"""Update :attr:`_versions` with the registered plotter methods"""

for pm_name in plot._plot_methods:

pm = getattr(plot, pm_name)

plugin = pm._plugin

if (plugin is not None and plugin not in _versions and

pm.module in sys.modules):

for_maps=False, *args, **kwargs):

"""

import matplotlib.pyplot as plt

axes = np.array([])

maxplots = maxplots or rows * cols

kwargs.setdefault('figsize', [

min(8.*cols, 16), min(6.5*rows, 12)])

if for_maps:

import cartopy.crs as ccrs

subplot_kw = kwargs.setdefault('subplot_kw', {})

subplot_kw['projection'] = ccrs.PlateCarree()

for i in range(0, n, maxplots):

fig, ax = plt.subplots(rows, cols, *args, **kwargs)

try:

axes = np.append(axes, ax.ravel()[:maxplots])

if delete:

for iax in range(maxplots, rows * cols):

fig.delaxes(ax.ravel()[iax])

except AttributeError: # got a single subplot

axes = np.append(axes, [ax])

if i + maxplots > n and delete:

for ax2 in axes[n:]:

fig.delaxes(ax2)

axes = axes[:n]

"""Call the given `func` only from the main project"""

@wraps(func)

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

if not self.is_main:

return getattr(self.main, func.__name__)(*args, **kwargs)

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

"""Call the given `func` with the same arguments but after the function

@wraps(func)

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

if not self.is_main:

getattr(self.main, func.__name__)(*args, **kwargs)

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

"""A manager of multiple interactive data projects"""

_main = None

_registered_plotters = {} #: registered plotter identifiers

#: signal to be emiitted when the current main and/or subproject changes

oncpchange = Signal(name='oncpchange', cls_signal=True)

# block the signals of this class

block_signals = utils._TempBool()

@property

def main(self):

""":class:`Project`. The main project of this subproject"""

return self._main if self._main is not None else self

@main.setter

def main(self, value):

self._main = value

@property

@dedent

def plot(self):

"""

return self._plot

@property

def _fmtos(self):

"""An iterator over formatoption objects

plotters = self.plotters

if len(plotters) == 0:

return {}

p0 = plotters[0]

if len(plotters) == 1:

return p0._fmtos

return (getattr(p0, key) for key in set(p0).intersection(

*map(set, plotters[1:])))

@property

def is_csp(self):

"""Boolean that is True if the project is the current subproject"""

return self is _current_subproject

@property

def is_cmp(self):

"""Boolean that is True if the project is the current main project"""

return self is _current_project

@property

def figs(self):

"""A mapping from figures to data objects with the plotter in this

ret = utils.DefaultOrderedDict(lambda: self[1:0])

for arr in self:

if arr.psy.plotter is not None:

ret[arr.psy.plotter.ax.get_figure()].append(arr)

return OrderedDict(ret)

@property

def axes(self):

"""A mapping from axes to data objects with the plotter in this axes

ret = utils.DefaultOrderedDict(lambda: self[1:0])

for arr in self:

if arr.psy.plotter is not None:

ret[arr.psy.plotter.ax].append(arr)

return OrderedDict(ret)

@property

def is_main(self):

""":class:`bool`. True if this :class:`Project` is a main project"""

return self._main is None

@property

def logger(self):

""":class:`logging.Logger` of this instance"""

if not self.is_main:

return self.main.logger

try:

return self._logger

except AttributeError:

name = '%s.%s.%s' % (self.__module__, self.__class__.__name__,

self.num)

self._logger = logging.getLogger(name)

self.logger.debug('Initializing...')

return self._logger

@logger.setter

def logger(self, value):

self._logger = value

def with_plotter(self):

ret = super(Project, self).with_plotter

ret.main = self.main

return ret

with_plotter = property(with_plotter, doc=ArrayList.with_plotter.__doc__)

@property

def arr_names(self):

