"return True if a is greater than or equal to b"

if a:

if six.PY3:

if isinstance(a, bytes):

a = a.decode('ascii')

if isinstance(b, bytes):

b = b.decode('ascii')

a = distutils.version.LooseVersion(a)

b = distutils.version.LooseVersion(b)

return a >= b

else:

"""

try:

p + '' # test is string like

except TypeError:

return False

# Test whether the operating system thinks it's a writable directory.

# Note that this check is necessary on Google App Engine, because the

# subsequent check will succeed even though p may not be writable.

if not os.access(p, os.W_OK) or not os.path.isdir(p):

return False

# Also test that it is actually possible to write to a file here.

try:

t = tempfile.TemporaryFile(dir=p)

try:

t.write(b'1')

finally:

t.close()

except:

return False

"""

levels = ('silent', 'helpful', 'debug', 'debug-annoying')

vald = dict([(level, i) for i, level in enumerate(levels)])

# parse the verbosity from the command line; flags look like

# --verbose-silent or --verbose-helpful

_commandLineVerbose = None

for arg in sys.argv[1:]:

# cast to str because we are using unicode_literals,

# and argv is always str

if not arg.startswith(str('--verbose-')):

continue

level_str = arg[10:]

# If it doesn't match one of ours, then don't even

# bother noting it, we are just a 3rd-party library

# to somebody else's script.

if level_str in levels:

_commandLineVerbose = level_str

def __init__(self):

self.set_level('silent')

self.fileo = sys.stdout

def set_level(self, level):

'set the verbosity to one of the Verbose.levels strings'

if self._commandLineVerbose is not None:

level = self._commandLineVerbose

if level not in self.levels:

warnings.warn('matplotlib: unrecognized --verbose-* string "%s".'

' Legal values are %s' % (level, self.levels))

else:

self.level = level

def set_fileo(self, fname):

std = {

'sys.stdout': sys.stdout,

'sys.stderr': sys.stderr,

}

if fname in std:

self.fileo = std[fname]

else:

try:

fileo = open(fname, 'w')

except IOError:

raise ValueError('Verbose object could not open log file "{0}"'

' for writing.\nCheck your matplotlibrc '

'verbose.fileo setting'.format(fname))

else:

self.fileo = fileo

def report(self, s, level='helpful'):

"""

if self.ge(level):

print(s, file=self.fileo)

return True

return False

def wrap(self, fmt, func, level='helpful', always=True):

"""

assert six.callable(func)

def wrapper(*args, **kwargs):

ret = func(*args, **kwargs)

if (always or not wrapper._spoke):

spoke = self.report(fmt % ret, level)

if not wrapper._spoke:

wrapper._spoke = spoke

return ret

wrapper._spoke = False

wrapper.__doc__ = func.__doc__

return wrapper

def ge(self, level):

'return true if self.level is >= level'

try:

s = subprocess.Popen(['dvipng', '-version'], stdout=subprocess.PIPE,

stderr=subprocess.PIPE)

stdout, stderr = s.communicate()

line = stdout.decode('ascii').split('\n')[1]

v = line.split()[-1]

return v

except (IndexError, ValueError, OSError):

if sys.platform == 'win32':

gs_execs = ['gswin32c', 'gswin64c', 'gs']

else:

gs_execs = ['gs']

for gs_exec in gs_execs:

try:

s = subprocess.Popen(

[gs_exec, '--version'], stdout=subprocess.PIPE,

stderr=subprocess.PIPE)

stdout, stderr = s.communicate()

if s.returncode == 0:

v = stdout[:-1].decode('ascii')

return gs_exec, v

except (IndexError, ValueError, OSError):

pass

try:

s = subprocess.Popen(['tex', '-version'], stdout=subprocess.PIPE,

stderr=subprocess.PIPE)

stdout, stderr = s.communicate()

line = stdout.decode('ascii').split('\n')[0]

pattern = '3\.1\d+'

match = re.search(pattern, line)

v = match.group(0)

return v

except (IndexError, ValueError, AttributeError, OSError):

try:

s = subprocess.Popen(['pdftops', '-v'], stdout=subprocess.PIPE,

stderr=subprocess.PIPE)

