'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 "%s": valid strings are %s'

def f(s):

if isinstance(s, six.string_types):

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, six.string_types) or v]

else:

raise ValueError("{!r} must be of type: string 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__ = 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, six.string_types):

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, six.string_types):

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 value is None:

return None # converted to True where accessed in figure.py,

# axes/_base.py

warnings.warn("axes.hold is deprecated, will be removed in 3.0",

mplDeprecation)

"""convert s to float or raise"""

try:

return float(s)

except ValueError:

"""convert s to float, None or raise"""

# values directly from the rc file can only be strings,

# so we need to recognize the string "None" and convert

# it into the object. We will be case-sensitive here to

# avoid confusion between string values of 'none', which

# can be a valid string value for some other parameters.

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

return None

try:

return float(s)

except ValueError:

"""convert s to string or raise"""

if s is None:

return None

try:

return validate_string(s)

except ValueError:

try:

return validate_bool(s)

except ValueError:

if isinstance(s, six.string_types):

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'

"""convert s to int or raise"""

try:

return int(s)

except ValueError:

"""if not None, tries to validate as an int"""

if s=='None':

s = None

if s is None:

return None

try:

return int(s)

except ValueError:

"""

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 six.itervalues(fonttypes):

raise ValueError(

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

list(six.itervalues(fonttypes)))

if s.startswith('module://'):

return s

else:

validator = ValidateInStrings(

'toolbar',

['None', 'toolbar2', 'toolmanager'],

ignorecase=True)

def __init__(self, n=None, allow_none=False):

self.n = n

self.allow_none = allow_none

def __call__(self, s):

"""return a seq of n floats or raise"""

if isinstance(s, six.string_types):

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

err_msg = _str_err_msg

else:

err_msg = _seq_err_msg

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

raise ValueError(err_msg.format(n=self.n, num=len(s), s=s))

try:

return [float(val)

if not self.allow_none or val is not None

else val

for val in s]

except ValueError:

def __init__(self, n=None):

self.n = n

def __call__(self, s):

"""return a seq of n ints or raise"""

if isinstance(s, six.string_types):

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

err_msg = _str_err_msg

else:

err_msg = _seq_err_msg

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

raise ValueError(err_msg.format(n=self.n, num=len(s), s=s))

try:

return [int(val) for val in s]

except ValueError:

'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, six.string_types):

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, six.string_types):

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 isinstance(s, (str, six.text_type)):

# Always leave str as str and unicode as unicode

return s

else:

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

return s

try:

return float(s)

except ValueError:

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

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

if isinstance(s, six.string_types):

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 "

if s == 'range':

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

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, six.string_types):

s = s.lower()

if s in ('none', None):

return None

elif s in ('false', False):

return False

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

return s

else:

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

try:

res = validate_negative_linestyle(s)

return res

except ValueError:

dashes = validate_nseq_float(2)(s)

'legend_loc',

['best',

'upper right',

'upper left',

'lower left',

'lower right',

'right',

'center left',

'center right',

'lower center',

'upper center',

if s in ["none", "path"]:

return s

if s == "svgfont":

cbook.warn_deprecated(

"2.2", "'svgfont' support for svg.fonttype is deprecated.")

return s

raise ValueError("Unrecognized svg.fonttype string '{}'; "

if s in (True, False):

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, six.string_types):

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, six.string_types):

s = s.lower()

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

return None

if isinstance(s, six.string_types):

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

"""

if not isinstance(s, six.string_types):

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

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,

'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 = six.iteritems(kwargs)

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, six.string_types):

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)

if isinstance(s, six.string_types) and s == 'auto':

return s

try:

return int(s)

except (TypeError, ValueError):

pass

try:

return validate_floatlist(s)

except ValueError:

pass

raise ValueError("'hist.bins' must be 'auto', 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)

if not isinstance(p, six.string_types):

raise ValueError("path must be a (unicode) string")

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 as e:

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

return s

list(six.iterkeys(ls_mapper)) +

list(six.itervalues(ls_mapper)) +

['None', 'none', ' ', ''],

"""

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

if isinstance(ls, six.string_types):

try:

return _validate_named_linestyle(ls)

except (UnicodeDecodeError, KeyError):

# On Python 2, string-like *ls*, like for example

# 'solid'.encode('utf-16'), may raise a unicode error.

raise ValueError("the linestyle string {!r} is not a valid "

"string.".format(ls))

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

# On Python 2, a string-like *ls* should already have lead to a

# successful return or to raising an exception. On Python 3, we have

# to manually raise an exception in the case of a byte-like *ls*.

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

raise ValueError("linestyle {!r} neither looks like an on-off ink "

"sequence nor a valid string.".format(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.

raise ValueError("linestyle {!r} is not a valid on-off ink "

'backend': ['Agg', validate_backend], # agg is certainly

# present

'backend_fallback': [True, validate_bool], # agg is certainly present

'backend.qt4': [None, validate_qt4],

'backend.qt5': [None, validate_qt5],

'webagg.port': [8988, validate_int],

'webagg.address': ['127.0.0.1', validate_webagg_address],

'webagg.open_in_browser': [True, validate_bool],

'webagg.port_retries': [50, validate_int],

'nbagg.transparent': [True, validate_bool],

'toolbar': ['toolbar2', validate_toolbar],

'datapath': [None, validate_path_exists], # handled by

# _get_data_path_cached

'interactive': [False, validate_bool],

'timezone': ['UTC', validate_string],

# the verbosity setting

'verbose.level': ['silent', validate_verbose],

'verbose.fileo': ['sys.stdout', validate_string],

# line props

'lines.linewidth': [1.5, validate_float], # line width in points

'lines.linestyle': ['-', _validate_linestyle], # solid line

'lines.color': ['C0', validate_color], # first color in color cycle

'lines.marker': ['None', validate_string], # marker name

'lines.markeredgewidth': [1.0, validate_float],

'lines.markersize': [6, validate_float], # markersize, in points

'lines.antialiased': [True, validate_bool], # antialiased (no jaggies)

'lines.dash_joinstyle': ['round', validate_joinstyle],

'lines.solid_joinstyle': ['round', validate_joinstyle],

'lines.dash_capstyle': ['butt', validate_capstyle],

'lines.solid_capstyle': ['projecting', validate_capstyle],

'lines.dashed_pattern': [[3.7, 1.6], validate_nseq_float(allow_none=True)],

'lines.dashdot_pattern': [[6.4, 1.6, 1, 1.6],

validate_nseq_float(allow_none=True)],

'lines.dotted_pattern': [[1, 1.65], validate_nseq_float(allow_none=True)],

'lines.scale_dashes': [True, validate_bool],

# marker props

'markers.fillstyle': ['full', validate_fillstyle],

## patch props

'patch.linewidth': [1.0, validate_float], # line width in points

'patch.edgecolor': ['k', validate_color],

'patch.force_edgecolor' : [False, validate_bool],

'patch.facecolor': ['C0', validate_color], # first color in cycle

'patch.antialiased': [True, validate_bool], # antialiased (no jaggies)

## hatch props

'hatch.color': ['k', validate_color],

'hatch.linewidth': [1.0, validate_float],

## Histogram properties

'hist.bins': [10, validate_hist_bins],