xarray-graph 0.2.2__tar.gz → 0.2.4__tar.gz

{xarray_graph-0.2.2 → xarray_graph-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xarray-graph
-Version: 0.2.2
+Version: 0.2.4
 Summary: PyQt/PySide UI for graphing (x,y) slices of Xarray datasets.
 Keywords: PyQt,PySide,xarray,graph
 Home-page: https://github.com/marcel-goldschen-ohm/xarray-graph

{xarray_graph-0.2.2 → xarray_graph-0.2.4}/pyproject.toml

@@ -35,7 +35,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
 ]
-version = "0.2.2"
+version = "0.2.4"
 
 [project.license]
 text = "MIT"

{xarray_graph-0.2.2 → xarray_graph-0.2.4}/src/xarray_graph/XarrayGraph.py

@@ -153,7 +153,7 @@ class XarrayGraph(QMainWindow):
         self._notes_edit.setPlainText(self.attrs.get('notes', ''))
 
         # populate array math selections
-        # self._update_array_math_comboboxes()
+        self._update_array_math_comboboxes()
     
     @property
     def dims(self) -> list[str]:
@@ -905,8 +905,9 @@ class XarrayGraph(QMainWindow):
             item.deleteLater()
             self.add_region(region)
             
-            # stop drawing regions (draw one at a time)
-            self._set_region_drawing_mode(False)
+            # stop drawing regions (draw one at a time)?
+            if self._draw_single_region_action.isChecked():
+                self._set_region_drawing_mode(False)
 
     def _setup_ui(self) -> None:
         self._setup_menubar()
@@ -916,11 +917,13 @@ class XarrayGraph(QMainWindow):
         self._control_panel_toolbar.setStyleSheet("QToolBar{spacing:2px;}")
         self._control_panel_toolbar.setIconSize(QSize(DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE))
         self._control_panel_toolbar.setMovable(False)
+        self._control_panel_toolbar.setContextMenuPolicy(Qt.ContextMenuPolicy.PreventContextMenu)
 
         self._plot_grid_toolbar = QToolBar()
         self._plot_grid_toolbar.setStyleSheet("QToolBar{spacing:2px;}")
         self._plot_grid_toolbar.setIconSize(QSize(DEFAULT_ICON_SIZE, DEFAULT_ICON_SIZE))
         self._plot_grid_toolbar.setMovable(False)
+        self._plot_grid_toolbar.setContextMenuPolicy(Qt.ContextMenuPolicy.PreventContextMenu)
         icon_button = QToolButton()
         icon_button.setIcon(qta.icon('fa5s.cubes', options=[{'opacity': 0.5}]))
         icon_button.pressed.connect(self.refresh)
@@ -991,6 +994,18 @@ class XarrayGraph(QMainWindow):
         self._region_button.clicked.connect(self._set_region_drawing_mode)
         self._action_after_dim_iter_things = self._plot_grid_toolbar.addWidget(self._region_button)
 
+        self._region_button_menu = QMenu()
+        self._draw_single_region_action = QAction('Draw single region', self._region_button_menu, checkable=True, checked=True)
+        self._draw_multiple_regions_action = QAction('Draw multiple regions', self._region_button_menu, checkable=True, checked=False)
+        self._region_button_menu.addAction(self._draw_single_region_action)
+        self._region_button_menu.addAction(self._draw_multiple_regions_action)
+        group = QActionGroup(self._region_button_menu)
+        group.addAction(self._draw_single_region_action)
+        group.addAction(self._draw_multiple_regions_action)
+        group.setExclusive(True)
+        self._region_button.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self._region_button.customContextMenuRequested.connect(lambda pos: self._region_button_menu.exec_(self._region_button.mapToGlobal(pos)))
+
         self._home_button = QToolButton()
         self._home_button.setIcon(qta.icon('mdi.home-outline', options=[{'opacity': 0.5}]))
         self._home_button.setToolTip('Autoscale all plots')
@@ -1176,7 +1191,7 @@ class XarrayGraph(QMainWindow):
         self._math_operator_combobox.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Preferred)
 
         self._math_eval_button = QPushButton('Evaluate')
-        # self._math_eval_button.clicked.connect(self.eval_array_math)
+        self._math_eval_button.pressed.connect(self.eval_array_math)
 
         math_group = QGroupBox('Array math')
         grid = QGridLayout(math_group)
@@ -1645,57 +1660,48 @@ class XarrayGraph(QMainWindow):
                 if isinstance(item, XAxisRegion):
                     item.setFontSize(self._textitem_fontsize_spinbox.value())
 
-    # def _update_array_math_comboboxes(self) -> None:
-    #     var_items = []
-    #     item = self._data_treeview.model().root
-    #     while item is not None:
-    #         if item.is_var():
-    #             var_items += [item.name_from_path(maxchar=100)]
-    #         item = item.next_depth_first()
-    #     self._math_lhs_combobox.clear()
-    #     self._math_rhs_combobox.clear()
-    #     self._math_lhs_combobox.addItems(var_items)
-    #     self._math_rhs_combobox.addItems(var_items)
+    def _update_array_math_comboboxes(self) -> None:
+        var_paths = [item.path for item in self._data_treeview.model().root().depth_first() if item.is_var()]
+        for i in range(len(var_paths)):
+            if len(var_paths[i]) > 100:
+                var_paths[i] = '...' + var_paths[i][-97:]
+        self._math_lhs_combobox.clear()
+        self._math_rhs_combobox.clear()
+        self._math_lhs_combobox.addItems(var_paths)
+        self._math_rhs_combobox.addItems(var_paths)
     
