robert 2.1.1__tar.gz → 2.1.2__tar.gz

{robert-2.1.1 → robert-2.1.2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: robert
-Version: 2.1.1
+Version: 2.1.2
 Summary: Refiner and Optimizer of a Bunch of Existing Regression Tools
 Home-page: https://github.com/jvalegre/robert
-Download-URL: https://github.com/jvalegre/robert/archive/refs/tags/2.1.1.tar.gz
+Download-URL: https://github.com/jvalegre/robert/archive/refs/tags/2.1.2.tar.gz
 Author: Juan V. Alegre Requena, David Dalmau
 Author-email: jv.alegre@csic.es
 License: MIT

{robert-2.1.1 → robert-2.1.2}/robert/api.py

@@ -514,6 +514,11 @@ class RobertModel(BaseEstimator):
             umode = "cv_sd"
         else:
             umode = False
+        if umode in ("conformal", "both") and self.problem_type != "reg":
+            raise ValueError(
+                "return_uncertainty='conformal' or 'both' is only supported "
+                "for problem_type='reg'."
+            )
 
         descriptors = list(self.model_data_["X_descriptors"])
         y_target = str(self.model_data_["y"])
@@ -559,6 +564,7 @@ class RobertModel(BaseEstimator):
         base["csv_test"] = pred_name
         base["params_dir"] = "GENERATE/Best_model"
         base["names"] = self.names_col_
+        base["_api_predict"] = True
 
         with _noninteractive_mpl(), _chdir(workdir):
             predict_module(**base)
@@ -608,11 +614,6 @@ class RobertModel(BaseEstimator):
                 raise RuntimeError(f"Column {sd_col!r} missing in {csv_path}")
             y_sd = ordered[sd_col].to_numpy(dtype=float)
         if umode in ("conformal", "both"):
-            if self.problem_type != "reg":
-                raise ValueError(
-                    "return_uncertainty='conformal' or 'both' is only supported "
-                    "for problem_type='reg'."
-                )
             if hw_col not in result_df.columns:
                 raise RuntimeError(f"Column {hw_col!r} missing in {csv_path}")
             y_hw = ordered[hw_col].to_numpy(dtype=float)
@@ -637,9 +638,10 @@ class RobertModel(BaseEstimator):
         y_hat = np.asarray(self.predict(X, return_std=False)).ravel()
         if self.problem_type == "reg":
             return float(r2_score(y_true, y_hat))
-        return float(
-            accuracy_score(
-                np.round(y_true).astype(int),
-                np.round(y_hat).astype(int),
-            )
-        )
+        try:
+            y_true_score = np.round(y_true).astype(int)
+            y_hat_score = np.round(y_hat).astype(int)
+        except (TypeError, ValueError):
+            y_true_score = y_true.astype(str)
+            y_hat_score = y_hat.astype(str)
+        return float(accuracy_score(y_true_score, y_hat_score))

{robert-2.1.1 → robert-2.1.2}/robert/aqme.py

@@ -127,7 +127,8 @@ class aqme:
                     aqme_indv_name = f'AQME_indiv_{smi_suffix}'
 
                 # run AQME-QDESCP to generate descriptors
-                cmd_qdescp = ['python','-u', '-m', 'aqme', '--qdescp', '--input', f'{aqme_indv_name}.csv', '--program', 'xtb', '--csv_name', f'{aqme_indv_name}.csv', '--nprocs', f'{self.args.nprocs}', '--robert']
+                python_executable = sys.executable or 'python'
+                cmd_qdescp = [python_executable,'-u', '-m', 'aqme', '--qdescp', '--input', f'{aqme_indv_name}.csv', '--program', 'xtb', '--csv_name', f'{aqme_indv_name}.csv', '--nprocs', f'{self.args.nprocs}', '--robert']
                 _ = self.run_aqme(cmd_qdescp, self.args.qdescp_keywords)
 
                 if smi_suffix is not None:
@@ -268,4 +269,4 @@ def move_aqme():
                     shutil.rmtree(f'AQME/{file}')
                 else:
                     os.remove(f'AQME/{file}')
-            shutil.move(file, f'AQME/{file}')
+            shutil.move(file, f'AQME/{file}')

{robert-2.1.1 → robert-2.1.2}/robert/argument_parser.py

@@ -61,7 +61,8 @@ var_dict = {
     "descp_lvl": "interpret",
     "report_modules" : ['AQME','CURATE','GENERATE','VERIFY','PREDICT'],
     "debug_report": False,
-    # Split conformal (regression): symmetric interval half-width.
+    # Internal API/BO uncertainty options. Normal ROBERT workflows leave them unused.
+    "_api_predict": False,
     "conformal_enable": True,
     "conformal_calib_frac": 0.15,
     "conformal_coverage": 0.9,

{robert-2.1.1 → robert-2.1.2}/robert/curate.py

@@ -61,6 +61,7 @@ Parameters
 
 import time
 import os
+import json
 import pandas as pd
 from robert.utils import (load_variables, finish_print, load_database, pearson_map,
                           check_clas_problem, categorical_transform, correlation_filter)
@@ -203,6 +204,8 @@ class curate:
         options_df['csv_name'] = [csv_curate_name_general]
         
         # Save class label mapping if it exists (for classification with string labels)
+        if hasattr(self.args, 'class_mapping_reverse'):
+            options_df['class_mapping_reverse'] = [json.dumps(self.args.class_mapping_reverse)]
         if hasattr(self.args, 'class_0_label'):
             options_df['class_0_label'] = [self.args.class_0_label]
             options_df['class_1_label'] = [self.args.class_1_label]

{robert-2.1.1 → robert-2.1.2}/robert/generate.py

@@ -124,8 +124,8 @@ class generate:
         # load database, discard user-defined descriptors and perform data checks
         csv_df, _, _ = load_database(self,self.args.csv_name,"generate")
 
-        # changes type to classification if there are only two different y values
-        if self.args.type.lower() == 'reg' and self.args.auto_type:
+        # adjust classification labels and auto-detect binary classification
+        if self.args.type.lower() == 'clas' or (self.args.type.lower() == 'reg' and self.args.auto_type):
             self = check_clas_problem(self,csv_df)
         
         # scan different ML models
@@ -171,7 +171,9 @@ class generate:
             
             # load database, discard user-defined descriptors and perform data checks
             csv_df, csv_X, csv_y = load_database(self,csv_to_load,"generate",print_info=False)
-            
+            if self.args.type.lower() == 'clas':
+                self = check_clas_problem(self,csv_df)
+                csv_y = csv_df[self.args.y]
 
             # standardizes and separates an external test set
             Xy_data = prepare_sets(self,csv_df,csv_X,csv_y,None,self.args.names,None,None,None,BO_opt=True)
@@ -183,6 +185,9 @@ class generate:
             if self.args.pfi_filter:
                 # load database, discard user-defined descriptors and perform data checks
                 csv_df, csv_X, csv_y = load_database(self,csv_to_load,"generate",print_info=False)
+                if self.args.type.lower() == 'clas':
+                    self = check_clas_problem(self,csv_df)
+                    csv_y = csv_df[self.args.y]
 
                 # standardizes and separates an external test set
                 Xy_data = prepare_sets(self,csv_df,csv_X,csv_y,None,self.args.names,None,None,None,BO_opt=True)

{robert-2.1.1 → robert-2.1.2}/robert/generate_utils.py

@@ -60,6 +60,8 @@ def BO_workflow(self, Xy_data, csv_df, ML_model):
         bo_data_to_save['X_descriptors'] = json.dumps(bo_data_to_save['X_descriptors'])
     
     # Save class label mapping if it exists (for classification with string labels)
+    if hasattr(self.args, 'class_mapping_reverse'):
+        bo_data_to_save['class_mapping_reverse'] = json.dumps(self.args.class_mapping_reverse)
     if hasattr(self.args, 'class_0_label'):
         bo_data_to_save['class_0_label'] = self.args.class_0_label
         bo_data_to_save['class_1_label'] = self.args.class_1_label
@@ -152,6 +154,8 @@ def save_pfi_csv(self,csv_df,name_csv_hyperopt,PFI_dict,Xy_data_PFI,ML_model):
     path_csv_PFI = self.args.destination.joinpath(f'{name_csv_hyperopt_PFI}_PFI')
     
     # Save class label mapping if it exists (for classification with string labels)
+    if hasattr(self.args, 'class_mapping_reverse'):
+        PFI_dict['class_mapping_reverse'] = json.dumps(self.args.class_mapping_reverse)
     if hasattr(self.args, 'class_0_label'):
         PFI_dict['class_0_label'] = self.args.class_0_label
         PFI_dict['class_1_label'] = self.args.class_1_label

{robert-2.1.1 → robert-2.1.2}/robert/gui_easyrob/easyrob_launcher.py

@@ -37,19 +37,52 @@ configure_environment()
 
 from PySide6.QtCore import Qt, QCoreApplication
 from PySide6.QtWidgets import QApplication
-from PySide6.QtGui import QPalette
+from PySide6.QtGui import QIcon, QPalette
+
+APP_NAME = "EasyRob"
+APP_DISPLAY_NAME = "EasyRob"
+APP_ORGANIZATION = "The Alegre Group"
+APP_DESKTOP_FILE_NAME = "easyrob"
+APP_USER_MODEL_ID = "com.thealegregroup.easyrob"
+
+
+def configure_process_identity():
+    """Configure process-level identity used by desktop shells."""
+    if sys.platform != "win32":
+        return
+
+    try:
+        import ctypes
+
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
+            APP_USER_MODEL_ID
+        )
+    except Exception:
+        pass
 
 def main():
     """Main entry point for the EasyROB application."""
+    configure_process_identity()
     QCoreApplication.setAttribute(Qt.ApplicationAttribute.AA_UseSoftwareOpenGL)
 
     app = QApplication(sys.argv)
+    app.setApplicationName(APP_NAME)
+    app.setApplicationDisplayName(APP_DISPLAY_NAME)
+    app.setOrganizationName(APP_ORGANIZATION)
+    app.setDesktopFileName(APP_DESKTOP_FILE_NAME)
 
     # Import AFTER QApplication to avoid lunching issues
     try:
         from easyrob import get_main_window_class
+        from utils.utils_gui import AssetLibrary
     except ImportError:
         from robert.gui_easyrob.easyrob import get_main_window_class
+        from robert.gui_easyrob.utils.utils_gui import AssetLibrary
+
+    with AssetLibrary.Robert_icon.get_path() as path_icon:
+        icon = QIcon(str(path_icon))
+        if not icon.isNull():
+            app.setWindowIcon(icon)
 
     EasyROB = get_main_window_class()
 
@@ -60,9 +93,11 @@ def main():
     app.setStyleSheet(f"QLabel {{ color: {text_color}; }}")
 
     window = EasyROB()
+    if not app.windowIcon().isNull():
+        window.setWindowIcon(app.windowIcon())
     window.show()
 
     sys.exit(app.exec())
 
 if __name__ == "__main__":
-    main()
+    main()

{robert-2.1.1 → robert-2.1.2}/robert/gui_easyrob/main/window.py

@@ -196,6 +196,21 @@ class EasyROB(QMainWindow):
 
         QApplication.quit()
 
+    def _resolve_python_executable(self):
+        """Return the Python interpreter that should be reused for child workflows."""
+        python_pointer = sys.executable or "python"
+
+        if getattr(sys, "frozen", False):
+            embedded_env = Path.cwd() / "_internal" / "robert_env"
+            if sys.platform == "win32":
+                python_pointer = embedded_env / "python.exe"
+            elif sys.platform == "darwin":
+                python_pointer = embedded_env / "bin" / "python3"
+            else:
+                python_pointer = embedded_env / "bin" / "python"
+
+        return str(python_pointer)
+
     def move_to_selected(self):
         """Move selected items from available_list to selected_list."""
         selected_items = self.available_list.selectedItems()
@@ -1461,16 +1476,20 @@ class EasyROB(QMainWindow):
         if not hasattr(self, "tab_widget_aqme"):
             return
 
-        if self.csv_test_path:
-            unified_smiles = self.tab_widget_aqme.build_unified_smiles_context(
-                self.file_path,
-                self.csv_test_path
-            )
-        else:
-            unified_smiles = self.tab_widget_aqme.build_unified_smiles_context(
-                self.file_path
-            )
-        
+        try:
+            if self.csv_test_path:
+                unified_smiles = self.tab_widget_aqme.build_unified_smiles_context(
+                    self.file_path,
+                    self.csv_test_path
+                )
+            else:
+                unified_smiles = self.tab_widget_aqme.build_unified_smiles_context(
+                    self.file_path
+                )
+        except ValueError:
+            # Missing SMILES is a valid non-AQME situation; keep the GUI quiet.
+            unified_smiles = []
+
         self.tab_widget_aqme.unified_smiles = unified_smiles
 
     def set_main_chemdraw_path(self, file_path):
@@ -1742,15 +1761,7 @@ class EasyROB(QMainWindow):
     def _build_test_aqme_command(self, original_command=None, qdescp_keywords=None):
         """Builds an AQME command for generating descriptors for the test CSV."""
 
-        python_pointer = "python"
-        if getattr(sys, "frozen", False):
-            env = Path.cwd() / "_internal" / "robert_env"
-            if sys.platform == "win32":
-                python_pointer = env / "python.exe"
-            elif sys.platform == "darwin":
-                python_pointer = env / "bin" / "python3"
-            else:
-                python_pointer = env / "bin" / "python"
+        python_pointer = self._resolve_python_executable()
 
         test_csv = os.path.basename(self.csv_test_path)
 
@@ -1854,8 +1865,9 @@ class EasyROB(QMainWindow):
         if not smarts or not selected_atoms:
             return
 
-        os.makedirs(run_dir, exist_ok=True)
-        dat_path = os.path.join(run_dir, filename)
+        dat_dir = self._get_atom_mapping_dir(run_dir)
+        os.makedirs(dat_dir, exist_ok=True)
+        dat_path = os.path.join(dat_dir, filename)
 
         try:
             pattern_mol = Chem.MolFromSmarts(smarts)
@@ -1915,6 +1927,58 @@ class EasyROB(QMainWindow):
             self.console_output.append(
                 f"<span style='color:orange;'>WARNING: Failed to write atom mapping dat: {e}</span>"
             )
+
+    def _write_atom_mapping_image(
+        self,
+        smarts: str,
+        selected_atoms: list,
+        run_dir: str,
+        filename: str = "AtomMapping_preview.png"
+    ):
+        """Write a numbered PNG preview for the current atom-mapping contract."""
+
+        if not smarts or not selected_atoms:
+            return None
+
+        image_dir = self._get_atom_mapping_dir(run_dir)
+        os.makedirs(image_dir, exist_ok=True)
+        image_path = os.path.join(image_dir, filename)
+
+        try:
+            saved_path = self.tab_widget_aqme.save_atom_mapping_image(
+                image_path,
+                smarts=smarts,
+                selected_atoms=selected_atoms,
+            )
+            return saved_path
+        except Exception as e:
+            self.console_output.append(
+                f"<span style='color:orange;'>WARNING: Failed to write atom mapping image: {e}</span>"
+            )
+            return None
+
+    def _get_atom_mapping_dir(self, run_dir: str) -> str:
+        """Return the dedicated folder used for atom-mapping artifacts."""
+
+        return os.path.join(run_dir, "AtomMapping")
+
+    def _resolve_atom_mapping_dat_path(
+        self,
+        run_dir: str,
+        filename: str = "AtomMapping_data.dat"
+    ) -> str | None:
+        """Resolve the atom-mapping contract path, preferring the dedicated folder."""
+
+        candidate_paths = [
+            os.path.join(self._get_atom_mapping_dir(run_dir), filename),
+            os.path.join(run_dir, filename),
+        ]
+
+        for path in candidate_paths:
+            if os.path.isfile(path):
+                return path
+
+        return None
     def _check_generate_folder(self, run_dir):
         """Checks if a GENERATE folder exists in the run directory."""
         
@@ -2137,6 +2201,11 @@ class EasyROB(QMainWindow):
                 selected_atoms=selected_atoms_for_robert,
                 run_dir=run_dir
             )
