"""Function to create a list

if isstring(l):

return [l]

try:

return list(l)

except TypeError:

"""Class that keeps week reference to the base dictionary

@property

def data(self):

"""Dictionary representing this :class:`SubDict` instance

return dict(self.iteritems())

@property

def replace(self):

""":class:`bool`. If True, matching strings in the :attr:`base_str`

return self._replace

@replace.setter

def replace(self, value):

def replace_base(key):

for pattern in self.patterns:

try:

return pattern.match(key).group('key')

except AttributeError: # if match is None

pass

raise KeyError(

"Could not find any matching key for %s in the base "

"dictionary!" % key)

value = bool(value)

if hasattr(self, '_replace') and value == self._replace:

return

if not hasattr(self, '_replace'):

self._replace = value

return

# if the value has changed, we change the key in the SubDict instance

# to match the ones in the base dictionary (if they exist)

for key, val in DictMethods.iteritems(self):

try:

if value:

new_key = replace_base(key)

else:

new_key = self._get_val_and_base(key)[0]

except KeyError:

continue

else:

dict.__setitem__(self, new_key, dict.pop(self, key))

self._replace = value

#: :class:`dict`. Reference dictionary

base = {}

#: list of strings. The strings that are used to set and get a specific key

#: from the :attr:`base` dictionary

base_str = []

#: list of compiled patterns from the :attr:`base_str` attribute, that

#: are used to look for the matching keys in :attr:`base`

patterns = []

#: :class:`bool`. If True, changes are traced back to the :attr:`base` dict

trace = False

@docstrings.get_sections(base='SubDict.add_base_str')

@dedent

def add_base_str(self, base_str, pattern='.+', pattern_base=None,

append=True):

"""

base_str = safe_list(base_str)

pattern_base = safe_list(pattern_base or [])

for i, s in enumerate(base_str):

if '%(key)s' not in s:

base_str[i] += '%(key)s'

if pattern_base:

for i, s in enumerate(pattern_base):

if '%(key)s' not in s:

pattern_base[i] += '%(key)s'

else:

pattern_base = base_str

self.base_str = base_str + self.base_str

self.patterns = list(map(lambda s: re.compile(s.replace(

'%(key)s', '(?P<key>%s)' % pattern)), pattern_base)) + \

self.patterns

docstrings.delete_params('SubDict.add_base_str.parameters', 'append')

@docstrings.get_sections(base='SubDict')

@docstrings.dedent

def __init__(self, base, base_str, pattern='.+', pattern_base=None,

trace=False, replace=True):

"""

self.base = base

self.base_str = []

self.patterns = []

self.replace = bool(replace)

self.trace = bool(trace)

self.add_base_str(base_str, pattern=pattern, pattern_base=pattern_base,

append=False)

def __getitem__(self, key):

if key in DictMethods.iterkeys(self):

return dict.__getitem__(self, key)

if not self.replace:

return self.base[key]

return self._get_val_and_base(key)[1]

def __setitem__(self, key, val):

# set it in the SubDict instance if trace is False

if not self.trace:

dict.__setitem__(self, key, val)

return

base = self.base

# set it with the given key, if trace is True

if not self.replace:

base[key] = val

dict.pop(self, key, None)

return

# first look if the key already exists in the base dictionary

for s, patt in self._iter_base_and_pattern(key):

m = patt.match(s)

if m and s in base:

base[m.group()] = val

return

# if the key does not exist, we set it

self.base[key] = val

def _get_val_and_base(self, key):

found = False

e = None

for s, patt in self._iter_base_and_pattern(key):

found = True

try:

m = patt.match(s)

if m:

return m.group(), self.base[m.group()]

else:

raise KeyError(

"{0} does not match the specified pattern!".format(

s))

except KeyError as e:

pass

if not found:

if e is not None:

raise

raise KeyError("{0} does not match the specified pattern!".format(

key))

def _iter_base_and_pattern(self, key):

return zip(

map(lambda s: safe_modulo(s, {'key': key}), self.base_str),

self.patterns)

def iterkeys(self):

"""Unsorted iterator over keys"""

patterns = self.patterns

replace = self.replace

seen = set()

for key in six.iterkeys(self.base):

for pattern in patterns:

m = pattern.match(key)

if m:

ret = m.group('key') if replace else m.group()

if ret not in seen:

seen.add(ret)

yield ret

break

for key in DictMethods.iterkeys(self):

if key not in seen:

yield key

def iteritems(self):

"""Unsorted iterator over items"""

return ((key, self[key]) for key in self.iterkeys())

def itervalues(self):

"""Unsorted iterator over values"""

return (val for key, val in self.iteritems())

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

"""Update the dictionary"""

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

"""A dictionary object including validation

@property

def validate(self):

"""Dictionary with validation methods as values"""

depr = self._all_deprecated

return dict((key, val[1]) for key, val in

six.iteritems(self.defaultParams)

if key not in depr)

@property

def descriptions(self):

"""The description of each keyword in the rcParams dictionary"""

return {key: val[2] for key, val in six.iteritems(self.defaultParams)

if len(val) >= 3}

HEADER = """Configuration parameters of the psyplot module

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

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