-    # def eval_array_math(self) -> None:
-    #     var_items = []
-    #     item = self._data_treeview.model().root
-    #     while item is not None:
-    #         if item.is_var():
-    #             var_items += [item]
-    #         item = item.next_depth_first()
-    #     lhs_item = var_items[self._math_lhs_combobox.currentIndex()]
-    #     rhs_item = var_items[self._math_rhs_combobox.currentIndex()]
-    #     lhs: xr.DataArray = lhs_item.node.inherited_data(lhs_item.key)
-    #     rhs: xr.DataArray = rhs_item.node.inherited_data(rhs_item.key)
-    #     op = self._math_operator_combobox.currentText()
-    #     # TODO: limit vars to the intersection of their coords
-    #     if op == '+':
-    #         result = lhs + rhs
-    #     elif op == '-':
-    #         result = lhs - rhs
-    #     elif op == '*':
-    #         result = lhs * rhs
-    #     elif op == '/':
-    #         result = lhs / rhs
-    #     # append result as child of lhs_item
-    #     # TODO: handle result name collisions
-    #     result_name = self._math_result_name_edit.text().strip()
-    #     ds = xr.Dataset(data_vars={result.name: result})
-    #     result_node = XarrayTreeNode(name=result_name, dataset=ds, parent=lhs_item.node)
+    def eval_array_math(self) -> None:
+        var_items = [item for item in self._data_treeview.model().root().depth_first() if item.is_var()]
+        lhs_item = var_items[self._math_lhs_combobox.currentIndex()]
+        rhs_item = var_items[self._math_rhs_combobox.currentIndex()]
+        lhs: xr.DataArray = lhs_item.node[lhs_item.key]
+        rhs: xr.DataArray = rhs_item.node[rhs_item.key]
+        op = self._math_operator_combobox.currentText()
+        if op == '+':
+            result = lhs + rhs
+        elif op == '-':
+            result = lhs - rhs
+        elif op == '*':
+            result = lhs * rhs
+        elif op == '/':
+            result = lhs / rhs
+        # append result as child of lhs_item
+        result_name = self._math_result_name_edit.text().strip()
+        if result_name == '':
+            result_name = self._math_result_name_edit.placeholderText()
+        result_ds = xr.Dataset(data_vars={result.name: result})
+        result_node = DataTree(name=result_name, data=result_ds, parent=lhs_item.node)
         
-    #     # update data tree
-    #     self.data = self.data
-
-    #     # make sure newly added node is selected and expanded
-    #     model: XarrayTreeModel = self._data_treeview.model()
-    #     item: XarrayTreeItem = model.root
-    #     while item is not None:
-    #         if item.node is result_node and item.is_var():
-    #             index: QModelIndex = model.createIndex(item.row(), 0, item)
-    #             self._data_treeview.selectionModel().select(index, QItemSelectionModel.SelectionFlag.Select | QItemSelectionModel.SelectionFlag.Rows)
-    #             self._data_treeview.setExpanded(model.parent(index), True)
-    #         item = item.next_depth_first()
+        # update data tree
+        self.data = self.data
+
+        # make sure newly added fit nodes are selected and expanded
+        model: XarrayTreeModel = self._data_treeview.model()
+        for item in model.root().depth_first():
+            if item.node is result_node and item.is_var():
+                index: QModelIndex = model.createIndex(item.sibling_index, 0, item)
+                self._data_treeview.selectionModel().select(index, QItemSelectionModel.SelectionFlag.Select | QItemSelectionModel.SelectionFlag.Rows)
+                self._data_treeview.setExpanded(model.parent(index), True)
     
     # # @Slot()
     # # def on_axes_item_changed(self):
@@ -1725,7 +1731,7 @@ class XarrayGraph(QMainWindow):
                 i = np.argpartition(x, len(x) // 2)[len(x) // 2]
                 return x[i]
         if measure_type in ['Min', 'Max', 'AbsMax', 'Peaks']:
-            peak_width = self._peak_width_spinbox.value()
+            peak_width = self._peak_half_width_spinbox.value()
             if peak_width > 0:
                 def get_peak_index_range(mask, center_index):
                     start, stop = center_index, center_index + 1
@@ -2010,21 +2016,21 @@ class XarrayGraph(QMainWindow):
                 dims = yarr.dims
                 
                 # region mask for fit optimization and/or evaluation
-                if regions and (self._curve_fit_optimize_in_visible_regions_checkbox.isChecked() or self._curve_fit_evaluate_in_visible_regions_checkbox.isChecked()):
+                if regions and (self._curve_fit_optimize_in_regions_checkbox.isChecked() or self._curve_fit_evaluate_in_regions_checkbox.isChecked()):
                     # mask for combined regions
                     regions_mask = np.full(xdata.shape, False)
                     for region in regions:
                         xmin, xmax = region
                         regions_mask[(xdata >= xmin) & (xdata <= xmax)] = True
 
-                if regions and self._curve_fit_optimize_in_visible_regions_checkbox.isChecked():
+                if regions and self._curve_fit_optimize_in_regions_checkbox.isChecked():
                     xinput = xdata[regions_mask]
                     yinput = ydata[regions_mask]
                 else:
                     xinput = xdata
                     yinput = ydata
 
-                if regions and self._curve_fit_evaluate_in_visible_regions_checkbox.isChecked():
+                if regions and self._curve_fit_evaluate_in_regions_checkbox.isChecked():
                     xoutput = xdata[regions_mask]
                 else:
                     xoutput = xdata