stdout, stderr = s.communicate()

lines = stderr.decode('ascii').split('\n')

for line in lines:

if 'version' in line:

v = line.split()[-1]

return v

except (IndexError, ValueError, UnboundLocalError, OSError):

try:

s = subprocess.Popen(['inkscape', '-V'], stdout=subprocess.PIPE,

stderr=subprocess.PIPE)

stdout, stderr = s.communicate()

lines = stdout.decode('ascii').split('\n')

for line in lines:

if 'Inkscape' in line:

v = line.split()[1]

break

return v

except (IndexError, ValueError, UnboundLocalError, OSError):

try:

s = subprocess.Popen(['xmllint', '--version'], stdout=subprocess.PIPE,

stderr=subprocess.PIPE)

stdout, stderr = s.communicate()

lines = stderr.decode('ascii').split('\n')

for line in lines:

if 'version' in line:

v = line.split()[-1]

break

return v

except (IndexError, ValueError, UnboundLocalError, OSError):

if not s:

return False

flag = True

gs_req = '7.07'

gs_sugg = '7.07'

gs_exec, gs_v = checkdep_ghostscript()

if compare_versions(gs_v, gs_sugg):

pass

elif compare_versions(gs_v, gs_req):

verbose.report(('ghostscript-%s found. ghostscript-%s or later '

'is recommended to use the ps.usedistiller option.')

% (gs_v, gs_sugg))

else:

flag = False

warnings.warn(('matplotlibrc ps.usedistiller option can not be used '

'unless ghostscript-%s or later is installed on your '

'system') % gs_req)

if s == 'xpdf':

pdftops_req = '3.0'

pdftops_req_alt = '0.9' # poppler version numbers, ugh

pdftops_v = checkdep_pdftops()

if compare_versions(pdftops_v, pdftops_req):

pass

elif (compare_versions(pdftops_v, pdftops_req_alt) and not

compare_versions(pdftops_v, '1.0')):

pass

else:

flag = False

warnings.warn(('matplotlibrc ps.usedistiller can not be set to '

'xpdf unless xpdf-%s or later is installed on '

'your system') % pdftops_req)

if flag:

return s

else:

if not s:

return False

tex_req = '3.1415'

gs_req = '7.07'

gs_sugg = '7.07'

dvipng_req = '1.5'

flag = True

tex_v = checkdep_tex()

if compare_versions(tex_v, tex_req):

pass

else:

flag = False

warnings.warn(('matplotlibrc text.usetex option can not be used '

'unless TeX-%s or later is '

'installed on your system') % tex_req)

dvipng_v = checkdep_dvipng()

if compare_versions(dvipng_v, dvipng_req):

pass

else:

flag = False

warnings.warn('matplotlibrc text.usetex can not be used with *Agg '

'backend unless dvipng-1.5 or later is '

'installed on your system')

gs_exec, gs_v = checkdep_ghostscript()

if compare_versions(gs_v, gs_sugg):

pass

elif compare_versions(gs_v, gs_req):

verbose.report(('ghostscript-%s found. ghostscript-%s or later is '

'recommended for use with the text.usetex '

'option.') % (gs_v, gs_sugg))

else:

flag = False

warnings.warn(('matplotlibrc text.usetex can not be used '

'unless ghostscript-%s or later is '

'installed on your system') % gs_req)

"""Find user's home directory if possible.

try:

if six.PY2 and sys.platform == 'win32':

path = os.path.expanduser(b"~").decode(sys.getfilesystemencoding())

else:

path = os.path.expanduser("~")

except ImportError:

# This happens on Google App Engine (pwd module is not present).

pass

else:

if os.path.isdir(path):

return path

for evar in ('HOME', 'USERPROFILE', 'TMP'):

path = os.environ.get(evar)

if path is not None and os.path.isdir(path):

return path

"""

import getpass

import tempfile

from matplotlib.cbook import mkdirs

try:

tempdir = tempfile.gettempdir()

except NotImplementedError:

# Some restricted platforms (such as Google App Engine) do not provide

# gettempdir.

return None

tempdir = os.path.join(tempdir, 'matplotlib-%s' % getpass.getuser())

