"""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 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 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_sectionsf('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_sectionsf('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

@_first_main

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

len0 = len(self)

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

if len(self) > len0 and (self is gcp() or self is gcp(True)):

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 len(self) > len0 and (self is gcp() or self is gcp(True)):

self.oncpchange.emit(self)

return ret

append.__doc__ = ArrayList.append.__doc__

__call__.__doc__ = ArrayList.__call__.__doc__

@docstrings.get_sectionsf('Project.close')

@dedent

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

"""

import matplotlib.pyplot as plt

close_ds = ds

for arr in self[:]:

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

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

if data:

self.remove(arr)

if not self.is_main:

self.main.remove(arr)

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

arr.psy.plotter = None

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

scp(None)

elif self.main is gcp(True):

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

@_only_main

@docstrings.get_sectionsf('Project._add_data')

@docstrings.dedent

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

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

share=False, clear=False, enable_post=None, *args, **kwargs):

"""

if not isinstance(filename_or_obj, xarray.Dataset):

if mf_mode:

filename_or_obj = open_mfdataset(filename_or_obj,

engine=engine)

else:

filename_or_obj = open_dataset(filename_or_obj,

engine=engine)

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)

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

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

all_keys = set(chain(*(attrs.keys() for attrs in all_attrs)))

ret = {}

for key in all_keys:

vals = {utils.hashable(attrs.get(key, None))

for attrs in all_attrs} - {None}

if len(vals) == 1:

ret[key] = next(iter(vals))

else:

ret[key] = delimiter.join(map(str, vals))

return ret

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

from matplotlib.backends.backend_pdf import PdfPages

if tight:

kwargs['bbox_inches'] = 'tight'

if use_time:

def insert_time(s, attrs):

time = attrs[tname]

try: # assume a valid datetime.datetime instance

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

except ValueError:

pass

return s

tnames = self._get_tnames()

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

else:

def insert_time(s, attrs):

return s

tname = None

if isinstance(output, six.string_types): # a single string

out_fmt = kwargs.pop('format', os.path.splitext(output))[1][1:]

if out_fmt.lower() == 'pdf' and concat:

attrs = self.joined_attrs('-')

if tname is not None and tname in attrs:

output = insert_time(output, attrs)

pdf = PdfPages(safe_modulo(output, attrs))

def save(fig):

pdf.savefig(fig, **kwargs)

def close():

if close_pdf is None or close_pdf:

pdf.close()

return

return pdf

else:

def save(fig):

attrs = self.figs[fig].joined_attrs('-')

out = output

if tname is not None and tname in attrs:

out = insert_time(out, attrs)

try:

out = safe_modulo(out, i, print_warning=False)

except TypeError:

pass

fig.savefig(safe_modulo(out, attrs), **kwargs)

def close():

pass

elif isinstance(output, Iterable): # a list of strings

output = cycle(output)

def save(fig):

attrs = self.figs[fig].joined_attrs('-')

out = next(output)

if tname is not None and tname in attrs:

out = insert_time(out, attrs)

try:

out = safe_modulo(next(output), i, print_warning=False)

except TypeError:

pass

fig.savefig(safe_modulo(out, attrs), **kwargs)

def close():

pass

else: # an instances of matplotlib.backends.backend_pdf.PdfPages

def save(fig):

output.savefig(fig, **kwargs)

def close():

if close_pdf:

output.close()

for i, fig in enumerate(self.figs, 1):

save(fig)

return close()

docstrings.keep_params('Plotter.share.parameters', 'keys')

docstrings.delete_params('Plotter.share.parameters', 'keys', 'plotters')

@docstrings.dedent

def share(self, base=None, keys=None, by=None, **kwargs):

"""

if by is not None:

if base is not None:

if hasattr(base, 'psy') or isinstance(base, Plotter):

base = [base]

if by.lower() in ['ax', 'axes']:

bases = {ax: p[0] for ax, p in six.iteritems(

Project(base).axes)}

elif by.lower() in ['fig', 'figure']:

bases = {fig: p[0] for fig, p in six.iteritems(

Project(base).figs)}

else:

raise ValueError(

"*by* must be out of {'fig', 'figure', 'ax', 'axes'}. "

"Not %s" % (by, ))

else:

bases = {}

projects = self.axes if by == 'axes' else self.figs

