"""Combobox showing coordinate information of a dataset

close_popups = _temp_bool_prop("close_popups", default=True)

use_coords = _temp_bool_prop("use_coords", default=False)

leftclick = QtCore.pyqtSignal(QComboBox)

def __init__(self, ds_func, dim, parent=None):

"""

super(CoordComboBox, self).__init__(parent)

self.dim = dim

self._is_empty = True

self.get_ds = ds_func

self._changed = False

self._right_clicked = False

# modify the view

view = self.view()

# We allow the selection of multiple items with a left-click

view.setSelectionMode(QListView.ExtendedSelection)

# The following modifications will cause this behaviour:

# Left-click:

# Case 1: Any of the already existing plot arrays is selected

# Add the selected values in the popup to the dimension in

# the currently selected plot items

# Case 2: No plot arrays are selected or none exists

# Create new plot items from the selection in the popup

# Right-Click:

# Set the currentIndex which will be used when new plot items

# are created

#

# Therefore we first enable a CustomContextMenu

view.setContextMenuPolicy(Qt.CustomContextMenu)

# We have to disable the default MousePressEvent in the views viewport

# because otherwise the Left-click behaviour would occur as well when

# hitting the right button

# Therefore:

# install an EventFilter such that only the customContextMenuRequested

# signal of the view is fired and not the pressed signal (which would

# hide the popup)

view.viewport().installEventFilter(self)

view.customContextMenuRequested.connect(self.right_click)

# Furthermore we implement, that the pop up shall not be closed if the

# keep open property is True. Therefore we have to track when the

# index changes

view.pressed.connect(self.handleItemPressed)

view.doubleClicked.connect(self.hide_anyway)

def eventFilter(self, obj, event):

"""Reimplemented to filter right-click events on the view()"""

ret = (

event.type() == QtCore.QEvent.MouseButtonPress

) and event.button() == Qt.RightButton

return ret

def handleItemPressed(self, index):

"""Function to be called when an item is pressed to make sure that

item = self.model().itemFromIndex(index)

if item.checkState() == Qt.Checked:

item.setCheckState(Qt.Unchecked)

else:

item.setCheckState(Qt.Checked)

self.setCurrentIndex(0)

self._changed = True

def right_click(self, point):

"""Function that is called when an item is right_clicked"""

ind = self.view().indexAt(point).row()

self.setCurrentIndex(ind)

self._right_clicked = True

self._changed = True

def hide_anyway(self, index=None):

"""Function to hide the popup despite of the :attr:`_changed` attribute"""

self._changed = True

self.hidePopup()

def hidePopup(self):

"""Reimplemented to only close the popup when the :attr:`close_popup`

if not self._right_clicked:

self.leftclick.emit(self)

if not self._changed or self.close_popups:

super(CoordComboBox, self).hidePopup()

self._changed = False

self._right_clicked = False

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

"""Reimplemented to fill the box with content from the dataset"""

self.load_coord()

super(CoordComboBox, self).mousePressEvent(*args, **kwargs)

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

"""Reimplemented to fill the box with content from the dataset"""

self.load_coord()

super(CoordComboBox, self).mouseDoubleClickEvent(*args, **kwargs)

def load_coord(self):

"""Load the coordinate data from the dataset and fill the combobox with

if self._is_empty:

ds = self.get_ds()

self.addItem("")

if self.use_coords:

self.addItems(ds[self.dim].astype(str).values)

else:

self.addItems(list(map(str, range(len(ds[self.dim])))))

"""Class to make sure that only those arrays names are inserted that are

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

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

self.table = table

self.current_text = text

self.current_names = list(table.current_names)

def fixup(self, s):

s = asstring(s)

if not s:

return self.table.next_available_name()

return self.table.next_available_name(s + "_{0}")

def validate(self, s, pos):

s = asstring(s)

if not s:

return QValidator.Intermediate, s, pos

elif s == self.current_text:

pass

elif s in chain(psy.gcp(True).arr_names, self.current_names):

return QValidator.Intermediate, s, pos