os.environ['MPLCONFIGDIR'] = tempdir

mkdirs(tempdir)

"""

path = os.environ.get('XDG_CONFIG_HOME')

if path is None:

path = get_home()

if path is not None:

path = os.path.join(path, '.config')

"""

path = os.environ.get('XDG_CACHE_HOME')

if path is None:

path = get_home()

if path is not None:

path = os.path.join(path, '.cache')

from matplotlib.cbook import mkdirs

configdir = os.environ.get('MPLCONFIGDIR')

if configdir is not None:

configdir = os.path.abspath(configdir)

if not os.path.exists(configdir):

mkdirs(configdir)

if not _is_writable_dir(configdir):

return _create_tmp_config_dir()

return configdir

p = None

h = get_home()

if h is not None:

p = os.path.join(h, '.matplotlib')

if (sys.platform.startswith('linux') and xdg_base):

p = os.path.join(xdg_base, 'matplotlib')

if p is not None:

if os.path.exists(p):

if _is_writable_dir(p):

return p

else:

try:

mkdirs(p)

except OSError:

pass

else:

return p

"""

"""

if isinstance(path, bytes):

return path.decode(sys.getfilesystemencoding())

else:

'get the path to matplotlib data'

if 'MATPLOTLIBDATA' in os.environ:

path = os.environ['MATPLOTLIBDATA']

if not os.path.isdir(path):

raise RuntimeError('Path in environment MATPLOTLIBDATA not a '

'directory')

return path

_file = _decode_filesystem_path(__file__)

path = os.sep.join([os.path.dirname(_file), 'mpl-data'])

if os.path.isdir(path):

return path

# setuptools' namespace_packages may highjack this init file

# so need to try something known to be in matplotlib, not basemap

import matplotlib.afm

_file = _decode_filesystem_path(matplotlib.afm.__file__)

path = os.sep.join([os.path.dirname(_file), 'mpl-data'])

if os.path.isdir(path):

return path

# py2exe zips pure python, so still need special check

if getattr(sys, 'frozen', None):

exe_path = os.path.dirname(_decode_filesystem_path(sys.executable))

path = os.path.join(exe_path, 'mpl-data')

if os.path.isdir(path):

return path

# Try again assuming we need to step up one more directory

path = os.path.join(os.path.split(exe_path)[0], 'mpl-data')

if os.path.isdir(path):

return path

# Try again assuming sys.path[0] is a dir not a exe

path = os.path.join(sys.path[0], 'mpl-data')

if os.path.isdir(path):

return path

"""

raise NotImplementedError('get_example_data is deprecated -- use '

datapath = get_data_path()

_, tail = os.path.split(datapath)

d = {}

for root, _, files in os.walk(datapath):

# Need to explicitly remove cocoa_agg files or py2exe complains

# NOTE I dont know why, but do as previous version

if 'Matplotlib.nib' in files:

files.remove('Matplotlib.nib')

files = [os.path.join(root, filename) for filename in files]

root = root.replace(tail, 'mpl-data')

root = root[root.index('mpl-data'):]

d[root] = files

"""

if six.PY2:

cwd = os.getcwdu()

else:

cwd = os.getcwd()

fname = os.path.join(cwd, 'matplotlibrc')

if os.path.exists(fname):

return fname

if 'MATPLOTLIBRC' in os.environ:

path = os.environ['MATPLOTLIBRC']

if os.path.exists(path):

if os.path.isfile(path):

return path

fname = os.path.join(path, 'matplotlibrc')

if os.path.exists(fname):

return fname

configdir = _get_configdir()

if configdir is not None:

fname = os.path.join(configdir, 'matplotlibrc')

if os.path.exists(fname):

home = get_home()

if (sys.platform.startswith('linux') and

home is not None and

os.path.exists(os.path.join(

home, '.matplotlib', 'matplotlibrc'))):

warnings.warn(

"Found matplotlib configuration in ~/.matplotlib/. "

"To conform with the XDG base directory standard, "

"this configuration location has been deprecated "

"on Linux, and the new location is now %s/matplotlib/. "

"Please move your configuration there to ensure that "

"matplotlib will continue to find it in the future." %

_get_xdg_config_dir())

