class RcParams(dict): """ A dictionary object including validation validating functions are defined and associated with rc parameters in :mod:`matplotlib.rcsetup` """ validate = dict([ (key, converter) for key, (default, converter) in \ defaultParams.items() ]) msg_depr = "%s is deprecated and replaced with %s; please use the latter." msg_depr_ignore = "%s is deprecated and ignored. Use %s" def __setitem__(self, key, val): try: if key in _deprecated_map: alt = _deprecated_map[key] warnings.warn(self.msg_depr % (key, alt)) key = alt elif key in _deprecated_ignore_map: alt = _deprecated_ignore_map[key] warnings.warn(self.msg_depr_ignore % (key, alt)) return cval = self.validate[key](val) 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): if key in _deprecated_map: alt = _deprecated_map[key] warnings.warn(self.msg_depr % (key, alt)) key = alt elif key in _deprecated_ignore_map: alt = _deprecated_ignore_map[key] warnings.warn(self.msg_depr_ignore % (key, alt)) key = alt return dict.__getitem__(self, key) def keys(self): """ Return sorted list of keys. """ k = list(dict.keys(self)) k.sort() return k def values(self): """ Return values in order of sorted keys. """ return [self[k] for k in self.keys()]
def rc_params(fail_on_error=False): 'Return the default params updated from the values in the rc file' 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, converter) in \ defaultParams.items() ]) warnings.warn(message) return ret return rc_params_from_file(fname, fail_on_error)
def rc_params(fail_on_error=False): """Return a :class:`matplotlib.RcParams` instance from the default matplotlib rc file. """ 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 \ defaultParams.items() ]) warnings.warn(message) return ret return rc_params_from_file(fname, fail_on_error)
def rc_params_from_file(fname, fail_on_error=False, use_default_template=True): """ Construct a `RcParams` from file *fname*. Parameters ---------- fname : str or path-like Name of file parsed for Matplotlib settings. fail_on_error : bool If True, raise an error when the parser fails to convert a parameter. use_default_template : bool If True, initialize with default parameters before updating with those in the given file. If False, the configuration class only contains the parameters specified in the file. (Useful for updating dicts.) """ config_from_file = _rc_params_in_file(fname, fail_on_error) if not use_default_template: return config_from_file iter_params = defaultParams.items() with cbook._suppress_matplotlib_deprecation_warning(): config = RcParams([(key, default) for key, (default, _) in iter_params if key not in _all_deprecated]) config.update(config_from_file) with cbook._suppress_matplotlib_deprecation_warning(): if config['datapath'] is None: config['datapath'] = _get_data_path() else: config['datapath'] = get_data_path(_from_rc=config['datapath']) if "".join(config['text.latex.preamble']): _log.info( """ ***************************************************************** You have the following UNSUPPORTED LaTeX preamble customizations: %s Please do not ask for support with these customizations active. ***************************************************************** """, '\n'.join(config['text.latex.preamble'])) _log.debug('loaded rc file %s', fname) return config
class RcParams(MutableMapping, dict): """ A dictionary object including validation. Validating functions are defined and associated with rc parameters in :mod:`matplotlib.rcsetup`. See Also -------- :ref:`customizing-with-matplotlibrc-files` """ validate = { key: converter for key, (default, converter) in defaultParams.items() if key not in _all_deprecated } # validate values on the way in def __init__(self, *args, **kwargs): self.update(*args, **kwargs) def __setitem__(self, key, val): try: if key in _deprecated_map: version, alt_key, alt_val, inverse_alt = _deprecated_map[key] cbook.warn_deprecated(version, name=key, obj_type="rcparam", alternative=alt_key) key = alt_key val = alt_val(val) elif key in _deprecated_remain_as_none and val is not None: version, = _deprecated_remain_as_none[key] cbook.warn_deprecated(version, name=key, obj_type="rcparam") elif key in _deprecated_ignore_map: version, alt_key = _deprecated_ignore_map[key] cbook.warn_deprecated(version, name=key, obj_type="rcparam", alternative=alt_key) return elif key == 'backend': if val is rcsetup._auto_backend_sentinel: if 'backend' in self: return try: cval = self.validate[key](val) except ValueError as ve: raise ValueError(f"Key {key}: {ve}") from None dict.__setitem__(self, key, cval) except KeyError: raise KeyError( f"{key} is not a valid rc parameter (see rcParams.keys() for " f"a list of valid parameters)") def __getitem__(self, key): if key in _deprecated_map: version, alt_key, alt_val, inverse_alt = _deprecated_map[key] cbook.warn_deprecated(version, name=key, obj_type="rcparam", alternative=alt_key) return inverse_alt(dict.__getitem__(self, alt_key)) elif key in _deprecated_ignore_map: version, alt_key = _deprecated_ignore_map[key] cbook.warn_deprecated(version, name=key, obj_type="rcparam", alternative=alt_key) return dict.__getitem__(self, alt_key) if alt_key else None elif key == "backend": val = dict.__getitem__(self, key) if val is rcsetup._auto_backend_sentinel: from matplotlib import pyplot as plt plt.switch_backend(rcsetup._auto_backend_sentinel) return dict.__getitem__(self, key) def __repr__(self): class_name = self.__class__.__name__ indent = len(class_name) + 1 with cbook._suppress_matplotlib_deprecation_warning(): repr_split = pprint.pformat(dict(self), indent=1, width=80 - indent).split('\n') repr_indented = ('\n' + ' ' * indent).join(repr_split) return '{}({})'.format(class_name, repr_indented) def __str__(self): return '\n'.join(map('{0[0]}: {0[1]}'.format, sorted(self.items()))) def __iter__(self): """Yield sorted list of keys.""" with cbook._suppress_matplotlib_deprecation_warning(): yield from sorted(dict.__iter__(self)) def __len__(self): return dict.__len__(self) def find_all(self, pattern): """ Return the subset of this RcParams dictionary whose keys match, using :func:`re.search`, the given ``pattern``. .. note:: Changes to the returned dictionary are *not* propagated to the parent RcParams dictionary. """ pattern_re = re.compile(pattern) return RcParams((key, value) for key, value in self.items() if pattern_re.search(key)) def copy(self): return {k: dict.__getitem__(self, k) for k in self}
%s Please do not ask for support with these customizations active. ***************************************************************** """, '\n'.join(config['text.latex.preamble'])) _log.debug('loaded rc file %s', fname) return config # this is the instance used by the matplotlib classes rcParams = rc_params() with cbook._suppress_matplotlib_deprecation_warning(): rcParamsOrig = RcParams(rcParams.copy()) rcParamsDefault = RcParams([ (key, default) for key, (default, converter) in defaultParams.items() if key not in _all_deprecated ]) if rcParams['axes.formatter.use_locale']: locale.setlocale(locale.LC_ALL, '') def rc(group, **kwargs): """ Set the current `.rcParams`. *group* is the grouping for the rc, e.g., for ``lines.linewidth`` the group is ``lines``, for ``axes.facecolor``, the group is ``axes``, and so on. Group may also be a list or tuple of group names, e.g., (*xtick*, *ytick*). *kwargs* is a dictionary attribute name/value pairs, e.g.,::
Please do not ask for support with these customizations active. ***************************************************************** """, '\n'.join(config['text.latex.preamble'])) _log.debug('loaded rc file %s', fname) return config # this is the instance used by the matplotlib classes rcParams = rc_params() with cbook._suppress_matplotlib_deprecation_warning(): rcParamsOrig = RcParams(rcParams.copy()) rcParamsDefault = RcParams([(key, default) for key, (default, converter) in defaultParams.items() if key not in _all_deprecated]) if rcParams['axes.formatter.use_locale']: locale.setlocale(locale.LC_ALL, '') def rc(group, **kwargs): """ Set the current `.rcParams`. *group* is the grouping for the rc, e.g., for ``lines.linewidth`` the group is ``lines``, for ``axes.facecolor``, the group is ``axes``, and so on. Group may also be a list or tuple of group names, e.g., (*xtick*, *ytick*). *kwargs* is a dictionary attribute name/value pairs, e.g.,:: rc('lines', linewidth=2, color='r')
def rc_params_from_file(fname, fail_on_error=False): """Load and return params from fname.""" cnt = 0 rc_temp = {} with open(fname) as fd: for line in fd: cnt += 1 strippedline = line.split('#',1)[0].strip() if not strippedline: continue tup = strippedline.split(':',1) if len(tup) !=2: warnings.warn('Illegal line #%d\n\t%s\n\tin file "%s"'%\ (cnt, line, fname)) continue key, val = tup key = key.strip() val = val.strip() if key in rc_temp: warnings.warn('Duplicate key in file "%s", line #%d'%(fname,cnt)) rc_temp[key] = (val, line, cnt) ret = RcParams([ (key, default) for key, (default, converter) in \ defaultParams.items() ]) for key in ('verbose.level', 'verbose.fileo'): if key in rc_temp: val, line, cnt = rc_temp.pop(key) if fail_on_error: ret[key] = val # try to convert to proper type or raise else: try: ret[key] = val # try to convert to proper type or skip except Exception as msg: warnings.warn('Bad val "%s" on line #%d\n\t"%s"\n\tin file \ "%s"\n\t%s' % (val, cnt, line, fname, msg)) verbose.set_level(ret['verbose.level']) verbose.set_fileo(ret['verbose.fileo']) for key, (val, line, cnt) in rc_temp.items(): if key in defaultParams: if fail_on_error: ret[key] = val # try to convert to proper type or raise else: try: ret[key] = val # try to convert to proper type or skip except Exception as msg: warnings.warn('Bad val "%s" on line #%d\n\t"%s"\n\tin file \ "%s"\n\t%s' % (val, cnt, line, fname, msg)) elif key in _deprecated_ignore_map: warnings.warn('%s is deprecated. Update your matplotlibrc to use %s instead.'% (key, _deprecated_ignore_map[key])) else: print(""" Bad key "%s" on line %d in %s. You probably need to get an updated matplotlibrc file from http://matplotlib.sf.net/_static/matplotlibrc or from the matplotlib source distribution""" % (key, cnt, fname), file=sys.stderr) if ret['datapath'] is None: ret['datapath'] = get_data_path() if not ret['text.latex.preamble'] == ['']: verbose.report(""" ***************************************************************** You have the following UNSUPPORTED LaTeX preamble customizations: %s Please do not ask for support with these customizations active. ***************************************************************** """% '\n'.join(ret['text.latex.preamble']), 'helpful') verbose.report('loaded rc file %s'%fname) return ret
# are allowed for the examples.directory parameter. # However, we will need to fully qualify the path because # Sphinx requires absolute paths. if not os.path.isabs(rcParams['examples.directory']): _basedir, _fname = os.path.split(matplotlib_fname()) # Sometimes matplotlib_fname() can return relative paths, # Also, using realpath() guarentees that Sphinx will use # the same path that matplotlib sees (in case of weird symlinks). _basedir = os.path.realpath(_basedir) _fullpath = os.path.join(_basedir, rcParams['examples.directory']) rcParams['examples.directory'] = _fullpath rcParamsOrig = rcParams.copy() rcParamsDefault = RcParams([ (key, default) for key, (default, converter) in \ defaultParams.items() ]) rcParams['ps.usedistiller'] = checkdep_ps_distiller(rcParams['ps.usedistiller']) rcParams['text.usetex'] = checkdep_usetex(rcParams['text.usetex']) if rcParams['axes.formatter.use_locale']: import locale locale.setlocale(locale.LC_ALL, '') def rc(group, **kwargs): """ Set the current rc params. Group is the grouping for the rc, eg. for ``lines.linewidth`` the group is ``lines``, for ``axes.facecolor``, the group is ``axes``, and so on. Group may also be a list or tuple of group names, eg. (*xtick*, *ytick*). *kwargs* is a dictionary attribute name/value pairs, eg::