'MacOSX',

'nbAgg',

'Qt4Agg', 'Qt4Cairo', 'Qt5Agg', 'Qt5Cairo',

'TkAgg', 'TkCairo',

'WebAgg',

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)

cbook.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:

"""Convert b to ``bool`` or raise, passing through *None*."""

if isinstance(b, str):

b = b.lower()

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

return None

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:

if s is None:

return

s = validate_string(s)

if s not in ['auto', 'concise']:

cbook._warn_external(f'date.converter string must be "auto" '

f'or "concise", not "{s}". Check your '

'matplotlibrc')

return

import matplotlib.dates as mdates

if s is None:

return

s = validate_bool(s)

import matplotlib.dates as mdates

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

cbook.warn_deprecated(

"3.3", message="Support for setting the 'text.latex.preamble' or "

"'pgf.preamble' rcParam to None is deprecated since %(since)s and "

"will be removed %(removal)s; set it to an empty string instead.")

return ""

try:

if isinstance(s, str):

return s

elif np.iterable(s):

cbook.warn_deprecated(

"3.3", message="Support for setting the 'text.latex.preamble' "

"or 'pgf.preamble' rcParam to a list of strings is deprecated "

"since %(since)s and will be removed %(removal)s; set it to a "

"single string instead.")

return '\n'.join(s)

else:

raise TypeError

except TypeError as e:

try:

return validate_bool(s)

except ValueError:

if isinstance(s, str):

if s == 'line':

return 'line'

if s.lower().startswith('line'):

cbook.warn_deprecated(

"3.3", message=f"Support for setting axes.axisbelow to "

f"{s!r} to mean 'line' is deprecated since %(since)s and "

f"will be removed %(removal)s; set it to 'line' instead.")

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

try:

return cls(s)

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

"""

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

def validator(s):

"""Convert *n* objects using ``cls``, or raise."""

if isinstance(s, str):

s = [x.strip() for x in s.split(',')]

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

raise ValueError(

f'Expected exactly {n} comma-separated values, '

f'but got {len(s)} comma-separated values: {s}')

else:

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

raise ValueError(

f'Expected exactly {n} values, '

f'but got {len(s)} values: {s}')

try:

return [cls(val) if not allow_none or val is not None else val

for val in s]

except ValueError as e:

raise ValueError(

f'Could not convert all entries to {cls.__name__}s') from e

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

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

"""

if isinstance(b, str):

b = b.lower()

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

return None

else:

cbook.warn_deprecated(

"3.3", message="Support for setting the 'mathtext.fallback_to_cm' "

"rcParam is deprecated since %(since)s and will be removed "

"%(removal)s; use 'mathtext.fallback : 'cm' instead.")

_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, "

'ps_papersize',

['auto', 'letter', 'legal', 'ledger',

'a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'a10',

'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'b9', 'b10',

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

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

if (_is_iterable_not_string_like(ls)

and len(ls) == 2

and isinstance(ls[0], (type(None), Number))

and _is_iterable_not_string_like(ls[1])

and len(ls[1]) % 2 == 0

and all(isinstance(elem, Number) for elem in ls[1])):

if ls[0] is None:

cbook.warn_deprecated(

"3.3", message="Passing the dash offset as None is deprecated "

"since %(since)s and support for it will be removed "

"%(removal)s; pass it as zero instead.")

ls = (0, ls[1])

return ls

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

if (_is_iterable_not_string_like(ls)

and len(ls) % 2 == 0

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

return (0, ls)

s_low = s.lower()

if s != s_low:

if s_low in ['miter', 'round', 'bevel']:

cbook.warn_deprecated(

"3.3", message="Case-insensitive capstyles are deprecated "

"since %(since)s and support for them will be removed "

"%(removal)s; please pass them in lowercase.")

elif s_low in ['butt', 'round', 'projecting']:

cbook.warn_deprecated(

"3.3", message="Case-insensitive joinstyles are deprecated "

"since %(since)s and support for them will be removed "

"%(removal)s; please pass them in lowercase.")

# Else, error out at the check_in_list stage.

"""

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

'legend_loc',

['best',

'upper right',

'upper left',

'lower left',

'lower right',

'right',

'center left',

'center right',

'lower center',

'upper center',

'text.hinting',

['default', 'no_autohint', 'force_autohint', 'no_hinting',

'auto', 'native', 'either', 'none'],

# writers.list() would only list actually available writers, but

# FFMpeg.isAvailable is slow and not worth paying for at every import.

if s in animation.writers._registered:

return s

else:

raise ValueError(f"Supported animation writers are "

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

cbook._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': validate_joinstylelist,

'capstyle': validate_capstylelist,

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

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

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

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

# ast.literal_eval()

try:

if '.__' in s.replace(' ', ''):

raise ValueError("'%s' seems to have dunder methods. Raising"

" an exception for your safety")

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 s is not None:

import socket

try:

socket.inet_aton(s)

except socket.error as e:

raise ValueError(

"'webagg.address' is not a valid IP address") from e

return s

if isinstance(conv, list):

ignorecase = isinstance(conv, _ignorecase)

return ValidateInStrings(key, conv, ignorecase=ignorecase)

else: