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 = dict([(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, abc.Iterable) and not isinstance(s, abc.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:

msg = "{0!r} must be of type: string or non-dictionary iterable.".format(s)

raise ValueError(msg)

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:

"""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 six.text_type(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:

if s.lower() in six.iterkeys(fonttypes):

return fonttypes[s.lower()]

raise ValueError(

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

list(six.iterkeys(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)

# 2008/12/12: start warning; later, remove all traces of maskedarray

try:

if v == 'obsolete':

return v

except ValueError:

pass

warnings.warn('rcParams key "maskedarray" is obsolete and has no effect;\n'

def __init__(self, n=None):

self.n = n

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

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

return s

stmp = '#' + s

if is_color_like(stmp):

return stmp

# 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) != 3:

msg = '\nColor tuples must be length 3'

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:

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:

try:

v = float(s)

return v

except:

err_str = ("Not a valid whisker value ['range',"

"float, (float, 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 = six.text_type(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)

warnings.warn("Deprecated negative_linestyle specification; use "

"'solid' or 'dashed'")

if s == 'legacy':

return s

else:

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

return s

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

return s.lower()

['ffmpeg', 'ffmpeg_file',

'avconv', 'avconv_file',

'mencoder', 'mencoder_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:

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

unique_chars = set(s)

unknown = (unique_chars -

set(['\\', '/', '|', '-', '+', '*', '.', '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,

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

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

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

# present

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

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

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

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

'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', six.text_type],

# the verbosity setting

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

'verbose.fileo': ['sys.stdout', six.text_type],

# line props

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

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

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

'lines.marker': ['None', six.text_type], # black

'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': [[2.8, 1.2], validate_nseq_float()],

'lines.dashdot_pattern': [[4.8, 1.2, 0.8, 1.2], validate_nseq_float()],

'lines.dotted_pattern': [[1.2, 0.6], validate_nseq_float()],

# marker props

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

## patch props

'patch.linewidth': [None, validate_float_or_None], # line width in points

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

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

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

## hatch props

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

## Histogram properties

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

## Boxplot properties

'boxplot.notch': [False, validate_bool],

'boxplot.vertical': [True, validate_bool],

'boxplot.whiskers': [1.5, validate_whiskers],

'boxplot.bootstrap': [None, validate_int_or_None],

'boxplot.patchartist': [False, validate_bool],

'boxplot.showmeans': [False, validate_bool],

'boxplot.showcaps': [True, validate_bool],

'boxplot.showbox': [True, validate_bool],

'boxplot.showfliers': [True, validate_bool],

'boxplot.meanline': [False, validate_bool],

'boxplot.flierprops.color': ['C0', validate_color],

'boxplot.flierprops.marker': ['+', six.text_type],

'boxplot.flierprops.markerfacecolor': ['auto', validate_color_or_auto],

'boxplot.flierprops.markeredgecolor': ['k', validate_color],

'boxplot.flierprops.markersize': [6, validate_float],

'boxplot.flierprops.linestyle': ['none', six.text_type],

'boxplot.flierprops.linewidth': [1.0, validate_float],

'boxplot.boxprops.color': ['C0', validate_color],

'boxplot.boxprops.linewidth': [1.0, validate_float],

'boxplot.boxprops.linestyle': ['-', six.text_type],

'boxplot.whiskerprops.color': ['C0', validate_color],

'boxplot.whiskerprops.linewidth': [1.0, validate_float],

'boxplot.whiskerprops.linestyle': ['--', six.text_type],

'boxplot.capprops.color': ['k', validate_color],

'boxplot.capprops.linewidth': [1.0, validate_float],

'boxplot.capprops.linestyle': ['-', six.text_type],

'boxplot.medianprops.color': ['C1', validate_color],

'boxplot.medianprops.linewidth': [1.0, validate_float],

'boxplot.medianprops.linestyle': ['-', six.text_type],

'boxplot.meanprops.color': ['r', validate_color],

'boxplot.meanprops.linewidth': [1.0, validate_float],

'boxplot.meanprops.linestyle': ['-', six.text_type],

## font props

'font.family': [['sans-serif'], validate_stringlist], # used by text object

'font.style': ['normal', six.text_type],

'font.variant': ['normal', six.text_type],

'font.stretch': ['normal', six.text_type],

'font.weight': ['normal', six.text_type],

'font.size': [12, validate_float], # Base font size in points

'font.serif': [['DejaVu Serif', 'Bitstream Vera Serif',

'New Century Schoolbook', 'Century Schoolbook L',

'Utopia', 'ITC Bookman', 'Bookman',

'Nimbus Roman No9 L', 'Times New Roman',

'Times', 'Palatino', 'Charter', 'serif'],

validate_stringlist],

'font.sans-serif': [['DejaVu Sans', 'Bitstream Vera Sans',

'Lucida Grande', 'Verdana', 'Geneva', 'Lucid',

'Arial', 'Helvetica', 'Avant Garde', 'sans-serif'],

validate_stringlist],

'font.cursive': [['Apple Chancery', 'Textile', 'Zapf Chancery',

'Sand', 'Script MT', 'Felipa', 'cursive'],

validate_stringlist],

'font.fantasy': [['Comic Sans MS', 'Chicago', 'Charcoal', 'Impact'

'Western', 'Humor Sans', 'fantasy'],

validate_stringlist],

'font.monospace': [['DejaVu Sans Mono', 'Bitstream Vera Sans Mono',

'Andale Mono', 'Nimbus Mono L', 'Courier New',

'Courier', 'Fixed', 'Terminal', 'monospace'],

validate_stringlist],

# text props