'GTK3Agg', 'GTK3Cairo', 'GTK4Agg', 'GTK4Cairo',

'MacOSX',

'nbAgg',

'QtAgg', 'QtCairo', 'Qt5Agg', 'Qt5Cairo',

'TkAgg', 'TkCairo',

'WebAgg',

'WX', 'WXAgg', 'WXCairo',

def __init__(self, key, valid, ignorecase=False, *,

_deprecated_since=None):

"""*valid* is a list of legal strings."""

self.key = key

self.ignorecase = ignorecase

self._deprecated_since = _deprecated_since

def func(s):

if ignorecase:

return s.lower()

else:

return s

self.valid = {func(k): k for k in valid}

def __call__(self, s):

if self._deprecated_since:

name, = (k for k, v in globals().items() if v is self)

_api.warn_deprecated(

self._deprecated_since, name=name, obj_type="function")

if self.ignorecase:

s = s.lower()

if s in self.valid:

return self.valid[s]

msg = (f"{s!r} is not a valid value for {self.key}; supported values "

f"are {[*self.valid.values()]}")

if (isinstance(s, str)

and (s.startswith('"') and s.endswith('"')

or s.startswith("'") and s.endswith("'"))

and s[1:-1] in self.valid):

msg += "; remove quotes surrounding your string"

n=None, doc=None):

def f(s):

if isinstance(s, str):

try:

val = [scalar_validator(v.strip()) for v in s.split(',')

if v.strip()]

except Exception:

if allow_stringlist:

# Sometimes, a list of colors might be a single string

# of single-letter colornames. So give that a shot.

val = [scalar_validator(v.strip()) for v in s if v.strip()]

else:

raise

# Allow any ordered sequence type -- generators, np.ndarray, pd.Series

# -- but not sets, whose iteration order is non-deterministic.

elif np.iterable(s) and not isinstance(s, (set, frozenset)):

# The condition on this list comprehension will preserve the

# behavior of filtering out any empty strings (behavior was

# from the original validate_stringlist()), while allowing

# any non-string/text scalar values such as numbers and arrays.

val = [scalar_validator(v) for v in s

if not isinstance(v, str) or v]

else:

raise ValueError(

f"Expected str or other non-set iterable, but got {s}")

if n is not None and len(val) != n:

raise ValueError(

f"Expected {n} values, but there are {len(val)} values in {s}")

return val

try:

f.__name__ = "{}list".format(scalar_validator.__name__)

except AttributeError: # class instance.

f.__name__ = "{}List".format(type(scalar_validator).__name__)

f.__qualname__ = f.__qualname__.rsplit(".", 1)[0] + "." + f.__name__

f.__doc__ = doc if doc is not None else scalar_validator.__doc__

try:

np.datetime64(s)

return s

except ValueError:

raise ValueError(

"""Convert b to ``bool`` or raise."""

if isinstance(b, str):

b = b.lower()

if b in ('t', 'y', 'yes', 'on', 'true', '1', 1, True):

return True

elif b in ('f', 'n', 'no', 'off', 'false', '0', 0, False):

return False

else:

try:

return validate_bool(s)

except ValueError:

if isinstance(s, str):

if s == 'line':

return 'line'

raise ValueError('%s cannot be interpreted as'

"""Confirm s is string 'figure' or convert s to float or raise."""

if s == 'figure':

return s

try:

return float(s)

except ValueError as e:

raise ValueError(f'{s!r} is not string "figure" and '

"""

def validator(s):

if (allow_none and

(s is None or isinstance(s, str) and s.lower() == "none")):

return None

if cls is str and not isinstance(s, str):

_api.warn_deprecated(

"3.5", message="Support for setting an rcParam that expects a "

"str value to a non-str value is deprecated since %(since)s "

"and support will be removed %(removal)s.")

try:

return cls(s)

except (TypeError, ValueError) as e:

raise ValueError(

f'Could not convert {s!r} to {cls.__name__}') from e

validator.__name__ = f"validate_{cls.__name__}"

if allow_none:

validator.__name__ += "_or_None"

validator.__qualname__ = (

validator.__qualname__.rsplit(".", 1)[0] + "." + validator.__name__)

if isinstance(s, (str, os.PathLike)):

# Store value as str because savefig.directory needs to distinguish

# between "" (cwd) and "." (cwd, but gets updated by user selections).

return os.fsdecode(s)

else:

"""

fonttypes = {'type3': 3,

'truetype': 42}

try:

fonttype = validate_int(s)

except ValueError:

try:

return fonttypes[s.lower()]

except KeyError as e:

raise ValueError('Supported Postscript/PDF font types are %s'

% list(fonttypes)) from e

else:

if fonttype not in fonttypes.values():

raise ValueError(

'Supported Postscript/PDF font types are %s' %

list(fonttypes.values()))

backend = (

s if s is _auto_backend_sentinel or s.startswith("module://")

else _validate_standard_backends(s))

s = ValidateInStrings(

'toolbar', ['None', 'toolbar2', 'toolmanager'], ignorecase=True)(s)

if s == 'toolmanager':

_api.warn_external(

"Treat the new Tool classes introduced in v1.5 as experimental "

"for now; the API and rcParam may change in future versions.")

"""Return a valid color arg."""

if cbook._str_equal(s, 'inherit'):

return s

# N-th color cycle syntax can't go into the color cycle.

if isinstance(s, str) and re.match("^C[0-9]$", s):

raise ValueError(f"Cannot put cycle reference ({s!r}) in prop_cycler")

if cbook._str_equal(s, 'linecolor'):

return s

elif cbook._str_equal(s, 'mfc') or cbook._str_equal(s, 'markerfacecolor'):

return 'markerfacecolor'

elif cbook._str_equal(s, 'mec') or cbook._str_equal(s, 'markeredgecolor'):

return 'markeredgecolor'

elif s is None:

return None

elif isinstance(s, str) and len(s) == 6 or len(s) == 8:

stmp = '#' + s

if is_color_like(stmp):

return stmp

if s.lower() == 'none':

return None

elif is_color_like(s):

return s

"""Return a valid color arg."""

if isinstance(s, str):

if s.lower() == 'none':

return 'none'

if len(s) == 6 or len(s) == 8:

stmp = '#' + s

if is_color_like(stmp):

return stmp

if is_color_like(s):

return s

# If it is still valid, it must be a tuple (as a string from matplotlibrc).

try:

color = ast.literal_eval(s)

except (SyntaxError, ValueError):

pass

else:

if is_color_like(color):

return color

if s in ('auto', 'equal'):

return s

try:

return float(s)

except ValueError as e:

if s is None or s == 'None':

return None

else:

fontsizes = ['xx-small', 'x-small', 'small', 'medium', 'large',

'x-large', 'xx-large', 'smaller', 'larger']

if isinstance(s, str):

s = s.lower()

if s in fontsizes:

return s

try:

return float(s)

except ValueError as e:

raise ValueError("%s is not a valid font size. Valid font sizes "

weights = [

'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman',

'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black']

# Note: Historically, weights have been case-sensitive in Matplotlib

if s in weights:

return s

try:

return int(s)

except (ValueError, TypeError) as e:

_fallback_fonts = ['cm', 'stix', 'stixsans']

if isinstance(s, str):

s = s.lower()

if s is None or s == 'none':

return None

elif s.lower() in _fallback_fonts:

return s

else:

raise ValueError(

f"{s} is not a valid fallback font name. Valid fallback font "

f"names are {','.join(_fallback_fonts)}. Passing 'None' will turn "

try:

return _listify_validator(validate_float, n=2)(s)

except (TypeError, ValueError):

try:

return float(s)

except ValueError as e:

raise ValueError("Not a valid whisker value ['range', float, "

if isinstance(s, str):

s = s.lower()

if s in ('none', None, 'false', False):

return None

else:

"""

if isinstance(ls, str):

try: # Look first for a valid named line style, like '--' or 'solid'.

return _validate_named_linestyle(ls)

except ValueError:

pass

try:

ls = ast.literal_eval(ls) # Parsing matplotlibrc.

except (SyntaxError, ValueError):

pass # Will error with the ValueError at the end.

def _is_iterable_not_string_like(x):

# Explicitly exclude bytes/bytearrays so that they are not

# nonsensically interpreted as sequences of numbers (codepoints).

return np.iterable(x) and not isinstance(x, (str, bytes, bytearray))

if _is_iterable_not_string_like(ls):

if len(ls) == 2 and _is_iterable_not_string_like(ls[1]):

# (offset, (on, off, on, off, ...))

offset, onoff = ls

else:

# For backcompat: (on, off, on, off, ...); the offset is implicit.

offset = 0

onoff = ls

if (isinstance(offset, Number)

and len(onoff) % 2 == 0

and all(isinstance(elem, Number) for elem in onoff)):

return (offset, onoff)

"""

# Validate s against type slice float int and None

if isinstance(s, (slice, float, int, type(None))):

return s

# Validate s against type tuple

if isinstance(s, tuple):

if (len(s) == 2

and (all(isinstance(e, int) for e in s)

or all(isinstance(e, float) for e in s))):

return s

else:

raise TypeError(

"'markevery' tuple must be pair of ints or of floats")

# Validate s against type list

if isinstance(s, list):

if all(isinstance(e, int) for e in s):

return s

else:

raise TypeError(

"'markevery' list must have all elements of type int")

if isinstance(s, str):

s = s.lower()

if s == 'tight':

return s

if s == 'standard':

return None

raise ValueError("bbox should be 'tight' or 'standard'")

elif s is not None:

# Backwards compatibility. None is equivalent to 'standard'.

raise ValueError("bbox should be 'tight' or 'standard'")

if isinstance(s, str):

s = s.lower()

if s == 'none' or s is None:

return None

try:

return tuple(_listify_validator(validate_float, n=3)(s))

except ValueError:

s = validate_float(s)

if 0 <= s < 1:

return s

else:

s = validate_float(s)

if 0 <= s <= 1:

return s

else:

r"""

if not isinstance(s, str):

raise ValueError("Hatch pattern must be a string")

_api.check_isinstance(str, hatch_pattern=s)

unknown = set(s) - {'\\', '/', '|', '-', '+', '*', '.', 'x', 'o', 'O'}

if unknown:

raise ValueError("Unknown hatch symbol(s): %s" % list(unknown))

'color': _listify_validator(validate_color_for_prop_cycle,

allow_stringlist=True),

'linewidth': validate_floatlist,

'linestyle': _listify_validator(_validate_linestyle),

'facecolor': validate_colorlist,

'edgecolor': validate_colorlist,

'joinstyle': _listify_validator(JoinStyle),

'capstyle': _listify_validator(CapStyle),

'fillstyle': validate_fillstylelist,

'markerfacecolor': validate_colorlist,

'markersize': validate_floatlist,

'markeredgewidth': validate_floatlist,

'markeredgecolor': validate_colorlist,

'markevery': validate_markeverylist,

'alpha': validate_floatlist,

'marker': validate_stringlist,

'hatch': validate_hatchlist,

'dashes': validate_dashlist,

'c': 'color',

'lw': 'linewidth',

'ls': 'linestyle',

'fc': 'facecolor',

'ec': 'edgecolor',

'mfc': 'markerfacecolor',

'mec': 'markeredgecolor',

'mew': 'markeredgewidth',

'ms': 'markersize',

"""

if args and kwargs:

raise TypeError("cycler() can only accept positional OR keyword "

"arguments -- not both.")

elif not args and not kwargs:

raise TypeError("cycler() must have positional OR keyword arguments")

if len(args) == 1:

if not isinstance(args[0], Cycler):

raise TypeError("If only one positional argument given, it must "

"be a Cycler instance.")

return validate_cycler(args[0])

elif len(args) == 2:

pairs = [(args[0], args[1])]

elif len(args) > 2:

raise TypeError("No more than 2 positional arguments allowed")

else:

pairs = kwargs.items()

validated = []

for prop, vals in pairs:

norm_prop = _prop_aliases.get(prop, prop)

validator = _prop_validators.get(norm_prop, None)

if validator is None:

raise TypeError("Unknown artist property: %s" % prop)

vals = validator(vals)

# We will normalize the property names as well to reduce

# the amount of alias handling code elsewhere.

validated.append((norm_prop, vals))

def visit_Attribute(self, node):

if node.attr.startswith("__") and node.attr.endswith("__"):

raise ValueError("cycler strings with dunders are forbidden")

"""Return a Cycler object from a string repr or the object itself."""

if isinstance(s, str):

# TODO: We might want to rethink this...

# While I think I have it quite locked down, it is execution of

# arbitrary code without sanitation.

# Combine this with the possibility that rcparams might come from the

# internet (future plans), this could be downright dangerous.

# I locked it down by only having the 'cycler()' function available.

# UPDATE: Partly plugging a security hole.

# I really should have read this:

# https://nedbatchelder.com/blog/201206/eval_really_is_dangerous.html

# We should replace this eval with a combo of PyParsing and

# ast.literal_eval()

try:

_DunderChecker().visit(ast.parse(s))

s = eval(s, {'cycler': cycler, '__builtins__': {}})

except BaseException as e:

raise ValueError("'%s' is not a valid cycler construction: %s" %

(s, e)) from e

# Should make sure what comes from the above eval()

# is a Cycler object.

if isinstance(s, Cycler):

cycler_inst = s

else:

raise ValueError("object was not a string or Cycler instance: %s" % s)

unknowns = cycler_inst.keys - (set(_prop_validators) | set(_prop_aliases))

if unknowns:

raise ValueError("Unknown artist properties: %s" % unknowns)

# Not a full validation, but it'll at least normalize property names

# A fuller validation would require v0.10 of cycler.

checker = set()

for prop in cycler_inst.keys:

norm_prop = _prop_aliases.get(prop, prop)

if norm_prop != prop and norm_prop in cycler_inst.keys:

raise ValueError("Cannot specify both '{0}' and alias '{1}'"

" in the same prop_cycle".format(norm_prop, prop))

if norm_prop in checker:

raise ValueError("Another property was already aliased to '{0}'."

" Collision normalizing '{1}'.".format(norm_prop,

prop))

checker.update([norm_prop])

# This is just an extra-careful check, just in case there is some

# edge-case I haven't thought of.

assert len(checker) == len(cycler_inst.keys)

# Now, it should be safe to mutate this cycler

for prop in cycler_inst.keys:

norm_prop = _prop_aliases.get(prop, prop)

cycler_inst.change_key(prop, norm_prop)

for key, vals in cycler_inst.by_key().items():

_prop_validators[key](vals)

valid_strs = ["auto", "sturges", "fd", "doane", "scott", "rice", "sqrt"]

if isinstance(s, str) and s in valid_strs:

return s

try:

return int(s)

except (TypeError, ValueError):

pass

try:

return validate_floatlist(s)

except ValueError:

pass

raise ValueError("'hist.bins' must be one of {}, an int or"

if isinstance(conv, list):

ignorecase = isinstance(conv, _ignorecase)

return ValidateInStrings(key, conv, ignorecase=ignorecase)

else:

"backend": validate_backend,

"backend_fallback": validate_bool,

"toolbar": _validate_toolbar,

"interactive": validate_bool,

"timezone": validate_string,

"webagg.port": validate_int,

"webagg.address": validate_string,

"webagg.open_in_browser": validate_bool,

"webagg.port_retries": validate_int,

# line props

"lines.linewidth": validate_float, # line width in points

"lines.linestyle": _validate_linestyle, # solid line

"lines.color": validate_color, # first color in color cycle

"lines.marker": validate_string, # marker name

"lines.markerfacecolor": validate_color_or_auto, # default color

"lines.markeredgecolor": validate_color_or_auto, # default color

"lines.markeredgewidth": validate_float,

"lines.markersize": validate_float, # markersize, in points

"lines.antialiased": validate_bool, # antialiased (no jaggies)

"lines.dash_joinstyle": JoinStyle,

"lines.solid_joinstyle": JoinStyle,

"lines.dash_capstyle": CapStyle,

"lines.solid_capstyle": CapStyle,

"lines.dashed_pattern": validate_floatlist,

"lines.dashdot_pattern": validate_floatlist,

"lines.dotted_pattern": validate_floatlist,

"lines.scale_dashes": validate_bool,

# marker props

"markers.fillstyle": validate_fillstyle,

## pcolor(mesh) props:

"pcolor.shading": ["auto", "flat", "nearest", "gouraud"],

"pcolormesh.snap": validate_bool,

## patch props

"patch.linewidth": validate_float, # line width in points

"patch.edgecolor": validate_color,

"patch.force_edgecolor": validate_bool,

"patch.facecolor": validate_color, # first color in cycle

"patch.antialiased": validate_bool, # antialiased (no jaggies)

## hatch props

"hatch.color": validate_color,

"hatch.linewidth": validate_float,

## Histogram properties

"hist.bins": validate_hist_bins,

## Boxplot properties

"boxplot.notch": validate_bool,

"boxplot.vertical": validate_bool,

"boxplot.whiskers": validate_whiskers,

"boxplot.bootstrap": validate_int_or_None,

"boxplot.patchartist": validate_bool,

"boxplot.showmeans": validate_bool,

"boxplot.showcaps": validate_bool,

"boxplot.showbox": validate_bool,

"boxplot.showfliers": validate_bool,

"boxplot.meanline": validate_bool,

"boxplot.flierprops.color": validate_color,

"boxplot.flierprops.marker": validate_string,

"boxplot.flierprops.markerfacecolor": validate_color_or_auto,

"boxplot.flierprops.markeredgecolor": validate_color,

"boxplot.flierprops.markeredgewidth": validate_float,

"boxplot.flierprops.markersize": validate_float,

"boxplot.flierprops.linestyle": _validate_linestyle,

"boxplot.flierprops.linewidth": validate_float,

"boxplot.boxprops.color": validate_color,

"boxplot.boxprops.linewidth": validate_float,

"boxplot.boxprops.linestyle": _validate_linestyle,

"boxplot.whiskerprops.color": validate_color,

"boxplot.whiskerprops.linewidth": validate_float,

"boxplot.whiskerprops.linestyle": _validate_linestyle,

"boxplot.capprops.color": validate_color,

"boxplot.capprops.linewidth": validate_float,

"boxplot.capprops.linestyle": _validate_linestyle,

"boxplot.medianprops.color": validate_color,

"boxplot.medianprops.linewidth": validate_float,

"boxplot.medianprops.linestyle": _validate_linestyle,

"boxplot.meanprops.color": validate_color,

"boxplot.meanprops.marker": validate_string,

"boxplot.meanprops.markerfacecolor": validate_color,

"boxplot.meanprops.markeredgecolor": validate_color,

"boxplot.meanprops.markersize": validate_float,

"boxplot.meanprops.linestyle": _validate_linestyle,

"boxplot.meanprops.linewidth": validate_float,

## font props

"font.family": validate_stringlist, # used by text object

"font.style": validate_string,

"font.variant": validate_string,

"font.stretch": validate_string,

"font.weight": validate_fontweight,

"font.size": validate_float, # Base font size in points

"font.serif": validate_stringlist,

"font.sans-serif": validate_stringlist,

"font.cursive": validate_stringlist,

"font.fantasy": validate_stringlist,

"font.monospace": validate_stringlist,

# text props

"text.color": validate_color,

"text.usetex": validate_bool,

"text.latex.preamble": validate_string,

"text.hinting": ["default", "no_autohint", "force_autohint",

"no_hinting", "auto", "native", "either", "none"],

"text.hinting_factor": validate_int,

"text.kerning_factor": validate_int,

"text.antialiased": validate_bool,

"mathtext.cal": validate_font_properties,

"mathtext.rm": validate_font_properties,

"mathtext.tt": validate_font_properties,

"mathtext.it": validate_font_properties,

"mathtext.bf": validate_font_properties,

"mathtext.sf": validate_font_properties,

"mathtext.fontset": ["dejavusans", "dejavuserif", "cm", "stix",

"stixsans", "custom"],

"mathtext.default": ["rm", "cal", "it", "tt", "sf", "bf", "default",

"bb", "frak", "scr", "regular"],

"mathtext.fallback": _validate_mathtext_fallback,

"image.aspect": validate_aspect, # equal, auto, a number

"image.interpolation": validate_string,

"image.cmap": _validate_cmap, # gray, jet, etc.

"image.lut": validate_int, # lookup table

"image.origin": ["upper", "lower"],

"image.resample": validate_bool,

# Specify whether vector graphics backends will combine all images on a

# set of axes into a single composite image

"image.composite_image": validate_bool,

# contour props

"contour.negative_linestyle": _validate_linestyle,

"contour.corner_mask": validate_bool,

"contour.linewidth": validate_float_or_None,

# errorbar props

"errorbar.capsize": validate_float,

# axis props

# alignment of x/y axis title

"xaxis.labellocation": ["left", "center", "right"],

"yaxis.labellocation": ["bottom", "center", "top"],

# axes props

"axes.axisbelow": validate_axisbelow,

"axes.facecolor": validate_color, # background color

"axes.edgecolor": validate_color, # edge color

"axes.linewidth": validate_float, # edge linewidth

"axes.spines.left": validate_bool, # Set visibility of axes spines,

"axes.spines.right": validate_bool, # i.e., the lines around the chart

"axes.spines.bottom": validate_bool, # denoting data boundary.

"axes.spines.top": validate_bool,

"axes.titlesize": validate_fontsize, # axes title fontsize

"axes.titlelocation": ["left", "center", "right"], # axes title alignment

"axes.titleweight": validate_fontweight, # axes title font weight

"axes.titlecolor": validate_color_or_auto, # axes title font color

# title location, axes units, None means auto

"axes.titley": validate_float_or_None,

# pad from axes top decoration to title in points

"axes.titlepad": validate_float,

"axes.grid": validate_bool, # display grid or not

"axes.grid.which": ["minor", "both", "major"], # which grids are drawn

"axes.grid.axis": ["x", "y", "both"], # grid type

"axes.labelsize": validate_fontsize, # fontsize of x & y labels

"axes.labelpad": validate_float, # space between label and axis

"axes.labelweight": validate_fontweight, # fontsize of x & y labels

"axes.labelcolor": validate_color, # color of axis label

# use scientific notation if log10 of the axis range is smaller than the

# first or larger than the second

"axes.formatter.limits": _listify_validator(validate_int, n=2),

# use current locale to format ticks

"axes.formatter.use_locale": validate_bool,

"axes.formatter.use_mathtext": validate_bool,

# minimum exponent to format in scientific notation

"axes.formatter.min_exponent": validate_int,

"axes.formatter.useoffset": validate_bool,

"axes.formatter.offset_threshold": validate_int,

"axes.unicode_minus": validate_bool,

# This entry can be either a cycler object or a string repr of a

# cycler-object, which gets eval()'ed to create the object.

"axes.prop_cycle": validate_cycler,

# If "data", axes limits are set close to the data.

# If "round_numbers" axes limits are set to the nearest round numbers.

"axes.autolimit_mode": ["data", "round_numbers"],