llwp 2.1.0__tar.gz → 2.1.2__tar.gz

{llwp-2.1.0/llwp.egg-info → llwp-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llwp
-Version: 2.1.0
+Version: 2.1.2
 Summary: LLWP is a fast, efficient and easy solution for exploring and assigning spectra - relying on Loomis-Wood plots.
 Author-email: Luis Bonah <bonah@ph1.uni-koeln.de>
 License-Expression: GPL-3.0-only

{llwp-2.1.0 → llwp-2.1.2}/llwp/LLWP.py

@@ -158,6 +158,10 @@ def status_d(func):
     return _wrapper
 
 
+# Guards all modifications of matplotlib artists as well as the rendering of the figures
+matplotlib_lock = threading.RLock()
+
+
 def lock_d(lock):
     @wrapt.decorator
     def _wrapper(wrapped, instance, args, kwargs):
@@ -357,6 +361,7 @@ class Config(dict):
         "flag_showseriesarrows": (True, bool),
         "flag_keeponlylastassignment": (False, bool),
         "flag_autoreloadfiles": (True, bool),
+        "flag_reloadlinafterdelete": (True, bool),
         "flag_lincustomfreqformat": ("", str),
         "flag_allowdocking": (True, bool),
         "flag_docksalwaysontop": (True, bool),
@@ -682,7 +687,11 @@ class PlotWidget(QWidget):
             np.zeros(shape=(0, 2, 2)), colors=config["color_cat"], capstyle="round"
         )
         self.lin_coll = self.ax.scatter(
-            [], [], color=config["color_ref"], marker=config["plot_linmarker"], zorder=100
+            [],
+            [],
+            color=config["color_ref"],
+            marker=config["plot_linmarker"],
+            zorder=100,
         )
         self.ax.add_collection(self.exp_coll, autolim=False)
         self.ax.add_collection(self.cat_coll, autolim=False)
@@ -702,6 +711,7 @@ class PlotWidget(QWidget):
 
         self.update_plot()
 
+    @lock_d(matplotlib_lock)
     def update_plot(self):
         scaling = config["plot_yscale"]
 
@@ -877,18 +887,15 @@ class PlotWidget(QWidget):
             "s": lambda: self.move_plot("out"),
             "a": lambda: self.move_plot("left"),
             "d": lambda: self.move_plot("right"),
-
             "Shift+w": lambda: self.move_plot("sin"),
             "Shift+s": lambda: self.move_plot("sout"),
             "Shift+a": lambda: self.move_plot("sleft"),
             "Shift+d": lambda: self.move_plot("sright"),
-
             # We cannot use shortcuts that are also used in the menu bar here, as these are global shortcuts on MacOS, as the MenuBar is always active
             "Alt+w": lambda: self.change_index(0, +1),
             "Alt+s": lambda: self.change_index(0, -1),
             "Alt+a": lambda: self.change_index(1, -1),
             "Alt+d": lambda: self.change_index(1, +1),
-
             "Alt+Up": lambda: self.change_index(0, +1),
             "Alt+Down": lambda: self.change_index(0, -1),
             "Alt+Left": lambda: self.change_index(1, -1),
@@ -910,16 +917,17 @@ class PlotWidget(QWidget):
 
 
 drawplot_decorator = DynamicDecorator()
-matplotlib_lock = threading.RLock()
 
 
 ##
 ## Customized PyQt classes
 ##
 class QThread(QThread):
+    # Maps each function to the sequence number of its most recently created thread
     active_runnables = {}
     lock = threading.RLock()
     threads = set()
+    _sequence = AtomicCounter()
 
     @classmethod
     def threaded_d(cls, func):
@@ -930,26 +938,37 @@ class QThread(QThread):
 
         return wrapper
 
+    @classmethod
+    def _release_finished(cls):
+        # Python references are only dropped once Qt reports the thread as finished.
+        # Dropping them earlier (e.g. from the finished signal, which is emitted
+        # before the thread has fully stopped) can destroy a running QThread.
+        with cls.lock:
+            for thread in [t for t in cls.threads if t.isFinished()]:
+                thread.wait()
+                cls.threads.discard(thread)
+
     def __init__(self, function, *args, **kwargs):
         super().__init__()
         self.function, self.args, self.kwargs = function, args, kwargs
-        self.threads.add(self)
-        self.finished.connect(lambda x=self: self.threads.remove(x))
+        with self.lock:
+            self._release_finished()
+            # The sequence number is assigned at creation (not when the thread
+            # starts running), so the newest request always wins and the result
+            # does not depend on OS scheduling or on reused thread idents.
+            self.sequence = self._sequence.increase()
+            self.active_runnables[self.function] = self.sequence
+            self.threads.add(self)
 
     def earlyreturn(self):
-        if self.active_runnables[self.function] != self.thread_id:
+        if self.active_runnables.get(self.function) != self.sequence:
             raise EarlyReturnError
 
     def run(self):
         try:
-            with self.lock:
-                self.thread_id = threading.current_thread().ident
-                self.active_runnables[self.function] = self.thread_id
             self.function(*self.args, **self.kwargs, thread=self)
         except EarlyReturnError:
             pass
-        except Exception:
-            raise
 
 
 class NTimesBehavior(QObject):