return os.path.join(

home, '.matplotlib', 'matplotlibrc')

return fname

path = get_data_path() # guaranteed to exist or raise

fname = os.path.join(path, 'matplotlibrc')

if not os.path.exists(fname):

warnings.warn('Could not find matplotlibrc; using defaults')

'text.fontstyle': ('font.style', lambda x: x, None),

'text.fontangle': ('font.style', lambda x: x, None),

'text.fontvariant': ('font.variant', lambda x: x, None),

'text.fontweight': ('font.weight', lambda x: x, None),

'text.fontsize': ('font.size', lambda x: x, None),

'tick.size': ('tick.major.size', lambda x: x, None),

'svg.embed_char_paths': ('svg.fonttype',

lambda x: "path" if x else "none", None),

'savefig.extension': ('savefig.format', lambda x: x, None),

'axes.color_cycle': ('axes.prop_cycle', lambda x: cycler('color', x),

lambda x: [c.get('color', None) for c in x]),

"""

validate = dict((key, converter) for key, (default, converter) in

six.iteritems(defaultParams)

if key not in _all_deprecated)

msg_depr = "%s is deprecated and replaced with %s; please use the latter."

msg_depr_ignore = "%s is deprecated and ignored. Use %s"

# validate values on the way in

def __init__(self, *args, **kwargs):

for k, v in six.iteritems(dict(*args, **kwargs)):

self[k] = v

def __setitem__(self, key, val):

try:

if key in _deprecated_map:

alt_key, alt_val, inverse_alt = _deprecated_map[key]

warnings.warn(self.msg_depr % (key, alt_key))

key = alt_key

val = alt_val(val)

elif key in _deprecated_ignore_map:

alt = _deprecated_ignore_map[key]

warnings.warn(self.msg_depr_ignore % (key, alt))

return

try:

cval = self.validate[key](val)

except ValueError as ve:

raise ValueError("Key %s: %s" % (key, str(ve)))

dict.__setitem__(self, key, cval)

except KeyError:

raise KeyError('%s is not a valid rc parameter.\

See rcParams.keys() for a list of valid parameters.' % (key,))

def __getitem__(self, key):

inverse_alt = None

if key in _deprecated_map:

alt_key, alt_val, inverse_alt = _deprecated_map[key]

warnings.warn(self.msg_depr % (key, alt_key))

key = alt_key

elif key in _deprecated_ignore_map:

alt = _deprecated_ignore_map[key]

warnings.warn(self.msg_depr_ignore % (key, alt))

key = alt

val = dict.__getitem__(self, key)

if inverse_alt is not None:

return inverse_alt(val)

else:

return val

# http://stackoverflow.com/questions/2390827

# (how-to-properly-subclass-dict-and-override-get-set)

# the default dict `update` does not use __setitem__

# so rcParams.update(...) (such as in seaborn) side-steps

# all of the validation over-ride update to force

# through __setitem__

def update(self, *args, **kwargs):

for k, v in six.iteritems(dict(*args, **kwargs)):

self[k] = v

def __repr__(self):

import pprint

class_name = self.__class__.__name__

indent = len(class_name) + 1

repr_split = pprint.pformat(dict(self), indent=1,

width=80 - indent).split('\n')

repr_indented = ('\n' + ' ' * indent).join(repr_split)

return '{0}({1})'.format(class_name, repr_indented)

def __str__(self):

return '\n'.join('{0}: {1}'.format(k, v)

for k, v in sorted(self.items()))

def keys(self):

"""

k = list(dict.keys(self))

k.sort()

return k

def values(self):

"""

return [self[k] for k in self.keys()]

def find_all(self, pattern):

"""

import re

pattern_re = re.compile(pattern)

return RcParams((key, value)

for key, value in self.items()

"""Return a :class:`matplotlib.RcParams` instance from the

fname = matplotlib_fname()

if not os.path.exists(fname):

# this should never happen, default in mpl-data should always be found

message = 'could not find rc file; returning defaults'

ret = RcParams([(key, default) for key, (default, _) in

six.iteritems(defaultParams)

if key not in _all_deprecated])

warnings.warn(message)

return ret

if is_url(fname):

f = urlopen(fname)