+            self._write_atom_mapping_image(
+                smarts=smarts,
+                selected_atoms=selected_atoms_for_robert,
+                run_dir=run_dir
+            )
 
         # --------------------------------------------------
         # Decide REAL input CSVs for ROBERT
@@ -2182,9 +2251,9 @@ class EasyROB(QMainWindow):
             # -----------------------------------------------
             # Step 1: Detect atomic mapping contract (.dat)
             # -----------------------------------------------
-            dat_path = os.path.join(run_dir, "AtomMapping_data.dat")
+            dat_path = self._resolve_atom_mapping_dat_path(run_dir)
 
-            if os.path.isfile(dat_path):
+            if dat_path:
 
                 self.console_output.append(
                     f"[INFO] Atomic mapping contract detected: {dat_path}"
@@ -2404,19 +2473,7 @@ class EasyROB(QMainWindow):
 
     def build_robert_command(self, selected_file_path):
         """Builds the ROBERT command based on GUI selections."""
-        python_pointer = "python"
-
-        # --------------------------------------------------
-        # Detect embedded Python (frozen app)
-        # --------------------------------------------------
-        if getattr(sys, "frozen", False):
-            embedded_env = Path.cwd() / "_internal" / "robert_env"
-            if sys.platform == "win32":
-                python_pointer = embedded_env / "python.exe"
-            elif sys.platform == "darwin":
-                python_pointer = embedded_env / "bin" / "python3"
-            else:
-                python_pointer = embedded_env / "bin" / "python"
+        python_pointer = self._resolve_python_executable()
 
         wf = self.workflow_selector.currentText()
 
@@ -2857,16 +2914,7 @@ class EasyROB(QMainWindow):
     def build_aqme_command(self, selected_file_path, selected_atoms_override=None):
         """Builds the AQME command based on the GUI selections."""
 
-        python_pointer = "python"
-
-        if getattr(sys, "frozen", False):
-            embeded_env = Path.cwd() / "_internal" / "robert_env"
-            if sys.platform == "win32":
-                python_pointer = embeded_env / "python.exe"
-            elif sys.platform == "darwin":
-                python_pointer = embeded_env / "bin" / "python3"
-            else:
-                python_pointer = embeded_env / "bin" / "python"
+        python_pointer = self._resolve_python_executable()
 
         csv_name = os.path.basename(selected_file_path)
 
@@ -3001,6 +3049,11 @@ class EasyROB(QMainWindow):
                 selected_atoms=selected_atoms_for_aqme,
                 run_dir=run_dir
             )