@@ -968,7 +987,7 @@ class NTimesBehavior(QObject):
                 event.button() == Qt.MouseButton.LeftButton
                 and event.modifiers() & Qt.KeyboardModifier.AltModifier
             ):
-                i, ok = QInputDialog.getInt(self.widget, "Repat how many times", "N: ")
+                i, ok = QInputDialog.getInt(self.widget, "Repeat how many times", "N: ")
                 if not ok:
                     return True
 
@@ -1138,6 +1157,21 @@ class Figure(Figure):
 
 
 class FigureCanvas(FigureCanvas):
+    # Rendering and painting run in the GUI thread, while worker threads modify the
+    # artists of the figure. Both have to hold the matplotlib_lock, otherwise the
+    # renderer might traverse artists that are removed at the same time.
+    def draw(self):
+        with matplotlib_lock:
+            super().draw()
+
+    def paintEvent(self, event):
+        with matplotlib_lock:
+            super().paintEvent(event)
+
+    def blit(self, *args, **kwargs):
+        with matplotlib_lock:
+            super().blit(*args, **kwargs)
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.wheelEvent = lambda event: event.ignore()
@@ -2342,6 +2376,47 @@ class NewAssignments(LinFile):
                 file.write(pyckett.df_to_lin(df, custom_freq_format=custom_freq_format))
 
 
+def delete_assignments(assignments):
+    new_assignments = None
+    for lin_fname in assignments["filename"].unique():
+        to_delete = assignments[assignments["filename"] == lin_fname]
+        to_delete = to_delete[list(pyckett.lin_dtypes.keys())]
+
+        if lin_fname == "__newassignments__":
+            new_assignments = NewAssignments.get_instance()
+            lin = new_assignments.get_new_assignments_df().copy()
+        else:
+            lin = pyckett.lin_to_df(lin_fname, sort=False)
+
+        lin = pd.merge(lin, to_delete, how="left", indicator=True)
+        lin = lin[lin["_merge"] == "left_only"]
+        lin = lin.drop("_merge", axis="columns").reset_index(drop=True)
+
+        if lin_fname == "__newassignments__":
+            new_assignments.new_assignments_df = lin
+            new_assignments.load_file()
+
+            new_assignments_window = NewAssignmentsWindow.instance
+            new_assignments_window.model.update()
+        else:
+            # Saving the *.lin file after removing the transitions
+            # can overwrite custom formats for the x and error values
+            with open(lin_fname, "w+") as file:
+                custom_freq_format = config["flag_lincustomfreqformat"]
+                file.write(
+                    pyckett.df_to_lin(lin, custom_freq_format=custom_freq_format)
+                )
+
+            # Without the file watcher the file would not be updated otherwise
+            if (
+                config["flag_reloadlinafterdelete"]
+                and not config["flag_autoreloadfiles"]
+            ):
+                lin_file = LinFile.ids.get(lin_fname)
+                if lin_file:
+                    lin_file.load_file()
+
+
 class FileAdditionalSettingsDialog(QDialog):
     open_dialogs = {}
 
@@ -2560,6 +2635,7 @@ class LWPAx:
         self.indices = None
         self.annotation = None
         self.qns = None
+        self.lin_df = None
 
         with matplotlib_lock:
             self.span = matplotlib.widgets.SpanSelector(
@@ -2577,7 +2653,11 @@ class LWPAx:
             np.zeros(shape=(0, 2, 2)), colors=config["color_cat"], capstyle="round"
         )
         self.lin_coll = ax.scatter(
-            [], [], color=config["color_ref"], marker=config["plot_linmarker"], zorder=100
+            [],
+            [],
+            color=config["color_ref"],
+            marker=config["plot_linmarker"],
+            zorder=100,
         )
 
         with matplotlib_lock:
@@ -2591,6 +2671,7 @@ class LWPAx:
                 ax.set_xticks([])
 
     @drawplot_decorator.d
+    @lock_d(matplotlib_lock)
     def update(self):
         ax = self.ax
         ax.set_xlim(self.xrange)
@@ -2705,7 +2786,7 @@ class LWPAx:
 
                 else:
                     segs = np.array(((xs, xs), (ys * 0, ys))).T
-                    colors = dataframe["color"].to_numpy()
+                    colors = dataframe["color"].to_numpy().copy()
 
                     mask = xs == self.ref_position
                     colors[mask] = config["color_ref"]
@@ -2713,6 +2794,7 @@ class LWPAx:
                 self.cat_coll.set(segments=segs, colors=colors)
 
             elif datatype == "lin":
+                self.lin_df = dataframe
                 tuples = list(zip(xs, ys))
                 tuples = tuples if len(tuples) != 0 else [[None, None]]
                 colors = dataframe["color"].to_numpy()
@@ -2874,12 +2956,13 @@ class LWPAx:
 
     def fit_data(self, xmin, xmax):
         # Delete artists highlighting previous fit
