'MacOSX',

'nbAgg',

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

'TkAgg', 'TkCairo',

'WebAgg',

def __init__(self, key, valid, ignorecase=False):

'valid is a list of legal strings'

self.key = key

self.ignorecase = ignorecase

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

s = s.lower()

if s in self.valid:

return self.valid[s]

raise ValueError('Unrecognized %s string %r: valid strings are %s'

def f(s):

if isinstance(s, str):

try:

return [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.

return [scalar_validator(v.strip())

for v in s if v.strip()]

else:

raise

# We should allow any generic sequence type, including generators,

# Numpy ndarrays, and pandas data structures. However, unordered

# sequences, such as sets, should be allowed but discouraged unless the

# user desires pseudorandom behavior.

elif isinstance(s, Iterable) and not isinstance(s, Mapping):

# 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.

return [scalar_validator(v) for v in s

if not isinstance(v, str) or v]

else:

raise ValueError("{!r} must be of type: str or non-dictionary "

"iterable".format(s))

try:

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

except AttributeError: # class instance.

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

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

"""If s is a path, return s, else False"""

if s is None:

return None

if os.path.exists(s):

return s

else:

"""Convert b to a boolean 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 a boolean or raise."""

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 or s == 'None':

return ""

try:

if isinstance(s, str):

return s

elif isinstance(s, Iterable):

return '\n'.join(s)

else:

raise TypeError

except TypeError:

try:

return validate_bool(s)

except ValueError:

if isinstance(s, str):

s = s.lower()

if s.startswith('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:

raise ValueError('"%s" is not string "figure" or'

"""

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:

raise ValueError(f'Could not convert {s!r} to {cls.__name__}')

"""

fonttypes = {'type3': 3,

'truetype': 42}

try:

fonttype = validate_int(s)

except ValueError:

try:

return fonttypes[s.lower()]

except KeyError:

raise ValueError(

'Supported Postscript/PDF font types are %s' % list(fonttypes))

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:

raise ValueError(

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

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

if s == 'inherit':

return s

# Special-case the N-th color cycle syntax, this obviously can not

# go in the color cycle.

if isinstance(s, bytes):

match = re.match(b'^C[0-9]$', s)

if match is not None:

raise ValueError('Can not put cycle reference ({cn!r}) in '

'prop_cycler'.format(cn=s))

elif isinstance(s, str):

match = re.match('^C[0-9]$', s)

if match is not None:

raise ValueError('Can not put cycle reference ({cn!r}) in '

'prop_cycler'.format(cn=s))

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

try:

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

return 'none'

except AttributeError:

pass

if isinstance(s, str):

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.

colorarg = s

msg = ''

if s.find(',') >= 0:

# get rid of grouping symbols

stmp = ''.join([c for c in s if c.isdigit() or c == '.' or c == ','])

vals = stmp.split(',')

if len(vals) not in [3, 4]:

msg = '\nColor tuples must be of length 3 or 4'

else:

try:

colorarg = [float(val) for val in vals]

except ValueError:

msg = '\nCould not convert all entries to floats'

if not msg and is_color_like(colorarg):

return colorarg

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

return s

try:

return float(s)

except ValueError:

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:

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

if s == "circled":

cbook.warn_deprecated(

"3.1", message="Support for setting the mathtext.default rcParam "

"to 'circled' is deprecated since %(since)s and will be removed "

"%(removal)s.")

return ValidateInStrings(

'default',

if s == 'range':

cbook.warn_deprecated(

"3.2", message="Support for setting the boxplot.whiskers rcParam "

"to 'range' is deprecated since %(since)s and will be removed "

"%(removal)s; set it to 0, 100 instead.")

return 'range'

else:

try:

v = validate_nseq_float(2)(s)

return v

except (TypeError, ValueError):

try:

v = float(s)

return v

except ValueError:

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

# The old savefig.extension could also have a value of "auto", but

# the new savefig.format does not. We need to fix this here.

value = validate_string(value)

if value == 'auto':

cbook.warn_deprecated(

"3.2", message="Support for setting the 'savefig.format' rcParam "

"to 'auto' is deprecated since %(since)s and will be removed "

"%(removal)s; set it to 'png' instead.")

value = 'png'

# The old savefig.extension could also have a value of "auto", but

# the new savefig.format does not. We need to fix this here.

value = validate_string(value)

if value == 'auto':

cbook.warn_deprecated(

"3.2", message="Support for setting the 'savefig.format' rcParam "

"to 'auto' is deprecated since %(since)s and will be removed "

"%(removal)s; set it to 'png' instead.")

value = 'png'

'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

elif s in ('ghostscript', 'xpdf'):

try:

mpl._get_executable_info("gs")

except mpl.ExecutableNotFoundError:

_log.warning("Setting rcParams['ps.usedistiller'] requires "

"ghostscript.")

return None

if s == "xpdf":

try:

mpl._get_executable_info("pdftops")

except mpl.ExecutableNotFoundError:

_log.warning("Setting rcParams['ps.usedistiller'] to 'xpdf' "

"requires xpdf.")

return None

return s

else:

raise ValueError('matplotlibrc ps.usedistiller must either be none, '

"""

# 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',

if s in (True, False):

cbook.warn_deprecated(

"3.2", message="Support for setting the text.hinting rcParam to "

"True or False is deprecated since %(since)s and will be removed "

"%(removal)s; set it to its synonyms 'auto' or 'none' instead.")

return s

if s.lower() in ('auto', 'native', 'either', 'none'):

return s.lower()

['ffmpeg', 'ffmpeg_file',

'avconv', 'avconv_file',

'imagemagick', 'imagemagick_file',

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

if isinstance(s, str):

result = tuple([float(v.strip()) for v in s.split(',')])

elif isinstance(s, (list, tuple)):

result = tuple([float(v) for v in s])

if len(result) != 3:

raise ValueError("path.sketch must be a tuple (scale, length, randomness)")

"""

def __init__(self, vmin, vmax, closedmin=True, closedmax=True):

self.vmin = vmin

self.vmax = vmax

self.cmin = closedmin

self.cmax = closedmax

def __call__(self, s):

try:

s = float(s)

except ValueError:

raise RuntimeError('Value must be a float; found "%s"' % s)

if self.cmin and s < self.vmin:

raise RuntimeError('Value must be >= %f; found "%f"' %

(self.vmin, s))

elif not self.cmin and s <= self.vmin:

raise RuntimeError('Value must be > %f; found "%f"' %

(self.vmin, s))

if self.cmax and s > self.vmax:

raise RuntimeError('Value must be <= %f; found "%f"' %

(self.vmax, s))

elif not self.cmax and s >= self.vmax:

raise RuntimeError('Value must be < %f; found "%f"' %

(self.vmax, s))

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': validate_stringlist,

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

try:

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

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

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

# Make sure it's a string and then figure out if the animations

# are already loaded and reset the writers (which will validate

# the path on next call)

cbook._check_isinstance(str, path=p)

from sys import modules

# set dirty, so that the next call to the registry will re-evaluate

# the state.

# only set dirty if already loaded. If not loaded, the load will

# trigger the checks.

if "matplotlib.animation" in modules:

modules["matplotlib.animation"].writers.set_dirty()

if s is not None:

import socket

try:

socket.inet_aton(s)

except socket.error:

raise ValueError("'webagg.address' is not a valid IP address")

return s

"""

# Look first for a valid named line style, like '--' or 'solid' Also

# includes bytes(-arrays) here (they all fail _validate_named_linestyle);

# otherwise, if *ls* is of even-length, it will be passed to the instance

# of validate_nseq_float, which will return an absurd on-off ink

# sequence...

if isinstance(ls, (str, bytes, bytearray)):

return _validate_named_linestyle(ls)

# Look for an on-off ink sequence (in points) *of even length*.

# Offset is set to None.

try:

if len(ls) % 2 != 0:

raise ValueError("the linestyle sequence {!r} is not of even "

"length.".format(ls))

return (None, validate_nseq_float()(ls))

except (ValueError, TypeError):

# TypeError can be raised inside the instance of validate_nseq_float,

# by wrong types passed to float(), like NoneType.