"""Delegate using the :class:`ArrayNameValidator` for validation"""

def createEditor(self, widget, option, index):

if not index.isValid():

return

editor = QLineEdit(widget)

item = self.parent().item(index.row(), index.column())

validator = ArrayNameValidator(

item.text() if item else "", self.parent(), editor

)

editor.setValidator(validator)

"""Delegate alowing only the variables in the parents dataset.

def createEditor(self, widget, option, index):

if not index.isValid():

return

editor = QLineEdit(widget)

ds = self.parent().get_ds()

validator = ListValidator(

ds.variables.keys(), self.parent().sep, editor

)

editor.setValidator(validator)

"""Table to display the variables of a dataset"""

#: The variables in the dataset

variables = []

@property

def selected_variables(self):

"""The currently selected variables"""

return [

self.variables[i]

for i in map(

list(map(asstring, self.variables)).index,

sorted(

set(

item.text()

for item in self.selectedItems()

if item.column() == 0

)

),

)

]

def __init__(

self, get_func, columns=["long_name", "dims", "shape"], *args, **kwargs

):

"""

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

self.variables = []

self.get_ds = get_func

self.set_columns(columns)

self.setEditTriggers(QAbstractItemView.NoEditTriggers)

self.verticalHeader().setVisible(False)

def set_columns(self, columns=None):

if columns is None:

columns = self.column_labels

else:

self.column_labels = columns

self.setColumnCount(len(columns) + 1)

self.setHorizontalHeaderLabels(["variable"] + columns)

def fill_from_ds(self, ds=None):

"""Clear the table and insert items from the given `dataset`"""

self.clear()

self.set_columns()

if ds is None:

ds = self.get_ds()

if ds is None:

return

coords = list(ds.coords)

self.variables = vnames = [v for v in ds.variables if v not in coords]

self.setRowCount(len(vnames))

for i, vname in enumerate(vnames):

variable = ds.variables[vname]

self.setItem(i, 0, QTableWidgetItem(asstring(vname)))

for j, attr in enumerate(self.column_labels, 1):

if attr == "dims":

self.setItem(

i, j, QTableWidgetItem(", ".join(variable.dims))

)

else:

self.setItem(

i,

j,

QTableWidgetItem(

str(

variable.attrs.get(

attr, getattr(variable, attr, "")

)

)

),

"""A table showing the coordinates of in a dataset via instances of

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

"""

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

self.get_ds = get_func

self.setEditTriggers(QAbstractItemView.NoEditTriggers)

self.setRowCount(1)

self.verticalHeader().setVisible(False)

self.horizontalHeader().setStretchLastSection(True)

self.verticalHeader().setStretchLastSection(True)

@property

def combo_boxes(self):

"""A list of :class:`CoordComboBox` in this table"""

return list(

filter(

lambda w: w is not None,

(self.cellWidget(0, i) for i in range(self.columnCount())),

)

)

def fill_from_ds(self, ds=None):

"""Clear the table and create new comboboxes"""

for cb in self.combo_boxes:

cb.blockSignals(True)

self.clear()

if ds is None:

ds = self.get_ds()

if ds is None:

return

coords = list(ds.coords)

vnames = [v for v in ds.variables if v not in coords]

self.dims = dims = list(

set(chain(*(ds.variables[vname].dims for vname in vnames)))

)

try:

dims.sort()

except TypeError:

pass

self.setColumnCount(len(dims))

for i, dim in enumerate(dims):

header_item = QTableWidgetItem(dim)

self.setHorizontalHeaderItem(i, header_item)

self.setCellWidget(0, i, CoordComboBox(self.get_ds, dim))

def sizeHint(self):

"""Reimplemented to adjust the heigth based upon the header and the

return QtCore.QSize(

super(CoordsTable, self).sizeHint().width(),

self.horizontalHeader().height() + self.rowHeight(0),

"""Table that allows to exchange rows via drag and drop

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

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

self.setDragEnabled(True)

self.setAcceptDrops(True)

self.viewport().setAcceptDrops(True)

self.setDragDropOverwriteMode(False)

self.setDropIndicatorShown(True)

self.setSelectionMode(QAbstractItemView.ExtendedSelection)

self.setSelectionBehavior(QAbstractItemView.SelectRows)

self.setDragDropMode(QAbstractItemView.InternalMove)

def dropEvent(self, event):

if event.source() == self and (

event.dropAction() == Qt.MoveAction

or self.dragDropMode() == QAbstractItemView.InternalMove

):

self.dropOn(event)

else:

super(DragDropTable, self).dropEvent(event)

def moveRows(self, row, remove=False):

"""Move all selected rows to the given `row`"""

selRows = sorted({ind.row() for ind in self.selectedIndexes()})

top = selRows[0]

dropRow = row

if dropRow == -1:

dropRow = self.rowCount()

offset = dropRow - top

for i, row in enumerate(selRows):

r = row + offset

if r > self.rowCount() or r < 0:

r = 0

self.insertRow(r)

selRows = sorted({ind.row() for ind in self.selectedIndexes()})

top = selRows[0]

offset = dropRow - top

for i, row in enumerate(selRows):

r = row + offset

if r > self.rowCount() or r < 0:

r = 0

for j in range(self.columnCount()):

source = QTableWidgetItem(self.item(row, j))

self.setItem(r, j, source)

if remove:

for row in reversed(selRows):

self.removeRow(row)

def droppingOnItself(self, event, index):

dropAction = event.dropAction()

if self.dragDropMode() == QAbstractItemView.InternalMove:

dropAction = Qt.MoveAction

if (

event.source() == self

and event.possibleActions() & Qt.MoveAction

and dropAction == Qt.MoveAction

):

selectedIndexes = self.selectedIndexes()

child = index

while child.isValid() and child != self.rootIndex():

if child in selectedIndexes:

return True

child = child.parent()

return False

def dropOn(self, event):

if event.isAccepted():

return False, None, None, None

index = QtCore.QModelIndex()

row = -1

if self.viewport().rect().contains(event.pos()):

index = self.indexAt(event.pos())

if not index.isValid() or not self.visualRect(index).contains(

event.pos()

):

index = self.rootIndex()

if self.model().supportedDropActions() & event.dropAction():

if index != self.rootIndex():

dropIndicatorPosition = self.position(

event.pos(), self.visualRect(index), index

)

if dropIndicatorPosition == QAbstractItemView.AboveItem:

row = index.row()

# index = index.parent()

elif dropIndicatorPosition == QAbstractItemView.BelowItem:

row = index.row() + 1

# index = index.parent()

else:

row = index.row()

if not self.droppingOnItself(event, index):

self.moveRows(row, remove=event.source() is None)

event.accept()

def position(self, pos, rect, index):

r = QAbstractItemView.OnViewport

margin = 2

if pos.y() - rect.top() < margin:

r = QAbstractItemView.AboveItem

elif rect.bottom() - pos.y() < margin:

r = QAbstractItemView.BelowItem

elif rect.contains(pos, True):

r = QAbstractItemView.OnItem

if r == QAbstractItemView.OnItem and not (

self.model().flags(index) & Qt.ItemIsDropEnabled

):

if pos.y() < rect.center().y():

r = QAbstractItemView.AboveItem

else:

r = QAbstractItemView.BelowItem

"""Table that shows the arrays that will be used for plotting

#: Pattern to interprete subplots

subplot_patt = re.compile(

r"\((?P<fig>\d+),\s*" # figure

r"(?P<rows>\d+),\s*" # rows

r"(?P<cols>\d+),\s*" # columns

r"(?P<num1>\d+),\s*" # position

r"(?P<num2>\d+)\s*\)" # end subplot

)

#: pattern to interprete arbitrary axes

axes_patt = re.compile(

r"\((?P<fig>\d+),\s*" # figure

r"(?P<x0>0*\.\d+),\s*" # lower left x

r"(?P<y0>0*\.\d+),\s*" # lower left y

r"(?P<x1>0*\.\d+),\s*" # upper right x

r"(?P<y1>0*\.\d+)\s*\)" # upper right y

)

#: The separator for variable names

sep = ";;"

#: Tool tip for the variable column

VARIABLE_TT = (

"The variables of the array from the dataset. Multiple"

"variables for one array may be separated by '%s'" % (sep)

)

#: Base tool tip for a dimension column

DIMS_TT = (

"The values for dimension %s."

" You can use integers either explicit, e.g."

"<ul>"

"<li>1, 2, 3, ...,</li>"

"</ul>"

"or slices like <em>start:end:step</em>, e.g."

"<ul>"

"<li>'1:6:2'</li>"

"</ul>"

"where the latter is equivalent to '1, 3, 5'"

)

def dropEvent(self, event):

"""Reimplemented to call the :meth:`check_arrays` after the call"""

# apparently the row deletion occurs after the call of this method.

# therefore our call of `check_arrays` leads to the (wrong) result

# of a duplicated entry. We therefore filter them out here and make

# sure that those arrays are not considered when checking for

# duplicates

messages = dict(

zip(self.current_names, [msg for b, msg in self.check_arrays()])

)

super(ArrayTable, self).dropEvent(event)

ignores = [

arr_name

for arr_name, msg in messages.items()

if not msg.startswith("Found duplicated entry of")

]

self.check_arrays(ignore_duplicates=ignores)

@property

def prefer_list(self):

"""Return the _prefer_list attribute of the plot_method"""

return self.plot_method and self.plot_method._prefer_list

@property

def current_names(self):

"""The names that are currently in use"""

if self.prefer_list:

return []

arr_col = self.arr_col

return [

asstring(item.text())

for item in filter(

None,

map(lambda i: self.item(i, arr_col), range(self.rowCount())),

)

]

@property

def vnames(self):

"""The list of variable names per array"""

var_col = self.var_col

return [

self.item(i, var_col).text().split(";;")

for i in range(self.rowCount())

]

@property

def arr_names_dict(self):

"""The final dictionary containing the array names necessary for the

ret = dict()

arr_col = self.arr_col

for irow in range(self.rowCount()):

arr_name = asstring(self.item(irow, arr_col).text())

if self.plot_method and self.plot_method._prefer_list:

d = ret.setdefault(arr_name, defaultdict(list))

d["name"].append(self._get_variables(irow))

for key, val in self._get_dims(irow).items():

d[key].append(val)

else:

ret[arr_name] = d = {"name": self._get_variables(irow)}

d.update(self._get_dims(irow))

return ret

@property

def axes(self):

"""A list of axes settings corresponding to the arrays in the

ret = []

d = set()

arr_col = self.arr_col

axes_col = self.axes_col

# get the projection

pm = self.plot_method

kwargs = {}

if pm is not None:

projection = self.plot_method.plotter_cls._get_sample_projection()

if projection is not None:

kwargs["projection"] = projection

for irow in range(self.rowCount()):

arr_name = self.item(irow, arr_col).text()

if arr_name in d:

continue

d.add(arr_name)

axes_type, args = self.axes_info(self.item(irow, axes_col))

if axes_type == "subplot":

ret.append(SubplotCreator.create_subplot(*args, **kwargs))

elif axes_type == "axes":

ret.append(AxesCreator.create_axes(*args, **kwargs))

else:

ret.append(None)

return ret

@property

def var_col(self):

"""The index of the variable column"""

return self.desc_cols.index(self.VARIABLE_LABEL)

@property

def arr_col(self):

"""The index of the array name column"""

return self.desc_cols.index(self.ARRAY_LABEL)

@property

def axes_col(self):

"""The index of the axes column"""

return self.desc_cols.index(self.AXES_LABEL)

@property

def check_col(self):

"""The index of the check column"""

return self.desc_cols.index(self.CHECK_LABEL)

def __init__(self, get_func, columns=[], *args, **kwargs):

"""

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

self.get_ds = get_func

self.VARIABLE_LABEL = "variable"

self.ARRAY_LABEL = "array name"

self.AXES_LABEL = "axes"

self.CHECK_LABEL = "check"

self.desc_cols = [

self.VARIABLE_LABEL,

self.ARRAY_LABEL,

self.AXES_LABEL,

self.CHECK_LABEL,

]

self.plot_method = None

self.setSelectionBehavior(QAbstractItemView.SelectRows)

self.setContextMenuPolicy(Qt.CustomContextMenu)

self.customContextMenuRequested.connect(self.showAxesCreator)

self.set_columns(columns)

self.setItemDelegateForColumn(self.var_col, VariableItemDelegate(self))

self.setItemDelegateForColumn(

self.arr_col, ArrayNameItemDelegate(self)

)

self.itemChanged.connect(self.check_item)

self.itemChanged.connect(self.update_other_items)

def set_columns(self, columns):

"""Set the columns of the table

if columns is None:

columns = self.column_labels

else:

self.column_labels = columns

self.setColumnCount(len(columns) + len(self.desc_cols))

self.setHorizontalHeaderLabels(self.desc_cols + columns)

for i, col in enumerate(columns, len(self.desc_cols)):

self.horizontalHeaderItem(i).setToolTip(self.DIMS_TT % col)

self.horizontalHeaderItem(self.var_col).setToolTip(self.VARIABLE_TT)

def setup_from_ds(self, ds=None, plot_method=None):

"""Fill the table based upon the given dataset.

self.clear()

self.setRowCount(0)

if ds is None:

ds = self.get_ds()

if plot_method is not None:

self.set_pm(plot_method)

if ds is None:

self.set_columns([])

return

coords = list(ds.coords)

vnames = [v for v in ds.variables if v not in coords]

self.dims = dims = list(

set(chain(*(ds.variables[vname].dims for vname in vnames)))

)

try:

dims.sort()

except TypeError:

pass

self.set_columns(dims)

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

"""Gives the next possible name to use"""

counter = iter(range(1000))

current_names = self.current_names

mp = psy.gcp(True)

while True:

name = mp.next_available_name(*args, counter=counter, **kwargs)

if name not in current_names:

return name

def insert_array(self, name, check=True, **kwargs):

"""Appends the settings for an array the the list in a new row"""

dims = set(self.get_ds().variables[name].dims)

irow = self.rowCount()

self.setRowCount(irow + 1)

self.setItem(irow, 0, QTableWidgetItem(asstring(name)))

self.setItem(irow, 1, QTableWidgetItem(self.next_available_name()))

self.setItem(irow, 2, QTableWidgetItem(""))

for dim in dims.intersection(kwargs):

icol = len(self.desc_cols) + self.dims.index(dim)

self.setItem(irow, icol, QTableWidgetItem(kwargs[dim]))

if check:

self.check_array(irow)

def remove_arrays(self, selected=True):

"""Remove array rows from the list

if selected:

irows = sorted({ind.row() for ind in self.selectedIndexes()})

else:

irows = list(range(self.rowCount()))

for irow in irows[::-1]:

self.removeRow(irow)

def update_selected(self, check=True, dims={}):

"""Updates the dimensions of the selectiond arrays with the given

ds = self.get_ds()

irows = {item.row() for item in self.selectedItems()}

var_col = self.desc_cols.index(self.VARIABLE_LABEL)

for irow in irows:

vname = (

asstring(self.item(irow, var_col).text())

.split(self.sep)[0]

.strip()

)

var_dims = set(ds.variables[vname].dims)

for dim in var_dims.intersection(dims):

icol = len(self.desc_cols) + self.dims.index(dim)

item = self.item(irow, icol)

curr_text = asstring(item.text())

if curr_text:

curr_text += ", "

item.setText(curr_text + dims[dim])

if check:

for irow in irows:

self.check_array(irow)

def add_subplots(self, rows, cols, maxn=None):

"""Add multiple subplots to the selected arrays"""

import matplotlib.pyplot as plt

irows = sorted({ind.row() for ind in self.selectedIndexes()})

irows = irows or list(range(self.rowCount()))

maxn = maxn or rows * cols

figs = chain(

*([i] * maxn for i in range(1, 1000) if i not in plt.get_fignums())

)

nums = cycle(range(1, maxn + 1))

seen = set()

axes_col = self.desc_cols.index(self.AXES_LABEL)

arr_col = self.desc_cols.index(self.ARRAY_LABEL)

for irow in irows:

arr_item = self.item(irow, arr_col)

if arr_item is None or arr_item.text() in seen:

continue

seen.add(arr_item.text())

num = next(nums)

text = "(%i, %i, %i, %i, %i)" % (next(figs), rows, cols, num, num)

item = QTableWidgetItem(text)

self.setItem(irow, axes_col, item)

def add_single_subplot(self, rows, cols, row, col):

"""Add one subplot to the selected arrays on multiple figures"""

import matplotlib.pyplot as plt

irows = sorted({ind.row() for ind in self.selectedIndexes()})

irows = irows or list(range(self.rowCount()))

figs = (num for num in range(1, 1000) if num not in plt.get_fignums())

num = (row - 1) * rows + col

seen = set()

axes_col = self.desc_cols.index(self.AXES_LABEL)

arr_col = self.desc_cols.index(self.ARRAY_LABEL)

for irow in irows:

arr_item = self.item(irow, arr_col)

if arr_item is None or arr_item.text() in seen:

continue

seen.add(arr_item.text())

text = "(%i, %i, %i, %i, %i)" % (next(figs), rows, cols, num, num)

item = QTableWidgetItem(text)

self.setItem(irow, axes_col, item)

def showAxesCreator(self, pos):

"""Context menu for right-click on a row"""

irows = sorted({ind.row() for ind in self.selectedIndexes()})

if not irows:

return

menu = QMenu(self)

menu.addAction(self.axes_creator_action(irows))

menu.exec_(self.mapToGlobal(pos))

def axes_creator_action(self, rows):

"""Action to open a :class:`AxesCreatorCollection` for the selected

axes_col = self.desc_cols.index(self.AXES_LABEL)

items = [self.item(row, axes_col) for row in rows]

action = QAction("Select subplot", self)

types_and_args = list(

filter(lambda t: t[0], map(self.axes_info, items))

)

types = [t[0] for t in types_and_args]

if types and all(t == types[0] for t in types):

if types[0] == "subplot":

creator_kws = ["fig", "rows", "cols", "num1", "num2"]

elif types[0] == "axes":

creator_kws = ["fig", "x0", "y0", "x1", "y1"]

else:

creator_kws = []

func_name = types[0]

args = [t[1] for t in types_and_args]

#: the initialization keywords of the :class:`SubplotCreator` class

kwargs = {}

if len(items) > 0:

kwargs["fig"] = ""

for kw, vals in zip(creator_kws, zip(*args)):

if all(val == vals[0] for val in vals):

kwargs[kw] = vals[0]

else:

func_name = None

kwargs = {}

action.triggered.connect(

self._open_axes_creator(items, func_name, kwargs)

)

return action

def _change_axes(self, items, iterator):

seen = set()

arr_col = self.desc_cols.index(self.ARRAY_LABEL)

for item, text in zip(items, iterator):

arr_name = self.item(item.row(), arr_col).text()

if arr_name in seen:

continue

seen.add(arr_name)

item.setText(text)

def _open_axes_creator(self, items, func_name, kwargs):

def func():

if hasattr(self, "_axes_creator"):

self._axes_creator.close()

self._axes_creator = obj = AxesCreatorCollection(

func_name, kwargs, parent=self

)

obj.okpressed.connect(partial(self._change_axes, items))

obj.exec_()

return func

def axes_info(self, s):

"""Interpretes an axes information"""

s = asstring(s) if isstring(s) else asstring(s.text())

m = self.subplot_patt.match(s)

if m:

return "subplot", list(map(int, m.groups()))

m = self.axes_patt.match(s)

if m:

return "axes", [int(m.groupdict()["fig"])] + list(

map(float, m.groups()[1:])

)

return None, None

def set_pm(self, s):

"""Set the plot method"""