+            self._write_atom_mapping_image(
+                smarts=smarts,
+                selected_atoms=selected_atoms_for_aqme,
+                run_dir=run_dir
+            )
 
         # ------------------------------------------------
         # Decide REAL input CSVs for AQME

{robert-2.1.1 → robert-2.1.2}/robert/gui_easyrob/tabs/aqme.py

@@ -316,12 +316,14 @@ class AQMETab(QWidget):
 
     def _on_mcs_success(self, smarts):
         """Handle successful MCS detection."""
+        self.mcs_worker = None
         self.smarts_targets.append(smarts)
         self.mol_info_label.setText("🔬 Info here")
         self.display_molecule()
 
     def _on_mcs_error(self, message):
         """Handle MCS detection error."""
+        self.mcs_worker = None
         self.set_mol_viewer_message(
             message,
             tooltip="SMARTS pattern detection failed."
@@ -330,6 +332,7 @@ class AQMETab(QWidget):
 
     def _on_mcs_timeout(self):
         """Handle MCS detection timeout."""
+        self.mcs_worker = None
         self.set_mol_viewer_message(
             "⏱️ Timeout: MCS (Maximum Common Substructure) took too long and was aborted.",
             tooltip="SMARTS pattern detection failed."
@@ -463,6 +466,21 @@ class AQMETab(QWidget):
         # -------------------------------
         # Launch MCS worker
         # -------------------------------
+        existing_worker = getattr(self, "mcs_worker", None)
+        if existing_worker is not None:
+            try:
+                existing_worker.finished.disconnect(self._on_mcs_success)
+            except Exception:
+                pass
+            try:
+                existing_worker.error.disconnect(self._on_mcs_error)
+            except Exception:
+                pass
+            try:
+                existing_worker.timeout.disconnect(self._on_mcs_timeout)
+            except Exception:
+                pass
+
         self.mcs_worker = MCSProcessWorker(
             smiles_list,
             timeout_ms=60000
@@ -554,30 +572,16 @@ class AQMETab(QWidget):
             else:
                 highlight_atoms = set(self.selected_atoms)
 
-            highlight_colors = (
-                {idx: (0.698, 0.4, 1.0) for idx in highlight_atoms}
-                if highlight_atoms else {}
-            )
-
-            drawer = rdMolDraw2D.MolDraw2DCairo(
-                self.molecule_image_width,
-                self.molecule_image_height
-            )
-            drawer.drawOptions().bondLineWidth = 1.5
-            drawer.DrawMolecule(
+            png_bytes, atom_coords = self._draw_pattern_molecule(
                 self.mol,
-                highlightAtoms=list(highlight_atoms),
-                highlightAtomColors=highlight_colors
+                highlight_atoms=highlight_atoms,
+                selected_atoms=self.selected_atoms,
+                width=self.molecule_image_width,
+                height=self.molecule_image_height,
             )
-            drawer.FinishDrawing()
-
-            png_bytes = drawer.GetDrawingText()
             pixmap = QPixmap()
             pixmap.loadFromData(png_bytes)
-            self.atom_coords = [
-                drawer.GetDrawCoords(i)
-                for i in range(self.mol.GetNumAtoms())
-            ]
+            self.atom_coords = atom_coords
 
             if self.mol_viewer:
                 if pixmap.isNull():
@@ -618,6 +622,100 @@ class AQMETab(QWidget):
             )
             self.mol_info_label.setText("🔬 Info here")
 
+    def _prepare_pattern_molecule_for_drawing(self, pattern_mol, selected_atoms=None):
+        """Return a copy of the SMARTS pattern with visible atom-order labels."""
+
+        mol_for_draw = Chem.Mol(pattern_mol)
+        selected_atoms = list(selected_atoms or [])
+
+        for atom in mol_for_draw.GetAtoms():
+            if atom.HasProp("atomNote"):
+                atom.ClearProp("atomNote")
+
+        for order, atom_idx in enumerate(selected_atoms, start=1):
+            if 0 <= atom_idx < mol_for_draw.GetNumAtoms():
+                mol_for_draw.GetAtomWithIdx(atom_idx).SetProp(
+                    "atomNote",
+                    str(order)
+                )
+
+        return mol_for_draw
+
+    def _draw_pattern_molecule(
+        self,
+        pattern_mol,
+        highlight_atoms,
+        selected_atoms,
+        width,
+        height,
+    ):
+        """Draw the SMARTS pattern with highlight and click-order numbering."""
+
+        highlight_atoms = set(highlight_atoms or [])
+        highlight_colors = (
+            {idx: (0.698, 0.4, 1.0) for idx in highlight_atoms}
+            if highlight_atoms else {}
+        )
+
+        draw_mol = self._prepare_pattern_molecule_for_drawing(
+            pattern_mol,
+            selected_atoms=selected_atoms,
+        )
+
+        drawer = rdMolDraw2D.MolDraw2DCairo(
+            max(1, int(width)),
+            max(1, int(height))
+        )
+        options = drawer.drawOptions()
+        options.bondLineWidth = 1.5
+        options.annotationFontScale = 1.0
+        drawer.DrawMolecule(
+            draw_mol,
+            highlightAtoms=list(highlight_atoms),
+            highlightAtomColors=highlight_colors
+        )
+        drawer.FinishDrawing()
+
+        png_bytes = drawer.GetDrawingText()
+        atom_coords = [
+            drawer.GetDrawCoords(i)
+            for i in range(draw_mol.GetNumAtoms())
+        ]
+        return png_bytes, atom_coords
+
+    def save_atom_mapping_image(
+        self,
+        output_path,
+        smarts=None,
+        selected_atoms=None,
+        width=900,
+        height=700,
+    ):
+        """Save the numbered SMARTS render used for atom mapping as a PNG."""
+
+        smarts = smarts or (self.smarts_targets[0] if self.smarts_targets else None)
+        selected_atoms = list(self.selected_atoms if selected_atoms is None else selected_atoms)
+
+        if not smarts or not selected_atoms:
+            return None
+
+        pattern_mol = Chem.MolFromSmarts(smarts)
+        if pattern_mol is None:
+            raise ValueError("Invalid SMARTS pattern")
+
+        png_bytes, _ = self._draw_pattern_molecule(
+            pattern_mol,
+            highlight_atoms=set(selected_atoms),
+            selected_atoms=selected_atoms,
+            width=width,
+            height=height,
+        )
+
+        with open(output_path, "wb") as f:
+            f.write(png_bytes)
+
+        return output_path
+
     def handle_atom_selection(self, atom_idx):
         """Handle the selection of an atom in the pattern."""
 
@@ -1102,4 +1200,4 @@ class AQMETab(QWidget):
         save_button.clicked.connect(save_to_csv)
 
         dialog.setLayout(layout)
-        dialog.exec()
+        dialog.exec()