-        if self.__class__.fit_vline is not None:
-            self.__class__.fit_vline.remove()
-            self.__class__.fit_vline = None
-        if self.__class__.fit_curve is not None:
-            self.__class__.fit_curve.remove()
-            self.__class__.fit_curve = None
+        with matplotlib_lock:
+            if self.__class__.fit_vline is not None:
+                self.__class__.fit_vline.remove()
+                self.__class__.fit_vline = None
+            if self.__class__.fit_curve is not None:
+                self.__class__.fit_curve.remove()
+                self.__class__.fit_curve = None
 
         # Fit the data
         xmiddle, xuncert, fit_xs, fit_ys = self.fit_peak(xmin, xmax)
@@ -2887,12 +2970,13 @@ class LWPAx:
             QApplication.clipboard().setText(str(xmiddle))
 
         # Highlight fit in plot
-        self.__class__.fit_curve = self.ax.plot(
-            fit_xs, fit_ys, color=config["color_fit"], alpha=0.7, linewidth=1
-        )[0]
-        self.__class__.fit_vline = self.ax.axvline(
-            x=xmiddle, color=config["color_fit"], ls="--", alpha=1, linewidth=1
-        )
+        with matplotlib_lock:
+            self.__class__.fit_curve = self.ax.plot(
+                fit_xs, fit_ys, color=config["color_fit"], alpha=0.7, linewidth=1
+            )[0]
+            self.__class__.fit_vline = self.ax.axvline(
+                x=xmiddle, color=config["color_fit"], ls="--", alpha=1, linewidth=1
+            )
 
         # Create assignment object
         new_assignment = {
@@ -2941,8 +3025,8 @@ class LWPAx:
             xmiddle, xuncert = fit_results["xmiddle"], fit_results["xuncert"]
             fit_xs, fit_ys = fit_results["fit_xs"], fit_results["fit_ys"]
         except Exception as E:
-            self.fitcurve = None
-            self.fitline = None
+            self.fit_curve = None
+            self.fit_line = None
             notify_error.emit(
                 f"The fitting failed with the following error message : {str(E)}"
             )
@@ -3275,7 +3359,7 @@ class LWPWidget(QGroupBox):
 
         for i_col in range(n_widgets):
             thread.earlyreturn()
-            if i_col > n_cols:
+            if i_col >= n_cols:
                 continue
 
             refwidget = tab_widget.widget(i_col)
@@ -3341,24 +3425,28 @@ class LWPWidget(QGroupBox):
         thread.earlyreturn()
 
         # Set the correct values to the LWPAxes
-        if self.lwpaxes.shape != (n_rows, n_cols):
-            notify_error.emit("Shape of LWPAxes is out of sync with requested values.")
-            return
+        # The lock makes sure that the axes are not replaced while they are updated
+        with matplotlib_lock:
+            if self.lwpaxes.shape != (n_rows, n_cols):
+                notify_error.emit(
+                    "Shape of LWPAxes is out of sync with requested values."
+                )
+                return
 
-        for i_row in range(n_rows):
-            for i_col in range(n_cols):
-                ax = self.lwpaxes[i_row, i_col]
-                ax.ref_position = positions[i_row, i_col]
-                ax.xrange = (xmins[i_row, i_col], xmaxs[i_row, i_col])
-                ax.qns = qns[i_row, i_col]
-                ax.indices = {
-                    label: (
-                        min_indices[label][i_row, i_col],
-                        max_indices[label][i_row, i_col],
-                    )
-                    for label in ("exp", "cat", "lin")
-                }
-                ax.update()
+            for i_row in range(n_rows):
+                for i_col in range(n_cols):
+                    ax = self.lwpaxes[i_row, i_col]
+                    ax.ref_position = positions[i_row, i_col]
+                    ax.xrange = (xmins[i_row, i_col], xmaxs[i_row, i_col])
+                    ax.qns = qns[i_row, i_col]
+                    ax.indices = {
+                        label: (
+                            min_indices[label][i_row, i_col],
+                            max_indices[label][i_row, i_col],
+                        )
+                        for label in ("exp", "cat", "lin")
+                    }
+                    ax.update()
 
     def get_current_ax(self):
         shape = self.lwpaxes.shape
@@ -3368,6 +3456,27 @@ class LWPWidget(QGroupBox):
         else:
             return self.lwpaxes[0, 0]
 
+    def get_assignments_at(self, lwpax, event):
+        """Return the assignments whose markers are under the cursor."""
+        lin_df = lwpax.lin_df
+        if lin_df is None or not len(lin_df):
+            return pd.DataFrame()
+
+        ratio = self.plotcanvas.device_pixel_ratio
+        height = self.plotcanvas.get_width_height(physical=True)[1]
+        mouseevent = matplotlib.backend_bases.MouseEvent(
+            "button_press_event",
+            self.plotcanvas,
+            event.x() * ratio,
+            height - event.y() * ratio,
+        )
+        contained, info = lwpax.lin_coll.contains(mouseevent)
+        if not contained:
+            return pd.DataFrame()
+
+        assignments = lin_df.iloc[info["ind"]].copy()
+        return assignments
+
     def contextMenuCanvas(self, event):
         x, y = event.x(), event.y()
         geometry = self.plotcanvas.geometry()
@@ -3389,8 +3498,20 @@ class LWPWidget(QGroupBox):
         open_blend_action = menu.addAction("Open in Blended Lines")
         fit_all_action = menu.addAction("Fit all")
 
+        assignments = self.get_assignments_at(lwpax, event)
+        delete_assignment_action = None
+        if len(assignments):
+            menu.addSeparator()
+            delete_assignment_action = menu.addAction(
+                f"Delete assignment{'s' if len(assignments) > 1 else ''}"
+            )
+
         action = menu.exec(self.plotcanvas.mapToGlobal(event.pos()))
-        if action == get_position_action:
+        if action is None:
+            return
+        if action == delete_assignment_action:
+            delete_assignments(assignments)
+        elif action == get_position_action:
             QApplication.clipboard().setText(str(lwpax.ref_position))
         elif action == get_qns_action:
             output_string = []
@@ -3761,6 +3882,12 @@ class MainWindow(QMainWindow):
         config.register("flag_allowdocking", self.update_docking)
         config.register("flag_docksalwaysontop", self.update_docksalwaysontop)
 
+        self.setDockOptions(
+            QMainWindow.DockOption.AnimatedDocks
+            | QMainWindow.DockOption.AllowNestedDocks
+            | QMainWindow.DockOption.AllowTabbedDocks
+        )
+
         try:
             # Set LLWP logo as icon
             possible_folders = [
@@ -6018,6 +6145,14 @@ class ReferenceSelector(QTabWidget):
         self.values_changed.emit()
         mainwindow.lwpwidget.set_data()
 
+    def change_series_qns(self):
+        i, ok = QInputDialog.getInt(
+            self, "Set Number of Quantum Numbers", "# Quantum Numbers: "
+        )
+        if not ok:
+            return
+        config["series_qns"] = i
+
     def contextMenuEvent(self, event):
         menu = QMenu(self)
         get_positions_action = menu.addAction("Copy Reference Positions")
@@ -6027,8 +6162,15 @@ class ReferenceSelector(QTabWidget):
 
         change_qns_templates = config["series_changeqnsactions"]
         change_qns_actions = {}
+        is_transition_active = self.state["method"] == "Transition"
+
+        if is_transition_active:
+            menu.addSeparator()
+            change_series_qns_action = menu.addAction(
+                "Change number of quantum numbers"
+            )
 
-        if self.state["method"] == "Transition" and len(change_qns_templates):
+        if is_transition_active and len(change_qns_templates):
             menu.addSeparator()
 
             for label in change_qns_templates.keys():
@@ -6065,6 +6207,8 @@ class ReferenceSelector(QTabWidget):
             self.series_selector.change_qns_action(label)
         elif action == list_from_cat_trend_action:
             self.list_from_cat_trend()
+        elif is_transition_active and action == change_series_qns_action:
+            self.change_series_qns()
 
 
 class SeriesSelector(QWidget):
@@ -6620,7 +6764,11 @@ class NewAssignmentsWindow(EQDockWidget):
         # tooltip_append = "Append to file if checked or overwrite content if unchecked"
         new_assignments = self.new_assignments = NewAssignments.get_instance()
 
-        save_label = "Save && Update" if (not config["onsave_skipall"]) and config["onsave_consent"] else "Save"
+        save_label = (
+            "Save && Update"
+            if (not config["onsave_skipall"]) and config["onsave_consent"]
+            else "Save"
+        )
         widgets = self.widgets = {
             "save_settings": QQ(
                 QToolButton,
@@ -6991,7 +7139,9 @@ class OnSaveOptionsDialog(QDialog):
         for widget in self.widgets:
             widget.setEnabled(enabled)
 
-        NewAssignmentsWindow.instance.widgets["save"].setText("Save && Update" if enabled else "Save")
+        NewAssignmentsWindow.instance.widgets["save"].setText(
+            "Save && Update" if enabled else "Save"
+        )
 
     def on_exit(self, _=None):
         self.__class__.open_instance = None
@@ -7637,35 +7787,36 @@ class ResidualsWindow(EQDockWidget):
             colors = df["color"].to_numpy()
             tuples = list(zip(xs, ys))
             tuples = tuples if len(tuples) != 0 else [[None, None]]
-            self.points.set_offsets(tuples)
-            self.points.set_color(colors)
-            if len(xs) and config["residuals_autoscale"]:
-                xmin, xmax = np.min(xs), np.max(xs)
-                if xmin == xmax:
-                    xmin -= 1
-                    xmax += 1
-                self.ax.set_xlim(
-                    [
-                        xmin - 0.02 * (xmax - xmin),
-                        xmax + 0.02 * (xmax - xmin),
-                    ]
-                )
-                ymin, ymax = np.min(ys), np.max(ys)
-                if ymin == ymax:
-                    ymin -= 1
-                    ymax += 1
-                y_range = [ymin, ymax]
-                self.ax.set_ylim(
-                    y_range[0] - config["plot_ymargin"] * (y_range[1] - y_range[0]),
-                    y_range[1] + config["plot_ymargin"] * (y_range[1] - y_range[0]),
-                )
+            with matplotlib_lock:
+                self.points.set_offsets(tuples)
+                self.points.set_color(colors)
+                if len(xs) and config["residuals_autoscale"]:
+                    xmin, xmax = np.min(xs), np.max(xs)
+                    if xmin == xmax:
+                        xmin -= 1
+                        xmax += 1
+                    self.ax.set_xlim(
+                        [
+                            xmin - 0.02 * (xmax - xmin),
+                            xmax + 0.02 * (xmax - xmin),
+                        ]
+                    )
+                    ymin, ymax = np.min(ys), np.max(ys)
+                    if ymin == ymax:
+                        ymin -= 1
+                        ymax += 1
+                    y_range = [ymin, ymax]
+                    self.ax.set_ylim(
+                        y_range[0] - config["plot_ymargin"] * (y_range[1] - y_range[0]),
+                        y_range[1] + config["plot_ymargin"] * (y_range[1] - y_range[0]),
+                    )
+
             notify_info.emit("<br/>".join(message))
         except Exception:
             notify_warning.emit("There was an error in your Residuals window input")
         finally:
             self.plotting_finished.emit()
 
-
     def save_residuals(self):
         df = self.get_residuals()
         fname = QFileDialog.getSaveFileName(
@@ -7734,52 +7885,12 @@ class ResidualsWindow(EQDockWidget):
                     mainwindow.raise_()
                     mainwindow.activateWindow()
                 elif action_to_perform == "deletefromfile":
-                    unique_lin_fnames = tmp_transitions["filename_lin"].unique()
-                    for lin_fname in unique_lin_fnames:
-                        if lin_fname == "__newassignments__":
-                            new_assignments = NewAssignments.get_instance()
-                            lin = new_assignments.get_new_assignments_df().copy()
-                        else:
-                            lin = pyckett.lin_to_df(lin_fname, sort=False)
-
-                        transitions_to_delete = tmp_transitions.query(
-                            "filename_lin == @lin_fname"
-                        )
-                        columns = {
-                            x: x.replace("_lin", "").replace("_x", "")
-                            for x in transitions_to_delete.columns
-                            if (x.endswith("_lin") or x.endswith("_x"))
-                        }
-                        transitions_to_delete = transitions_to_delete.rename(
-                            columns=columns
-                        )
-                        transitions_to_delete = transitions_to_delete[
-                            list(pyckett.lin_dtypes.keys())
-                        ]
-
-                        lin = pd.merge(
-                            lin, transitions_to_delete, how="left", indicator=True
-                        )
-                        lin = lin[lin["_merge"] == "left_only"]
-                        lin = lin.drop("_merge", axis="columns").reset_index(drop=True)
-
-                        if lin_fname == "__newassignments__":
-                            new_assignments.new_assignments_df = lin
-                            new_assignments.load_file()
-
-                            new_assignments_window = NewAssignmentsWindow.instance
-                            new_assignments_window.model.update()
-                            # new_assignments_window.model.resize_columns()
-                        else:
-                            # Saving the *.lin file after removing the transitions
-                            # can overwrite custom formats for the x and error values
-                            with open(lin_fname, "w+") as file:
-                                custom_freq_format = config["flag_lincustomfreqformat"]
-                                file.write(
-                                    pyckett.df_to_lin(
-                                        lin, custom_freq_format=custom_freq_format
-                                    )
-                                )
+                    columns = {
+                        x: x.replace("_lin", "").replace("_x", "")
+                        for x in tmp_transitions.columns
+                        if (x.endswith("_lin") or x.endswith("_x"))
+                    }
+                    delete_assignments(tmp_transitions.rename(columns=columns))
 
     def fit_file_context_menu(self, pos):
         menu = QMenu(self)
@@ -7835,7 +7946,6 @@ class BlendedLinesWindow(EQDockWidget):
                     [], [], color=config["blendedlines_color_total"]
                 )[0]
                 self.plot_parts = []
-                self.plot_parts_lock = threading.Lock()
                 self.update_plot_requested.connect(super().update_plot)
 
             def update_plot(self):
@@ -7976,7 +8086,7 @@ class BlendedLinesWindow(EQDockWidget):
                 x, profile, derivative, 0, *args, fixedwidth=fixedwidth
             )
 
-        with plot_widget.plot_parts_lock:
+        with matplotlib_lock:
             for part in plot_widget.plot_parts:
                 part.remove()
             plot_widget.plot_parts = []
@@ -8076,8 +8186,9 @@ class BlendedLinesWindow(EQDockWidget):
 
         ax = plot_widget.ax
 
-        plot_widget.fit_line.set_data(res_xs, res_ys)
-        plot_widget.fit_line.set_color(config["blendedlines_color_total"])
+        with matplotlib_lock:
+            plot_widget.fit_line.set_data(res_xs, res_ys)
+            plot_widget.fit_line.set_color(config["blendedlines_color_total"])
 
         opt_param = []
         err_param = []
@@ -8101,7 +8212,7 @@ class BlendedLinesWindow(EQDockWidget):
             tmp_ys = fitfunction_no_baseline(res_xs, *tmp_params)
             tmp_ys += exp_mean
 
-            with plot_widget.plot_parts_lock:
+            with matplotlib_lock:
                 plot_widget.plot_parts.append(
                     ax.plot(
                         res_xs,
@@ -8114,7 +8225,7 @@ class BlendedLinesWindow(EQDockWidget):
             opt_param.append(tmp_params)
             err_param.append(tmp_errors)
 
-        with plot_widget.plot_parts_lock:
+        with matplotlib_lock:
             plot_widget.plot_parts.append(
                 ax.scatter(
                     [x[0] for x in opt_param],
@@ -8125,7 +8236,7 @@ class BlendedLinesWindow(EQDockWidget):
 
         if polynomrank > 0 and config["blendedlines_showbaseline"]:
             baseline_args = popt[-polynomrank:]
-            with plot_widget.plot_parts_lock:
+            with matplotlib_lock:
                 plot_widget.plot_parts.append(
                     ax.plot(
                         res_xs,
@@ -8164,7 +8275,7 @@ class BlendedLinesWindow(EQDockWidget):
 
         peaks = self.peaks.copy()
         fixedwidth = config["blendedlines_fixedwidth"]
-        with plot_widget.plot_parts_lock:
+        with matplotlib_lock:
             for part in plot_widget.plot_parts:
                 part.remove()
             plot_widget.plot_parts = []
@@ -8337,7 +8448,7 @@ class BlendedLinesWindow(EQDockWidget):
 
                 idx += delta_idx
 
-        with plot_widget.plot_parts_lock:
+        with matplotlib_lock:
             plot_widget.plot_parts.append(
                 ax.scatter(
                     [x[0] for x in opt_param],
@@ -8366,8 +8477,9 @@ class BlendedLinesWindow(EQDockWidget):
 
         thread.earlyreturn()
 
-        plot_widget.fit_line.set_data(res_xs, res_ys)
-        plot_widget.fit_line.set_color(config["blendedlines_color_total"])
+        with matplotlib_lock:
+            plot_widget.fit_line.set_data(res_xs, res_ys)
+            plot_widget.fit_line.set_color(config["blendedlines_color_total"])
 
         self.fill_table_requested.emit()
         self.set_indicator_text.emit("Ready")
@@ -9097,28 +9209,29 @@ class EnergyLevelsWindow(EQDockWidget):
             colors = df["color"].to_numpy()
             tuples = list(zip(xs, ys))
             tuples = tuples if len(tuples) != 0 else [[None, None]]
-            self.points.set_offsets(tuples)
-            self.points.set_color(colors)
-            if len(xs) and config["energylevels_autoscale"]:
-                xmin, xmax = np.min(xs), np.max(xs)
-                if xmin == xmax:
-                    xmin -= 1
-                    xmax += 1
-                self.ax.set_xlim(
-                    [
-                        xmin - 0.02 * (xmax - xmin),
-                        xmax + 0.02 * (xmax - xmin),
-                    ]
-                )
-                ymin, ymax = np.min(ys), np.max(ys)
-                if ymin == ymax:
-                    ymin -= 1
-                    ymax += 1
-                y_range = [ymin, ymax]
-                self.ax.set_ylim(
-                    y_range[0] - config["plot_ymargin"] * (y_range[1] - y_range[0]),
-                    y_range[1] + config["plot_ymargin"] * (y_range[1] - y_range[0]),
-                )
+            with matplotlib_lock:
+                self.points.set_offsets(tuples)
+                self.points.set_color(colors)
+                if len(xs) and config["energylevels_autoscale"]:
+                    xmin, xmax = np.min(xs), np.max(xs)
+                    if xmin == xmax:
+                        xmin -= 1
+                        xmax += 1
+                    self.ax.set_xlim(
+                        [
+                            xmin - 0.02 * (xmax - xmin),
+                            xmax + 0.02 * (xmax - xmin),
+                        ]
+                    )
+                    ymin, ymax = np.min(ys), np.max(ys)
+                    if ymin == ymax:
+                        ymin -= 1
+                        ymax += 1
+                    y_range = [ymin, ymax]
+                    self.ax.set_ylim(
+                        y_range[0] - config["plot_ymargin"] * (y_range[1] - y_range[0]),
+                        y_range[1] + config["plot_ymargin"] * (y_range[1] - y_range[0]),
+                    )
         except Exception:
             notify_error.emit("There was an error in your Energy Levels window inputs")
             raise
@@ -9197,6 +9310,7 @@ class PeakfinderWindow(EQDockWidget):
                     [], [], color=config["peakfinder_peakcolor"], marker="*"
                 )
 
+            @lock_d(matplotlib_lock)
             def update_plot(self):
                 xmin, xmax = self.xrange
                 tuples = list(filter(lambda x: xmin < x[0] < xmax, self.parent.peaks))
@@ -9221,7 +9335,7 @@ class PeakfinderWindow(EQDockWidget):
         layout.addLayout(tmp_layout)
 
         self.run_button = QQ(
-            QPushButton, text="Run Peakfinder", change=lambda: self.find_peaks()
+            QPushButton, text="Run Peakfinder", change=lambda: self.on_run_clicked()
         )
         tmp_layout.addWidget(self.run_button)
         tmp_layout.addWidget(
@@ -9345,11 +9459,15 @@ class PeakfinderWindow(EQDockWidget):
         config["peakfinder_kwargs"] = kwargs
         return kwargs.copy()
 
+    def on_run_clicked(self):
+        self.run_button.setEnabled(False)
+        kwargs = self.get_kwargs()
+        self.find_peaks(kwargs)
+
     @QThread.threaded_d
     @peak_locked
-    def find_peaks(self, thread=None):
+    def find_peaks(self, kwargs, thread=None):
         self.peakfinding_started.emit()
-        kwargs = self.get_kwargs()
 
         if "frequency" in kwargs:
             val = kwargs["frequency"]
@@ -10164,9 +10282,9 @@ def bin_data(dataframe, binwidth, range):
     bin_array = ((dataframe["x"].to_numpy() - range[0]) // binwidth).astype(np.int64)
     value_column = "x" if "y" not in dataframe else "y"
 
-    index_ = dataframe.groupby(
-        [bin_array, dataframe["filename"]], observed=True
-    )[value_column].idxmax()
+    index_ = dataframe.groupby([bin_array, dataframe["filename"]], observed=True)[
+        value_column
+    ].idxmax()
     return dataframe.loc[index_.to_numpy()]
 
 
@@ -10575,7 +10693,11 @@ class ASAPAx(LWPAx):
             np.zeros(shape=(0, 2, 2)), colors=config["color_exp"], capstyle="round"
         )
         self.lin_coll = self.ax.scatter(
-            [], [], color=config["color_ref"], marker=config["plot_linmarker"], zorder=100
+            [],
+            [],
+            color=config["color_ref"],
+            marker=config["plot_linmarker"],
+            zorder=100,
         )
 
         with matplotlib_lock:
@@ -10617,6 +10739,7 @@ class ASAPAx(LWPAx):
         self.exp_coll.set(segments=segs, color=color)
 
     @drawplot_decorator.d
+    @lock_d(matplotlib_lock)
     def update(self):
         ax = self.ax
 
@@ -10786,12 +10909,13 @@ class ASAPAx(LWPAx):
             return
 
         # Delete artists highlighting previous fit
-        if self.__class__.fit_vline is not None:
-            self.__class__.fit_vline.remove()
-            self.__class__.fit_vline = None
-        if self.__class__.fit_curve is not None:
-            self.__class__.fit_curve.remove()
-            self.__class__.fit_curve = None
+        with matplotlib_lock:
+            if self.__class__.fit_vline is not None:
+                self.__class__.fit_vline.remove()
+                self.__class__.fit_vline = None
+            if self.__class__.fit_curve is not None:
+                self.__class__.fit_curve.remove()
+                self.__class__.fit_curve = None
 
         if onclick:
             xmiddle = xmin
@@ -10800,14 +10924,16 @@ class ASAPAx(LWPAx):
         else:
             # Fit the data
             xmiddle, xuncert, fit_xs, fit_ys = self.fit_peak(xmin, xmax)
-            self.__class__.fit_curve = self.ax.plot(
-                fit_xs, fit_ys, color=config["color_fit"], alpha=0.7, linewidth=1
-            )[0]
+            with matplotlib_lock:
+                self.__class__.fit_curve = self.ax.plot(
+                    fit_xs, fit_ys, color=config["color_fit"], alpha=0.7, linewidth=1
+                )[0]
 
         # Highlight fit in plot
-        self.__class__.fit_vline = self.ax.axvline(
-            x=xmiddle, color=config["color_fit"], ls="--", alpha=1, linewidth=1
-        )
+        with matplotlib_lock:
+            self.__class__.fit_vline = self.ax.axvline(
+                x=xmiddle, color=config["color_fit"], ls="--", alpha=1, linewidth=1
+            )
 
         # Emit signal for detail viewer
         self.x_fit = xmiddle
@@ -10904,8 +11030,8 @@ class ASAPAx(LWPAx):
             fit_xs, fit_ys = fit_results["fit_xs"], fit_results["fit_ys"]
 
         except Exception as E:
-            self.fitcurve = None
-            self.fitline = None
+            self.fit_curve = None
+            self.fit_line = None
             notify_error.emit(
                 f"The fitting failed with the following error message : {str(E)}"
             )
@@ -11259,12 +11385,13 @@ class ASAPWidget(LWPWidget):
     @status_d
     @drawplot_decorator.d
     def calc_correlation_plots(self, thread=None):
-        if self._ax_class.fit_vline is not None:
-            self._ax_class.fit_vline.remove()
-            self._ax_class.fit_vline = None
-        if self._ax_class.fit_curve is not None:
-            self._ax_class.fit_curve.remove()
-            self._ax_class.fit_curve = None
+        with matplotlib_lock:
+            if self._ax_class.fit_vline is not None:
+                self._ax_class.fit_vline.remove()
+                self._ax_class.fit_vline = None
+            if self._ax_class.fit_curve is not None:
+                self._ax_class.fit_curve.remove()
+                self._ax_class.fit_curve = None
 
         if not hasattr(ASAPSettingsWindow, "instance"):
             return
@@ -11294,7 +11421,7 @@ class ASAPWidget(LWPWidget):
 
             for i_col in range(n_widgets):
                 thread.earlyreturn()
-                if i_col > n_cols:
+                if i_col >= n_cols:
                     continue
 
                 refwidget = tab_widget.widget(i_col)
@@ -11803,10 +11930,22 @@ class ASAPSquaredWindow(EQDockWidget):
 
         tmp_layout = QHBoxLayout()
         tmp_layout.addWidget(QQ(QLabel, text="Width: "))
-        tmp_layout.addWidget(QQ(QDoubleSpinBoxFullPrec, "asap_squaredwidth", width=120))
+        tmp_layout.addWidget(
+            QQ(
+                QDoubleSpinBoxFullPrec,
+                "asap_squaredwidth",
+                width=120,
+                range=(None, None),
+            )
+        )
         tmp_layout.addWidget(QQ(QLabel, text="Stepsize: "))
         tmp_layout.addWidget(
-            QQ(QDoubleSpinBoxFullPrec, "asap_squaredstepsize", width=120)
+            QQ(
+                QDoubleSpinBoxFullPrec,
+                "asap_squaredstepsize",
+                width=120,
+                range=(None, None),
+            )
         )
         tmp_layout.addWidget(QQ(QLabel, text="Threshold: "))
         tmp_layout.addWidget(
@@ -11870,12 +12009,15 @@ class ASAPSquaredWindow(EQDockWidget):
         self.noq = config["series_qns"]
         assignments = []
 
-        for ax in self.fig.get_axes():
-            self.fig.delaxes(ax)
-        self.ax = self.fig.subplots()
-        self.span_selector = matplotlib.widgets.SpanSelector(
-            self.ax, self.on_range, "horizontal", useblit=True
-        )
+        with matplotlib_lock:
+            for ax in self.fig.get_axes():
+                self.fig.delaxes(ax)
+            self.fit_vline = None
+            self.fit_curve = None
+            self.ax = self.fig.subplots()
+            self.span_selector = matplotlib.widgets.SpanSelector(
+                self.ax, self.on_range, "horizontal", useblit=True
+            )
 
         width = config["asap_squaredwidth"] or config["plot_width"]
         stepsize = config["asap_squaredstepsize"] or config["asap_stepsize"]
@@ -11943,9 +12085,10 @@ class ASAPSquaredWindow(EQDockWidget):
                 tot_ys /= ys_max
                 log_y_max += np.log10(ys_max)
 
-        self.ax.plot(rel_xs, tot_ys, color=config["color_exp"])
-        if config["asap_squaredplotlog"]:
-            self.ax.set_yscale("log")
+        with matplotlib_lock:
+            self.ax.plot(rel_xs, tot_ys, color=config["color_exp"])
+            if config["asap_squaredplotlog"]:
+                self.ax.set_yscale("log")
 
         self.data = np.vstack((rel_xs, tot_ys)).T
         self.drawplot.emit()
@@ -12016,12 +12159,13 @@ class ASAPSquaredWindow(EQDockWidget):
     @status_d
     def fit_data(self, xmin, xmax, thread=None):
         # Delete artists highlighting previous fit
-        if self.fit_vline is not None:
-            self.fit_vline.remove()
-            self.fit_vline = None
-        if self.fit_curve is not None:
-            self.fit_curve.remove()
-            self.fit_curve = None
+        with matplotlib_lock:
+            if self.fit_vline is not None:
+                self.fit_vline.remove()
+                self.fit_vline = None
+            if self.fit_curve is not None:
+                self.fit_curve.remove()
+                self.fit_curve = None
 
         if self.data is None:
             notify_warning.emit("No cross-correlation data available.")
@@ -12054,8 +12198,8 @@ class ASAPSquaredWindow(EQDockWidget):
                     f"The following parameters were determined: \n{popt=}\n{perr=}"
                 )
         except Exception as E:
-            self.fitcurve = None
-            self.fitline = None
+            self.fit_curve = None
+            self.fit_vline = None
             notify_error.emit(
                 f"The fitting failed with the following error message : {str(E)}"
             )
@@ -12065,12 +12209,13 @@ class ASAPSquaredWindow(EQDockWidget):
             self.clipboard_requested.emit(str(xmiddle))
 
         # Highlight fit in plot
-        self.fit_curve = self.ax.plot(
-            fit_xs, fit_ys, color=config["color_fit"], alpha=0.7, linewidth=1
-        )[0]
-        self.fit_vline = self.ax.axvline(
-            x=xmiddle, color=config["color_fit"], ls="--", alpha=1, linewidth=1
-        )
+        with matplotlib_lock:
+            self.fit_curve = self.ax.plot(
+                fit_xs, fit_ys, color=config["color_fit"], alpha=0.7, linewidth=1
+            )[0]
+            self.fit_vline = self.ax.axvline(
+                x=xmiddle, color=config["color_fit"], ls="--", alpha=1, linewidth=1
+            )
         self.xmiddle = xmiddle
         self.xuncert = xuncert
 

{llwp-2.1.0 → llwp-2.1.2/llwp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llwp
-Version: 2.1.0
+Version: 2.1.2
 Summary: LLWP is a fast, efficient and easy solution for exploring and assigning spectra - relying on Loomis-Wood plots.
 Author-email: Luis Bonah <bonah@ph1.uni-koeln.de>
 License-Expression: GPL-3.0-only

{llwp-2.1.0 → llwp-2.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "llwp"
-version = "2.1.0"
+version = "2.1.2"
 authors = [
   { name="Luis Bonah", email="bonah@ph1.uni-koeln.de" },
 ]
@@ -30,3 +30,6 @@ dev = [
 [project.scripts]
 llwp = "llwp:start_llwp"
 asap = "llwp:start_asap"
+
+[tool.setuptools]
+include-package-data = true