for obj, p in projects.items():

p.share(bases.get(obj), keys, **kwargs)

else:

plotters = self.plotters

if not plotters:

return

if base is None:

if len(plotters) == 1:

return

base = plotters[0]

plotters = plotters[1:]

elif not isinstance(base, Plotter):

base = getattr(getattr(base, 'psy', base), 'plotter', base)

base.share(plotters, keys=keys, **kwargs)

@docstrings.dedent

def unshare(self, **kwargs):

"""

for plotter in self.plotters:

plotter.unshare_me(**kwargs)

docstrings.delete_params('ArrayList.array_info.parameters', 'pwd', 'copy')

@docstrings.get_sectionsf('Project.save_project')

@docstrings.dedent

def save_project(self, fname=None, pwd=None, pack=False, **kwargs):

"""

# store the figure informatoptions and array informations

if fname is not None and pwd is None and not pack:

pwd = os.path.dirname(fname)

if pack and fname is not None:

target_dir = os.path.dirname(fname)

if not os.path.exists(target_dir):

os.makedirs(target_dir)

def tmp_it():

from tempfile import NamedTemporaryFile

while True:

yield NamedTemporaryFile(

dir=target_dir, suffix='.nc').name

kwargs.setdefault('paths', tmp_it())

if fname is not None:

kwargs['copy'] = True

_update_versions()

ret = {'figs': dict(map(_ProjectLoader.inspect_figure, self.figs)),

'arrays': self.array_info(pwd=pwd, **kwargs),

'versions': _deepcopy(_versions)}

if pack and fname is not None:

# we get the filenames out of the results and copy the datasets

# there. After that we check the filenames again and force them

# to the desired directory

from shutil import copyfile

fnames = (f[0] for f in self._get_dsnames(ret['arrays']))

alternative_paths = kwargs.pop('alternative_paths', {})

counters = defaultdict(int)

if kwargs.get('use_rel_paths', True):

get_path = partial(os.path.relpath, start=target_dir)

else:

get_path = os.path.abspath

for ds_fname in unique_everseen(chain(alternative_paths, fnames)):

if ds_fname is None or utils.is_remote_url(ds_fname):

continue

dst_file = alternative_paths.get(

ds_fname, os.path.join(target_dir, os.path.basename(

ds_fname)))

orig_dst_file = dst_file

if counters[dst_file] and (

not os.path.exists(dst_file) or

not os.path.samefile(ds_fname, dst_file)):

dst_file, ext = os.path.splitext(dst_file)

dst_file += '-' + str(counters[orig_dst_file]) + ext

if (not os.path.exists(dst_file) or

not os.path.samefile(ds_fname, dst_file)):

copyfile(ds_fname, dst_file)

counters[orig_dst_file] += 1

alternative_paths.setdefault(ds_fname, get_path(dst_file))

ret['arrays'] = self.array_info(

pwd=pwd, alternative_paths=alternative_paths, **kwargs)

# store the plotter settings

for arr, d in zip(self, six.itervalues(ret['arrays'])):

if arr.psy.plotter is None:

continue

plotter = arr.psy.plotter

d['plotter'] = {

'ax': _ProjectLoader.inspect_axes(plotter.ax),

'fmt': {key: getattr(plotter, key).value2pickle

for key in plotter},

'cls': (plotter.__class__.__module__,

plotter.__class__.__name__),

'shared': {}}

d['plotter']['ax']['shared'] = set(

other.psy.arr_name for other in self

if other.psy.ax == plotter.ax)

shared = d['plotter']['shared']

for fmto in plotter._fmtos:

if fmto.shared:

shared[fmto.key] = [other_fmto.plotter.data.psy.arr_name

for other_fmto in fmto.shared]

if fname is not None:

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

pickle.dump(ret, f)

return None

return ret

@docstrings.dedent

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

"""

class TmpClass(Plotter):

pass

for fmto in self._fmtos:

setattr(TmpClass, fmto.key, type(fmto)(fmto.key))

return TmpClass.show_keys(*args, **kwargs)

@docstrings.dedent

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

"""

class TmpClass(Plotter):

pass

for fmto in self._fmtos:

setattr(TmpClass, fmto.key, type(fmto)(fmto.key))

return TmpClass.show_summaries(*args, **kwargs)

@docstrings.dedent

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

"""