"""Names of the arrays (!not of the variables!) in this list

return list(arr.psy.arr_name for arr in self)

@arr_names.setter

def arr_names(self, value):

value = list(islice(value, len(self)))

if not len(set(value)) == len(self):

raise ValueError(

"Got %i unique array names for %i data objects!" % (

len(set(value)), len(self)))

elif not self.is_main and set(value) & (

set(self.main.arr_names) - set(self.arr_names)):

raise ValueError(

"Cannot rename arrays because there are duplicates with the "

"main project: %s" % (

set(value) & (

set(self.main.arr_names) - set(self.arr_names)), ))

for arr, n in zip(self, value):

arr.psy.arr_name = n

if self.main is gcp(True):

for arr in self:

arr.psy.onupdate.emit()

@property

def plotters(self):

"""A list of all the plotters in this instance"""

return [arr.psy.plotter for arr in self.with_plotter]

@property

def datasets(self):

"""A mapping from dataset numbers to datasets in this list"""

return {key: val['ds'] for key, val in six.iteritems(

self._get_ds_descriptions(self.array_info(ds_description=['ds'])))}

@property

def dsnames_map(self):

"""A dictionary from the dataset numbers in this list to their

return {key: val['fname'] for key, val in six.iteritems(

self._get_ds_descriptions(self.array_info(

ds_description=['num', 'fname']), ds_description={'fname'}))}

@property

def dsnames(self):

"""The set of dataset names in this instance"""

return {t[0] for t in self._get_dsnames(self.array_info()) if t[0]}

@docstrings.get_sections(base='Project')

@docstrings.dedent

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

"""

self.main = kwargs.pop('main', None)

self._plot = ProjectPlotter(self)

self.num = kwargs.pop('num', 1)

self._ds_counter = count()

with self.block_signals:

super(Project, self).__init__(*args, **kwargs)

@classmethod

@docstrings.get_sections(base='Project._register_plotter')

@dedent

def _register_plotter(cls, identifier, module, plotter_name,

plotter_cls=None):

"""

if plotter_cls is not None: # plotter has already been imported

def get_x(self):

return self(plotter_cls)

else:

def get_x(self):

return self(getattr(import_module(module), plotter_name))

setattr(cls, identifier, property(get_x, doc=(

"List of data arrays that are plotted by :class:`%s.%s`"

" plotters") % (module, plotter_name)))

cls._registered_plotters[identifier] = (module, plotter_name)

def disable(self):

"""Disables the plotters in this list"""

for arr in self:

if arr.psy.plotter:

arr.psy.plotter.disabled = True

def enable(self):

for arr in self:

if arr.psy.plotter:

arr.psy.plotter.disabled = False

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

ret = super(Project, self).__call__(*args, **kwargs)

ret.main = self.main

return ret

def __enter__(self):

return self

def __exit__(self, exc_type, exc_val, exc_tb):

self.close(True, True, True)

@staticmethod