#: possible connections that shall be called if the rcParams value change

_connections = defaultdict(list)

#: the names of the entry points that are loaded during the

#: :meth:`load_plugins` method

_plugins = []

@property

def _all_deprecated(self):

return set(chain(self._deprecated_ignore_map, self._deprecated_map))

@property

def defaultParams(self):

return getattr(self, '_defaultParams', defaultParams)

@defaultParams.setter

def defaultParams(self, value):

self._defaultParams = value

@defaultParams.deleter

def defaultParams(self):

del self._defaultParams

# validate values on the way in

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

"""

defaultParams = kwargs.pop('defaultParams', None)

if defaultParams is not None:

self.defaultParams = defaultParams

self._deprecated_map = {}

self._deprecated_ignore_map = {}

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

try:

self[k] = v

except (ValueError, RuntimeError):

# force the issue

warn(_rcparam_warn_str.format(key=repr(k), value=repr(v),

func='__init__'))

dict.__setitem__(self, k, v)

def __setitem__(self, key, val):

key, val = self._get_depreceated(key, val)

if key is None:

return

try:

cval = self.validate[key](val)

except ValueError as ve:

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

dict.__setitem__(self, key, cval)

for func in self._connections.get(key, []):

func(cval)

def _get_depreceated(self, key, *args):

if key in self._deprecated_map:

alt_key, alt_val = self._deprecated_map[key]

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

key = alt_key

return key, alt_val(args[0]) if args else None

elif key in self._deprecated_ignore_map:

alt = self._deprecated_ignore_map[key]

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

return None, None

elif key not in self.defaultParams:

raise KeyError(

'%s is not a valid rc parameter. See rcParams.keys() for a '

'list of valid parameters.' % (key,))

return key, args[0] if args else None

def __getitem__(self, key):

key = self._get_depreceated(key)[0]

if key is not None:

return dict.__getitem__(self, key)

def connect(self, key, func):

"""Connect a function to the given formatoption

key = self._get_depreceated(key)[0]

if key is not None:

self._connections[key].append(func)

def disconnect(self, key=None, func=None):

"""Disconnect the connections to the an rcParams key

if key is None:

for key, connections in self._connections.items():

for conn in connections[:]:

if func is None or conn is func:

connections.remove(conn)

else:

connections = self._connections[key]

for conn in connections[:]:

if func is None or conn is func:

connections.remove(conn)

def remove(self, key, func):

key = self._get_depreceated(key)[0]

if key is not None:

self._connections[key].remove(func)

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

try:

self[k] = v

except (ValueError, RuntimeError):

# force the issue

warn(_rcparam_warn_str.format(key=repr(k), value=repr(v),

func='update'))

dict.__setitem__(self, k, v)

def update_from_defaultParams(self, defaultParams=None,

plotters=True):

"""Update from the a dictionary like the :attr:`defaultParams`

if defaultParams is None:

defaultParams = self.defaultParams

self.update({key: val[0] for key, val in defaultParams.items()

if plotters or key != 'project.plotters'})

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

"""

pattern_re = re.compile(pattern)

ret = RcParams()

ret.defaultParams = self.defaultParams

ret.update((key, value) for key, value in self.items()

if pattern_re.search(key))

return ret

@docstrings.dedent

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

"""

return SubDict(self, *args, **kwargs)

def load_from_file(self, fname=None):

"""Update rcParams from user-defined settings

fname = fname or psyplot_fname()

if fname and os.path.exists(fname):

with open(fname) as f:

d = yaml.load(f, Loader=yaml.SafeLoader)

self.update(d)

if (d.get('project.plotters.user') and

'project.plotters' in self):

self['project.plotters'].update(d['project.plotters.user'])

def dump(self, fname=None, overwrite=True, include_keys=None,

exclude_keys=['project.plotters'], include_descriptions=True,

**kwargs):

"""Dump this instance to a yaml file

if fname is not None and not overwrite and os.path.exists(fname):

raise IOError(

'%s already exists! Set overwrite=True to overwrite it!' % (

fname))

if six.PY2:

kwargs.setdefault('encoding', 'utf-8')

d = {key: val for key, val in six.iteritems(self) if (

include_keys is None or key in include_keys) and

key not in exclude_keys}

kwargs['default_flow_style'] = False

if include_descriptions:

s = yaml.dump(d, **kwargs)

desc = self.descriptions

i = 2

header = self.HEADER.splitlines() + [

'', 'Created with python', ''] + sys.version.splitlines() + [

'', '']

lines = ['# ' + l for l in header] + s.splitlines()

for l in lines[2:]:

key = l.split(':')[0]

if key in desc:

lines.insert(i, '# ' + '\n# '.join(desc[key].splitlines()))

i += 1

i += 1

s = '\n'.join(lines)

if fname is None:

return s

else:

with open(fname, 'w') as f:

f.write(s)

else:

if fname is None:

return yaml.dump(d, **kwargs)

with open(fname, 'w') as f:

yaml.dump(d, f, **kwargs)

return None

def _load_plugin_entrypoints(self):

"""Load the modules for the psyplot plugins

from psyplot.utils import plugin_entrypoints

def load_plugin(ep):

try:

ep.module

except AttributeError: # python<3.10

try:

ep.module = ep.pattern.match(ep.value).group("module")

except AttributeError: # python<3.8

ep.module = ep.module_name

if plugins_env == ['no']:

return False

elif ep.module in exclude_plugins:

return False

elif include_plugins and ep.module not in include_plugins:

return False

return True

self._plugins = self._plugins or []

plugins_env = os.getenv('PSYPLOT_PLUGINS', '').split('::')

include_plugins = [s[4:] for s in plugins_env if s.startswith('yes:')]

exclude_plugins = [s[3:] for s in plugins_env if s.startswith('no:')]

logger = logging.getLogger(__name__)

eps = plugin_entrypoints("psyplot", "plugin")

for ep in eps:

if not load_plugin(ep):

logger.debug('Skipping entrypoint %s', ep)

continue

self._plugins.append(str(ep))

logger.debug('Loading entrypoint %s', ep)

yield ep

def load_plugins(self, raise_error=False):

"""

pm_env = os.getenv('PSYPLOT_PLOTMETHODS', '').split('::')

include_pms = [s[4:] for s in pm_env if s.startswith('yes:')]

exclude_pms = [s[3:] for s in pm_env if s.startswith('no:')]

logger = logging.getLogger(__name__)

plotters = self['project.plotters']

def_plots = {'default': list(plotters)}

defaultParams = self.defaultParams

def_keys = {'default': defaultParams}

def register_pm(ep, name):

full_name = '%s:%s' % (ep.module, name)

ret = True

if pm_env == ['no']:

ret = False

elif name in exclude_pms or full_name in exclude_pms:

ret = False

elif include_pms and (name not in include_pms and

full_name not in include_pms):

ret = False

if not ret:

logger.debug('Skipping plot method %s', full_name)

return ret

for ep in self._load_plugin_entrypoints():

try:

plugin_mod = ep.load()

except (ModuleNotFoundError, ImportError):

logger.debug("Failed to import %s!" % (ep, ), exc_info=True)

logger.warning("Failed to import %s!" % (ep, ))

continue

rc = plugin_mod.rcParams

# load the plotters

plugin_plotters = {

key: val for key, val in rc.get('project.plotters', {}).items()

if register_pm(ep, key)}

already_defined = set(plotters).intersection(plugin_plotters)

if already_defined:

msg = ("Error while loading psyplot plugin %s! The "

"following plotters have already been "

"defined") % ep

msg += 'and will be overwritten:' if not raise_error else ':'

msg += '\n' + '\n'.join(chain.from_iterable(

(('%s by %s' % (key, plugin)

for plugin, keys in def_plots.items() if key in keys)

for key in already_defined)))

if raise_error:

raise ImportError(msg)

else:

warn(msg)

for d in plugin_plotters.values():

d['plugin'] = ep.module

plotters.update(plugin_plotters)

def_plots[ep] = list(plugin_plotters)

# load the defaultParams keys

plugin_defaultParams = rc.defaultParams

already_defined = set(defaultParams).intersection(

plugin_defaultParams) - {'project.plotters'}

if already_defined:

msg = ("Error while loading psyplot plugin %s! The "

"following default keys have already been "

"defined:") % ep

msg += '\n' + '\n'.join(chain.from_iterable(

(('%s by %s' % (key, plugin)

for plugin, keys in def_keys.items() if key in keys)

for key in already_defined)))

if raise_error:

raise ImportError(msg)

else:

warn(msg)

update_keys = set(plugin_defaultParams) - {'project.plotters'}

def_keys[ep] = update_keys

self.defaultParams.update(

{key: plugin_defaultParams[key] for key in update_keys})

# load the rcParams (without validation)

super(RcParams, self).update({key: rc[key] for key in update_keys})

# add the deprecated keys

self._deprecated_ignore_map.update(rc._deprecated_ignore_map)

self._deprecated_map.update(rc._deprecated_map)

def copy(self):

"""Make sure, the right class is retained"""

return RcParams(self)

@contextlib.contextmanager

def catch(self):

"""Context manager to reset the rcParams afterwards

save = dict(self)

yield

if_exists=True):

"""

cwd = getcwd()

full_fname = os.path.join(cwd, fname)

if os.path.exists(full_fname):

return full_fname

if env_key in os.environ:

path = os.environ[env_key]

if os.path.exists(path):

if os.path.isdir(path):

full_fname = os.path.join(path, fname)

if os.path.exists(full_fname):

return full_fname

else:

return path

configdir = get_configdir()

if configdir is not None:

full_fname = os.path.join(configdir, fname)

if os.path.exists(full_fname) or not if_exists:

return full_fname

"""