'data': 'Data manipulation formatoptions',

'axes': 'Axes formatoptions',

'labels': 'Label formatoptions',

'plotting': 'Plot formatoptions',

'post_processing': 'Post processing formatoptions',

'colors': 'Color coding formatoptions',

'misc': 'Miscallaneous formatoptions',

'ticks': 'Axis tick formatoptions',

'vector': 'Vector plot formatoptions',

'masking': 'Masking formatoptions',

'regression': 'Fitting formatoptions',

"""identity function to make no validation

"""Formats date values

if isinstance(x, (datetime64, datetime)):

return format_timestamp(x)

elif isinstance(x, (timedelta64, timedelta)):

return format_timedelta(x)

elif isinstance(x, ndarray):

return list(x) if x.ndim else x[()]

"""Check whether a formatoption is data dependent

if callable(fmto.data_dependent):

return fmto.data_dependent(data)

def get_x(self):

return getattr(self.plotter, self._child_mapping[childname])

return property(

"""Meta class for formatoptions

def __new__(cls, clsname, bases, dct):

"""Assign an automatic documentation to the formatoption"""

dct['__doc__'] = docstrings.dedents(dct.get('__doc__'))

new_cls = super(FormatoptionMeta, cls).__new__(cls, clsname, bases,

dct)

for childname in chain(new_cls.children, new_cls.dependencies,

new_cls.connections, new_cls.parents):

setattr(new_cls, childname, _child_property(childname))

if new_cls.plot_fmt:

new_cls.data_dependent = True

"""Abstract formatoption

priority = END

""":class:`int`. Priority value of the the formatoption determining when

#: :class:`str`. Formatoption key of this class in the

#: :class:`~psyplot.plotter.Plotter` class

key = None

#: :class:`~psyplot.plotter.Plotter`. Plotter instance this formatoption

#: belongs to

plotter = None

#: `list of str`. List of formatoptions that have to be updated before this

#: one is updated. Those formatoptions are only updated if they exist in

#: the update parameters.

children = []

#: `list of str`. List of formatoptions that force an update of this

#: formatoption if they are updated.

dependencies = []

#: `list of str`. Connections to other formatoptions that are (different

#: from :attr:`dependencies` and :attr:`children`) not important for the

#: update process

connections = []

#: `list of str`. List of formatoptions that, if included in the update,

#: prevent the update of this formatoption.

parents = []

#: :class:`bool`. Has to be True if the formatoption has a ``make_plot``

#: method to make the plot.

plot_fmt = False

#: :class:`bool`. True if an update of this formatoption requires a

#: clearing of the axes and reinitialization of the plot

requires_clearing = False

#: :class:`str`. Key of the group name in :data:`groups` of this

#: formatoption keyword

group = 'misc'

#: :class:`bool` or a callable. This attribute indicates whether this

#: :class:`Formatoption` depends on the data and should be updated if the

#: data changes. If it is a callable, it must accept one argument: the

#: new data. (Note: This is automatically set to True for plot

#: formatoptions)

data_dependent = False

#: :class:`bool`. True if this formatoption needs an update after the plot

#: has changed

update_after_plot = False

#: :class:`set` of the :class:`Formatoption` instance that are shared

#: with this instance.

shared = set()

#: int or None. Index that is used in case the plotting data is a

#: :class:`psyplot.InteractiveList`

index_in_list = 0

#: :class:`str`. A bit more verbose name than the formatoption key to be

#: included in the gui. If None, the key is used in the gui

name = None

#: Boolean that is True if an update of the formatoption requires a replot

requires_replot = False

@property

def init_kwargs(self):

""":class:`dict` key word arguments that are passed to the

return self._child_mapping

@property

def project(self):

"""Project of the plotter of this instance"""

return self.plotter.project

@property

def ax(self):

"""The axes this Formatoption plots on"""

return self.plotter.ax

@property

def lock(self):

"""A :class:`threading.Rlock` instance to lock while updating

try:

return self._lock

except AttributeError:

self._lock = RLock()

return self._lock

@property

def logger(self):

"""Logger of the plotter"""

return self.plotter.logger.getChild(self.key)

@property

def groupname(self):

"""Long name of the group this formatoption belongs too."""

try:

return groups[self.group]

except KeyError:

warn("Unknown formatoption group " + str(self.group),

PsyPlotRuntimeWarning)

return self.group

@property

def raw_data(self):

"""The original data of the plotter of this formatoption"""

if self.index_in_list is not None and isinstance(

self.plotter.data, InteractiveList):

return self.plotter.data[self.index_in_list]

else:

return self.plotter.data

@property

def decoder(self):

"""The :class:`~psyplot.data.CFDecoder` instance that decodes the

# If the decoder is modified by one of the formatoptions, use this one

if self.plotter.plot_data_decoder is not None:

if self.index_in_list is not None and isinstance(

self.plotter.plot_data, InteractiveList):

ret = self.plotter.plot_data_decoder[self.index_in_list]

if ret is not None:

return ret

else:

return self.plotter.plot_data_decoder

data = self.raw_data

check = isinstance(data, InteractiveList)

while check:

data = data[0]

check = isinstance(data, InteractiveList)

return data.psy.decoder

@decoder.setter

def decoder(self, value):

self.set_decoder(value, self.index_in_list)

@property

def any_decoder(self):

"""Return the first possible decoder"""

ret = self.decoder

while not isinstance(ret, CFDecoder):

ret = ret[0]

return ret

@property

def data(self):

"""The data that is plotted"""

if self.index_in_list is not None and isinstance(

self.plotter.plot_data, InteractiveList):

return self.plotter.plot_data[self.index_in_list]

else:

return self.plotter.plot_data

@data.setter

def data(self, value):

self.set_data(value, self.index_in_list)

@property

def iter_data(self):

"""Returns an iterator over the plot data arrays"""

data = self.data

if isinstance(data, InteractiveList):

return iter(data)

return iter([data])

@property

def iter_raw_data(self):

"""Returns an iterator over the original data arrays"""

data = self.raw_data

if isinstance(data, InteractiveList):

return iter(data)

return iter([data])

@property

def validate(self):

"""Validation method of the formatoption"""

try:

return self._validate

except AttributeError:

try:

self._validate = self.plotter.get_vfunc(self.key)

except KeyError:

warn("Could not find a validation function for %s "

"formatoption keyword! No validation will be made!" % (

self.key), PsyPlotRuntimeWarning, logger=self.logger)

self._validate = _identity

return self._validate

@validate.setter

def validate(self, value):

self._validate = value

@property

def default(self):

"""Default value of this formatoption"""

return self.plotter.rc[self.key]

@property

def default_key(self):

"""The key of this formatoption in the :attr:`psyplot.rcParams`"""

return self.plotter.rc._get_val_and_base(self.key)[0]

@property

def shared_by(self):

"""None if the formatoption is not controlled by another formatoption

return self.plotter._shared.get(self.key)

@property

def value(self):

"""Value of the formatoption in the corresponding :attr:`plotter` or

shared_by = self.shared_by

if shared_by:

return shared_by.value2share

return self.plotter[self.key]

@property

@dedent

def changed(self):

"""

return self.diff(self.default)

@property

@dedent

def value2share(self):

"""

return self.value

@property

@dedent

def value2pickle(self):

"""

return self.value

@docstrings.get_sectionsf('Formatoption')

@dedent

def __init__(self, key, plotter=None, index_in_list=None,

additional_children=[], additional_dependencies=[],

**kwargs):

"""

self.key = key

self.plotter = plotter

self.index_in_list = index_in_list

self.shared = set()

self.additional_children = additional_children

self.additional_dependencies = additional_dependencies

self.children = self.children + additional_children

self.dependencies = self.dependencies + additional_dependencies

self._child_mapping = dict(zip(*tee(chain(

self.children, self.dependencies, self.connections,

self.parents), 2)))

# check kwargs

for key in (key for key in kwargs if key not in self._child_mapping):

raise TypeError(

'%s.__init__() got an unexpected keyword argument %r' % (

self.__class__.__name__, key))

# set up child mapping

self._child_mapping.update(kwargs)

# reset the dependency lists to match the current plotter setup

for attr in ['children', 'dependencies', 'connections', 'parents']:

setattr(self, attr,

[self._child_mapping[key] for key in getattr(self, attr)])

def __set__(self, instance, value):

if isinstance(value, Formatoption):

setattr(instance, '_' + self.key, value)

else:

fmto = getattr(instance, self.key)

fmto.set_value(value)

def __get__(self, instance, owner):

if instance is None:

return self

try:

return getattr(instance, '_' + self.key)

except AttributeError:

fmto = self.__class__(

self.key, instance, self.index_in_list,

additional_children=self.additional_children,

additional_dependencies=self.additional_dependencies,

**self.init_kwargs)

setattr(instance, '_' + self.key, fmto)

return fmto

def __delete__(self, instance, owner):

fmto = getattr(instance, '_' + self.key)

with instance.no_validation:

instance[self.key] = fmto.default

@docstrings.get_sectionsf('Formatoption.set_value')

@dedent

def set_value(self, value, validate=True, todefault=False):

"""

# do nothing if the key is shared

if self.key in self.plotter._shared:

return

with self.plotter.no_validation:

try:

self.plotter[self.key] = value if not validate else \

self.validate(value)

except ValueError as e:

critical("Error while setting %s!" % self.key,

logger=self.logger)

raise e

def set_data(self, data, i=None):

"""

if self.index_in_list is not None:

i = self.index_in_list

if i is not None and isinstance(self.plotter.plot_data,

InteractiveList):

self.plotter.plot_data[i] = data

else:

self.plotter.plot_data = data

def set_decoder(self, decoder, i=None):

"""

# we do not modify the raw data but instead set it on the plotter

# TODO: This is not safe for encapsulated InteractiveList instances!

if i is not None and isinstance(

self.plotter.plot_data, InteractiveList):

n = len(self.plotter.plot_data)

decoders = self.plotter.plot_data_decoder or [None] * n

decoders[i] = decoder

self.plotter.plot_data_decoder = decoders

else:

if (isinstance(self.plotter.plot_data, InteractiveList) and

isinstance(decoder, CFDecoder)):

decoder = [decoder] * len(self.plotter.plot_data)

self.plotter.plot_data_decoder = decoder

def check_and_set(self, value, todefault=False, validate=True):

"""Checks the value and sets the value if it changed

if validate:

value = self.validate(value)

if self.diff(value):

self.set_value(value, validate=False, todefault=todefault)

return True

return False

def diff(self, value):

"""Checks whether the given value differs from what is currently set

return value != self.value

def initialize_plot(self, value, *args, **kwargs):

"""Method that is called when the plot is made the first time

self.update(value, *args, **kwargs)

@abstractmethod

def update(self, value):

"""Method that is call to update the formatoption on the axes

pass

def get_fmt_widget(self, parent, project):

"""Get a widget to update the formatoption in the GUI

return None

def share(self, fmto, initializing=False, **kwargs):

"""Share the settings of this formatoption with other data objects

# lock all the childrens and the formatoption itself

self.lock.acquire()

fmto._lock_children()

fmto.lock.acquire()

# update the other plotter

if initializing:

fmto.initialize_plot(self.value2share, **kwargs)

else:

fmto.update(self.value2share, **kwargs)

self.shared.add(fmto)

# release the locks

fmto.lock.release()

fmto._release_children()

self.lock.release()

def _lock_children(self):

"""acquire the locks of the children"""

plotter = self.plotter

for key in self.children + self.dependencies:

try:

getattr(plotter, key).lock.acquire()

except AttributeError:

pass

def _release_children(self):

"""release the locks of the children"""

plotter = self.plotter

for key in self.children + self.dependencies:

try:

getattr(plotter, key).lock.release()

except AttributeError:

pass

def finish_update(self):

"""Finish the update, initialization and sharing process

pass

@dedent

def remove(self):

"""

"""

@docstrings.dedent

def set_value(self, value, validate=True, todefault=False):

"""

value = value if not validate else self.validate(value)

# if the key in the plotter is not already set (i.e. it is initialized

# with None, we set it)

if self.plotter[self.key] is None:

with self.plotter.no_validation:

self.plotter[self.key] = value.copy()

# in case of an empty dict, clear the value

elif not value:

self.plotter[self.key].clear()

# otherwhise we update the dictionary

else:

if todefault:

self.plotter[self.key].clear()

"""

default = 'never'

priority = -inf

group = 'post_processing'

name = 'Timing of the post processing'

@staticmethod

def validate(value):

value = six.text_type(value)

possible_values = ['never', 'always', 'replot']

if value not in possible_values:

raise ValueError('String must be one of %s, not %r' % (

possible_values, value))

return value

def update(self, value):

"""The dependencies of this formatoption"""

def __get__(self, instance, owner):

if (instance is None or instance.plotter is None or

not instance.plotter._initialized):

return []

elif instance.post_timing.value == 'always':

return list(set(instance.plotter) - {instance.key})

else:

return []

def __set__(self, instance, value):

"""

children = ['post_timing']

default = None

priority = -inf

group = 'post_processing'

name = 'Custom post processing script'

@staticmethod

def validate(value):

if value is None:

return value

elif not isinstance(value, six.string_types):

raise ValueError("Expected a string, not %s" % (type(value), ))

else:

return six.text_type(value)

@property

def data_dependent(self):

"""True if the corresponding :class:`post_timing <PostTiming>`

return self.post_timing.value == 'replot'

dependencies = PostProcDependencies()

def update(self, value):

if value is None:

return

if not self.plotter.enable_post:

self.logger.warn(

"Post processing is disabled. Set the ``enable_post`` "

"attribute to True to run the script")

else:

"""Interactive plotting object for one or more data arrays

#: List of base strings in the :attr:`psyplot.rcParams` dictionary

_rcparams_string = []

post_timing = PostTiming('post_timing')

post = PostProcessing('post')

no_validation = _temp_bool_prop('no_validation', """

>>> plotter.no_validation = False # reenable validation""")

#: Temporarily include links in the key descriptions from

#: :meth:`show_keys`, :meth:`show_docs` and :meth:`show_summaries`.

#: Note that this is a class attribute, so each change to the value of this

#: attribute will affect all instances and subclasses

include_links = _TempBool()

@property

def ax(self):

"""Axes instance of the plot"""

if self._ax is None:

import matplotlib.pyplot as plt

plt.figure()

self._ax = plt.axes(projection=self._get_sample_projection())

return self._ax

@ax.setter

def ax(self, value):

self._ax = value

#: The :class:`psyplot.project.Project` instance this plotter belongs to

project = None

@property

@dedent

def rc(self):

"""

try:

return self._rc

except AttributeError:

self._set_rc()

return self._rc

@property

def base_variables(self):

"""A mapping from the base_variable names to the variables"""

if isinstance(self.data, InteractiveList):

return dict(chain(*map(

lambda arr: six.iteritems(arr.psy.base_variables),

self.data)))

else:

return self.data.psy.base_variables

@property

def iter_base_variables(self):

"""A mapping from the base_variable names to the variables"""

if isinstance(self.data, InteractiveList):

return chain(*(arr.psy.iter_base_variables for arr in self.data))

else:

return self.data.psy.iter_base_variables

no_auto_update = property(_no_auto_update_getter,

doc=_no_auto_update_getter.__doc__)

@no_auto_update.setter

def no_auto_update(self, value):

self.no_auto_update.value = bool(value)

@property

def changed(self):

""":class:`dict` containing the key value pairs that are not the

return {key: value for key, value in six.iteritems(self)

if getattr(self, key).changed}

@property

def figs2draw(self):

"""All figures that have been manipulated through sharing and the own