@docstrings.get_sections(base='Project._load_preset',

def _load_preset(preset: str):

"""Load a preset from disk

if isinstance(preset, dict):

config = preset

else:

path = Project._resolve_preset_path(preset)

if path in rcParams['presets.trusted']:

loader = yaml.Loader

else:

loader = yaml.SafeLoader

with open(path) as f:

try:

config = yaml.load(f, loader)

except yaml.constructor.ConstructorError as e:

e.note = (e.note or '') + (

' You might want to add it to the trusted presets '

'via\n\npsy.rcParams["presets.trusted"].append("{}")\n\n'

'and run this method again. To permanently store '

'this preset, edit the file at\n\n{} ').format(

path, psyplot_fname())

raise

return config

@staticmethod

def _resolve_preset_path(preset, if_exists=True):

if osp.exists(preset):

return preset

else:

confdir = get_configdir()

presets_dir = osp.join(confdir, 'presets')

if osp.exists(osp.join(presets_dir, preset)):

return osp.join(presets_dir, preset)

elif osp.exists(osp.join(presets_dir, preset + '.yml')):

return osp.join(presets_dir, preset + '.yml')

else:

if if_exists:

raise ValueError(

f"Could not find a preset with name {preset}")

else:

if not preset.endswith('.yml'):

return osp.join(presets_dir, preset + '.yml')

return preset

@docstrings.dedent

def load_preset(self, preset: str, **kwargs):

"""Load a preset from disk and apply it to the open project.

config = self._load_preset(preset)

plotmethods = self.plot._plot_methods

pm_config, defaults = utils.sort_kwargs(config, plotmethods)

with self.no_auto_update:

for pm in plotmethods:

method = getattr(self.plot, pm)

if method.is_imported:

sp = getattr(self, pm)

if sp:

valid = list(method.plotter_cls._get_formatoptions())

fmts = {key: val for key, val in defaults.items()

if key in valid}

fmts.update(pm_config.get(pm, {}))

sp.update(fmt=fmts, **kwargs)

self.start_update()

@staticmethod

def extract_fmts_from_preset(preset: str, plotmethod: str):

"""Extract the formatoptions for a plotmethod from a given preset

preset = Project._load_preset(preset)

try:

plotmethod._method

except AttributeError:

method = getattr(plot, plotmethod)

else:

method = plotmethod

plotmethod = method._method

plotmethods = plot._plot_methods

pm_config, defaults = utils.sort_kwargs(preset, plotmethods)

valid = list(method.plotter_cls._get_formatoptions())

fmts = {key: val for key, val in defaults.items()

if key in valid}

fmts.update(pm_config.get(plotmethod, {}))

return fmts

def save_preset(self, fname=None, include_defaults=False, update=False):

"""Save the formatoptions of this project as a preset

def include(fmto, plotters):

key = fmto.key

for plotter in plotters:

if fmto.diff(plotter[key]):

return False

return True if include_defaults else fmto.changed

if update:

with open(f) as f:

preset = yaml.load(f, yaml.Loader)

else:

preset = {}

plotters = self.plotters

for fmto in self._fmtos:

if include(fmto, plotters):

preset[fmto.key] = fmto.value

for pm in self.plot._plot_methods:

method = getattr(self.plot, pm)

if method.is_imported:

sp = getattr(self, pm)

plotters = sp.plotters

for fmto in sp._fmtos:

if fmto.key not in preset and include(fmto, plotters):

preset.setdefault(pm, {})

preset[pm][fmto.key] = fmto.value

if fname is not None:

fname = self._resolve_preset_path(fname, False)

os.makedirs(osp.dirname(fname), exist_ok=True)

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

yaml.dump(preset, f)

else:

return preset

@_first_main

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

len0 = len(self)

ret = super(Project, self).extend(*args, **kwargs)

if self._main is None:

for arr in self:

if arr.psy.plotter is not None:

arr.psy.plotter._project = self

if len(self) > len0 and (self.is_csp or self.is_cmp):

self.oncpchange.emit(self)

return ret

extend.__doc__ = ArrayList.extend.__doc__

@_first_main

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

len0 = len(self)

ret = super(Project, self).append(*args, **kwargs)

if self._main is None:

for arr in self:

if arr.psy.plotter is not None:

arr.psy.plotter._project = self

if len(self) > len0 and (self.is_csp or self.is_cmp):

self.oncpchange.emit(self)

return ret

append.__doc__ = ArrayList.append.__doc__

__call__.__doc__ = ArrayList.__call__.__doc__

@docstrings.get_sections(base='Project.close')

@dedent

def close(self, figs=True, data=False, ds=False, remove_only=False):

"""

import matplotlib.pyplot as plt

close_ds = ds

for arr in self[:]:

if figs and arr.psy.plotter is not None:

if remove_only:

for fmto in arr.psy.plotter._fmtos:

try:

fmto.remove()

except Exception:

pass

else:

plt.close(arr.psy.plotter.ax.get_figure().number)

arr.psy.plotter = None

if data:

self.remove(arr)

if not self.is_main:

try:

self.main.remove(arr)

except ValueError: # arr not in list

pass

if close_ds:

if isinstance(arr, InteractiveList):

for ds in [val['ds'] for val in six.itervalues(

arr._get_ds_descriptions(

arr.array_info(ds_description=['ds'],

standardize_dims=False)))]:

ds.close()

else:

arr.psy.base.close()

if self.is_main and self is gcp(True) and data:

scp(None)

elif self.is_main and self.is_cmp:

self.oncpchange.emit(self)

elif self.main.is_cmp:

self.oncpchange.emit(self.main)

docstrings.keep_params('multiple_subplots.parameters', 'delete')

docstrings.delete_params('ArrayList.from_dataset.parameters', 'base')

docstrings.delete_kwargs('ArrayList.from_dataset.other_parameters',

kwargs='kwargs')

docstrings.keep_params('xarray.open_mfdataset.parameters', 'concat_dim')

docstrings.keep_params('Project._load_preset.parameters', 'preset')

@_only_main

@docstrings.get_sections(base='Project._add_data',

@docstrings.dedent

def _add_data(self, plotter_cls, filename_or_obj, fmt={}, make_plot=True,

draw=False, mf_mode=False, ax=None, engine=None, delete=True,

share=False, clear=False, enable_post=None,

concat_dim=_concat_dim_default, load=False,

*args, **kwargs):

"""

if not isinstance(filename_or_obj, xarray.Dataset):

if mf_mode:

filename_or_obj = open_mfdataset(filename_or_obj,

engine=engine,

concat_dim=concat_dim)

else:

filename_or_obj = open_dataset(filename_or_obj,

engine=engine)

if load:

old = filename_or_obj

filename_or_obj = filename_or_obj.load()

old.close()

fmt = dict(fmt)

possible_fmts = list(plotter_cls._get_formatoptions())

additional_fmt, kwargs = utils.sort_kwargs(

kwargs, possible_fmts)

fmt.update(additional_fmt)

if enable_post is None:

enable_post = bool(fmt.get('post'))

# create the subproject

sub_project = self.from_dataset(filename_or_obj, **kwargs)

sub_project.main = self

sub_project.no_auto_update = not (

not sub_project.no_auto_update or not self.no_auto_update)

# create the subplots

proj = plotter_cls._get_sample_projection()

if isinstance(ax, tuple):

axes = iter(multiple_subplots(

*ax, n=len(sub_project), subplot_kw={'projection': proj}))

elif ax is None or isinstance(ax, (mpl.axes.SubplotBase,

mpl.axes.Axes)):

axes = repeat(ax)

else:

axes = iter(ax)

clear = clear or (isinstance(ax, tuple) and proj is not None)

for arr in sub_project:

plotter_cls(arr, make_plot=(not bool(share) and make_plot),

draw=False, ax=next(axes), clear=clear,

project=self, enable_post=enable_post, **fmt)

if share:

if share is True:

share = possible_fmts

elif isinstance(share, six.string_types):

share = [share]

else:

share = list(share)

sub_project[0].psy.plotter.share(

[arr.psy.plotter for arr in sub_project[1:]], keys=share,

draw=False)

if make_plot:

for arr in sub_project:

arr.psy.plotter.reinit(draw=False, clear=clear)

if draw is None:

draw = rcParams['auto_draw']

if draw:

sub_project.draw()

if rcParams['auto_show']:

self.show()

self.extend(sub_project, new_name=True)

if self is gcp(True):

scp(sub_project)

return sub_project

def __getitem__(self, key):

"""Overwrites lists __getitem__ by returning subproject if `key` is a

if isinstance(key, slice): # return a new project

ret = self.__class__(

super(Project, self).__getitem__(key))

ret.main = self.main

else: # return the item

ret = super(Project, self).__getitem__(key)

return ret

if six.PY2: # for compatibility to python 2.7

def __getslice__(self, *args):

return self[slice(*args)]

def __add__(self, other):

# overwritte to return a subproject

ret = self.__class__(super(Project, self).__add__(other))

ret.main = self.main

return ret

@staticmethod

def show():

"""Shows all open figures"""

import matplotlib.pyplot as plt

plt.show(block=False)

docstrings.keep_params('join_dicts.parameters', 'delimiter')

docstrings.keep_params('join_dicts.parameters', 'keep_all')

@docstrings.get_sections(base='Project.joined_attrs')

@docstrings.with_indent(8)

def joined_attrs(self, delimiter=', ', enhanced=True, plot_data=False,

keep_all=True):

"""Join the attributes of the arrays in this project

if enhanced:

all_attrs = [

plotter.get_enhanced_attrs(

getattr(plotter, 'plot_data' if plot_data else 'data'))

for plotter in self.plotters]

else:

if plot_data:

all_attrs = [plotter.plot_data.attrs

for plotter in self.plotters]

else:

all_attrs = [arr.attrs for arr in self]

return utils.join_dicts(all_attrs, delimiter=delimiter,

keep_all=keep_all)

@docstrings.get_sections(base='Project.format_string')

@docstrings.with_indent(8)

def format_string(self, s, use_time=False, format_args=None, *args,

**kwargs):

"""Format a string with the attributes in this project

attrs = self.joined_attrs(*args, **kwargs)

if use_time:

tnames = self._get_tnames()

tname = next(iter(tnames)) if len(tnames) == 1 else None

time = attrs[tname]

try: # assume a valid datetime.datetime instance

s = pd.to_datetime(time).strftime(s)

except ValueError:

pass

if format_args is not None:

try:

s = safe_modulo(s, format_args, print_warning=False)

except TypeError:

pass

return safe_modulo(s, attrs)

docstrings.keep_params('Project.format_string.parameters', 'use_time')

@docstrings.with_indent(8)

def export(self, output, tight=False, concat=True, close_pdf=None,

use_time=False, **kwargs):

"""Exports the figures of the project to one or more image files