boris-behav-obs 9.4.1__py2.py3-none-any.whl → 9.5__py2.py3-none-any.whl

boris/plugins.py

@@ -47,12 +47,12 @@ def add_plugins_to_menu(self):
         self.menu_plugins.addAction(action)
 
 
-def get_plugin_name(plugin_path: str):
+def get_plugin_name(plugin_path: str) -> str | None:
     """
-    get name of plugin
+    get name of a Python plugin
     """
     # search plugin name
-    plugin_name = None
+    plugin_name: str | None = None
     with open(plugin_path, "r") as f_in:
         for line in f_in:
             if line.startswith("__plugin_name__"):
@@ -61,6 +61,48 @@ def get_plugin_name(plugin_path: str):
     return plugin_name
 
 
+def get_r_plugin_name(plugin_path: str) -> str | None:
+    """
+    get name of a R plugin
+    """
+    # search plugin name
+    plugin_name: str | None = None
+    with open(plugin_path, "r") as f_in:
+        for line in f_in:
+            if line.startswith("plugin_name"):
+                if "=" in line:
+                    plugin_name = line.split("=")[1].strip().replace('"', "").replace("'", "")
+                    break
+                elif "<-" in line:
+                    plugin_name = line.split("<-")[1].strip().replace('"', "").replace("'", "")
+                    break
+                else:
+                    plugin_name = None
+                    break
+    return plugin_name
+
+
+def get_r_plugin_description(plugin_path: str) -> str | None:
+    """
+    get description of a R plugin
+    """
+    # search plugin name
+    plugin_description: str | None = None
+    with open(plugin_path, "r") as f_in:
+        for line in f_in:
+            if line.startswith("description"):
+                if "=" in line:
+                    plugin_description = line.split("=")[1].strip().replace('"', "").replace("'", "")
+                    break
+                elif "<-" in line:
+                    plugin_description = line.split("<-")[1].strip().replace('"', "").replace("'", "")
+                    break
+                else:
+                    plugin_description = None
+                    break
+    return plugin_description
+
+
 def load_plugins(self):
     """
     load selected plugins in analysis menu
@@ -80,8 +122,6 @@ def load_plugins(self):
 
     # load BORIS plugins
     for file_ in sorted((Path(__file__).parent / "analysis_plugins").glob("*.py")):
-        if file_.name == "__init__.py":
-            continue
         if file_.name.startswith("_"):
             continue
         plugin_name = get_plugin_name(file_)
@@ -96,8 +136,6 @@ def load_plugins(self):
     # load personal plugins
     if self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, ""):
         for file_ in sorted(Path(self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, "")).glob("*.py")):
-            if file_.name == "__init__.py":
-                continue
             if file_.name.startswith("_"):
                 continue
             plugin_name = get_plugin_name(file_)
@@ -109,6 +147,20 @@ def load_plugins(self):
 
                 self.config_param[cfg.ANALYSIS_PLUGINS][plugin_name] = str(file_)
 
+    # load personal R plugins
+    if self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, ""):
+        for file_ in sorted(Path(self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, "")).glob("*.R")):
+            if file_.name.startswith("_"):
+                continue
+            plugin_name = get_r_plugin_name(file_)
+            if plugin_name is not None and plugin_name not in self.config_param.get(cfg.EXCLUDED_PLUGINS, set()):
+                # check if plugin with same name already loaded
+                if plugin_name in self.config_param[cfg.ANALYSIS_PLUGINS]:
+                    msg()
+                    continue
+
+                self.config_param[cfg.ANALYSIS_PLUGINS][plugin_name] = str(file_)
+
     logging.debug(f"{self.config_param.get(cfg.ANALYSIS_PLUGINS, {})=}")
 
 
@@ -203,7 +255,7 @@ def run_plugin(self, plugin_name):
         QMessageBox.critical(self, cfg.programName, f"Plugin '{plugin_name}' not found")
         return
 
-    plugin_path = self.config_param.get(cfg.ANALYSIS_PLUGINS, {})[plugin_name]
+    plugin_path: str = self.config_param.get(cfg.ANALYSIS_PLUGINS, {}).get(plugin_name, "")
 
     logging.debug(f"{plugin_path=}")
 
@@ -213,24 +265,12 @@ def run_plugin(self, plugin_name):
 
     logging.debug(f"run plugin from {plugin_path}")
 
-    module_name = Path(plugin_path).stem
-
-    spec = importlib.util.spec_from_file_location(module_name, plugin_path)
-    plugin_module = importlib.util.module_from_spec(spec)
-
-    logging.debug(f"{plugin_module=}")
-
-    spec.loader.exec_module(plugin_module)
-
-    logging.info(
-        f"{plugin_module.__plugin_name__} loaded v.{getattr(plugin_module, '__version__')} v. {getattr(plugin_module, '__version_date__')}"
-    )
-
+    # select observations to analyze
     selected_observations, parameters = self.obs_param()
     if not selected_observations:
         return
 
-    logging.info("preparing dtaaframe for plugin")
+    logging.info("preparing dataframe for plugin")
 
     df = project_functions.project2dataframe(self.pj, selected_observations)
 
@@ -247,8 +287,79 @@ def run_plugin(self, plugin_name):
     filtered_df = plugin_df_filter(df, observations_list=selected_observations, parameters=parameters)
     logging.info("done")
 
-    plugin_results = plugin_module.run(filtered_df)
-    # test if plugin_tests is a tuple: if not transform to tuple
+    if Path(plugin_path).suffix == ".py":
+        # load plugin as module
+        module_name = Path(plugin_path).stem
+
+        spec = importlib.util.spec_from_file_location(module_name, plugin_path)
+        plugin_module = importlib.util.module_from_spec(spec)
+
+        logging.debug(f"{plugin_module=}")
+
+        spec.loader.exec_module(plugin_module)
+
+        plugin_version = plugin_module.__version__
+        plugin_version_date = plugin_module.__version_date__
+
+        logging.info(
+            f"{plugin_module.__plugin_name__} loaded v.{getattr(plugin_module, '__version__')} v. {getattr(plugin_module, '__version_date__')}"
+        )
+
+        # run plugin
+        plugin_results = plugin_module.run(filtered_df)
+
+    if Path(plugin_path).suffix in (".R", ".r"):
+        try:
+            from rpy2 import robjects
+            from rpy2.robjects import pandas2ri
+            from rpy2.robjects.packages import SignatureTranslatedAnonymousPackage
+            from rpy2.robjects.conversion import localconverter
+        except Exception:
+            QMessageBox.critical(self, cfg.programName, "The rpy2 Python module is not installed. R plugins cannot be used")
+            return
+
+        # Read code from file
+        try:
+            with open(plugin_path, "r") as f:
+                r_code = f.read()
+        except Exception:
+            QMessageBox.critical(self, cfg.programName, f"Error reading the plugin {plugin_path}.")
+            return
+
+        # read version
+        plugin_version = next(
+            (
+                x.split("<-")[1].replace('"', "").replace("'", "").strip()
+                for x in r_code.splitlines()
+                if x.replace(" ", "").startswith("version<-")
+            ),
+            None,
+        )
+        # read version date
+        plugin_version_date = next(
+            (
+                x.split("<-")[1].replace('"', "").replace("'", "").strip()
+                for x in r_code.split("\n")
+                if x.replace(" ", "").startswith("version_date<")
+            ),
+            None,
+        )
+
+        r_plugin = SignatureTranslatedAnonymousPackage(r_code, "r_plugin")
+
+        with localconverter(robjects.default_converter + pandas2ri.converter):
+            r_df = robjects.conversion.py2rpy(filtered_df)
+
+        try:
+            r_result = r_plugin.run(r_df)
+        except Exception as e:
+            QMessageBox.critical(self, cfg.programName, f"Error in the plugin {plugin_path}: {e}.")
+            return
+
+        with localconverter(robjects.default_converter + pandas2ri.converter):
+            plugin_results = robjects.conversion.rpy2py(r_result)
+
+    # test if plugin_results is a tuple: if not transform it to tuple
     if not isinstance(plugin_results, tuple):
         plugin_results = tuple([plugin_results])
 
@@ -261,7 +372,7 @@ def run_plugin(self, plugin_name):
             self.plugin_visu[-1].ptText.appendPlainText(result)
             self.plugin_visu[-1].show()
         elif isinstance(result, pd.DataFrame):
-            self.plugin_visu.append(view_df.View_df(plugin_name, f"{plugin_module.__version__} ({plugin_module.__version_date__})", result))
+            self.plugin_visu.append(view_df.View_df(plugin_name, f"{plugin_version} ({plugin_version_date})", result))
             self.plugin_visu[-1].show()
         else:
             # result is not str nor dataframe

boris/preferences.py

@@ -35,6 +35,7 @@ from .preferences_ui import Ui_prefDialog
 
 from PySide6.QtWidgets import QDialog, QFileDialog, QListWidgetItem, QMessageBox
 from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont
 
 
 class Preferences(QDialog, Ui_prefDialog):
@@ -43,8 +44,6 @@ class Preferences(QDialog, Ui_prefDialog):
         self.setupUi(self)
 
         # plugins
-        """self.pb_add_plugin.clicked.connect(self.add_plugin)
-        self.pb_remove_plugin.clicked.connect(self.remove_plugin)"""
         self.pb_browse_plugins_dir.clicked.connect(self.browse_plugins_dir)
 
         self.pbBrowseFFmpegCacheDir.clicked.connect(self.browseFFmpegCacheDir)
@@ -58,6 +57,12 @@ class Preferences(QDialog, Ui_prefDialog):
 
         self.flag_refresh = False
 
+        # Create a monospace QFont
+        monospace_font = QFont("Courier New")  # or "Monospace", "Consolas", "Liberation Mono", etc.
+        monospace_font.setStyleHint(QFont.Monospace)
+        monospace_font.setPointSize(13)
+        self.pte_plugin_code.setFont(monospace_font)
+
     def browse_plugins_dir(self):
         """
         get the personal plugins directory
@@ -69,14 +74,21 @@ class Preferences(QDialog, Ui_prefDialog):
         self.le_personal_plugins_dir.setText(directory)
         self.lw_personal_plugins.clear()
         for file_ in Path(directory).glob("*.py"):
-            item = QListWidgetItem(file_.stem)
+            if file_.name.startswith("_"):
+                continue
+            plugin_name = plugins.get_plugin_name(file_)
+            if plugin_name is None:
+                continue
+            # check if personal plugin name is in BORIS plugins (case sensitive)
+            if plugin_name in [self.lv_all_plugins.item(i).text() for i in range(self.lv_all_plugins.count())]:
+                continue
+            item = QListWidgetItem(plugin_name)
+            # item = QListWidgetItem(file_.stem)
             item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
-            # if plugin_name in self.config_param.get(cfg.EXCLUDED_PLUGINS, set()):
-            #    item.setCheckState(Qt.Unchecked)
-            # else:
             item.setCheckState(Qt.Checked)
-            item.setData(100, file_.stem)
+            item.setData(100, str(file_))
             self.lw_personal_plugins.addItem(item)
+
         if self.lw_personal_plugins.count() == 0:
             QMessageBox.warning(self, cfg.programName, f"No plugin found in {directory}")
 
@@ -87,7 +99,7 @@ class Preferences(QDialog, Ui_prefDialog):
         if (
             dialog.MessageDialog(
                 "BORIS",
-                ("Refresh will re-initialize " "all your preferences and close BORIS"),
+                ("Refresh will re-initialize all your preferences and close BORIS"),
                 [cfg.CANCEL, "Refresh preferences"],
             )
             == "Refresh preferences"
@@ -138,21 +150,39 @@ def preferences(self):
         if item.text() not in self.config_param[cfg.ANALYSIS_PLUGINS]:
             return
 
-        import importlib
-
         plugin_path = item.data(100)
 
-        module_name = Path(plugin_path).stem
-        spec = importlib.util.spec_from_file_location(module_name, plugin_path)
-        plugin_module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(plugin_module)
-        out: list = []
-        out.append(plugin_module.__plugin_name__ + "\n")
-        out.append(plugin_module.__author__)
-        out.append(f"{plugin_module.__version__} ({plugin_module.__version_date__})\n")
-        out.append(plugin_module.run.__doc__.strip())
+        if Path(plugin_path).suffix == ".py":
+            import importlib
+
+            module_name = Path(plugin_path).stem
+            spec = importlib.util.spec_from_file_location(module_name, plugin_path)
+            plugin_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(plugin_module)
+
+            out: list = []
+            out.append(plugin_module.__plugin_name__ + "\n")
+            out.append(plugin_module.__author__)
+            out.append(f"{plugin_module.__version__} ({plugin_module.__version_date__})\n")
+            out.append(plugin_module.run.__doc__.strip())
 
-        preferencesWindow.pte_plugin_description.setPlainText("\n".join(out))
+            preferencesWindow.pte_plugin_description.setPlainText("\n".join(out))
+
+        if Path(plugin_path).suffix == ".R":
+            plugin_description = plugins.get_r_plugin_description(plugin_path)
+            if plugin_description is not None:
+                preferencesWindow.pte_plugin_description.setPlainText("\n".join(plugin_description.split("\\n")))
+            else:
+                preferencesWindow.pte_plugin_description.setPlainText("Plugin description not found")
+
+        # display plugin code
+        try:
+            with open(plugin_path, "r") as f_in:
+                plugin_code = f_in.read()
+        except Exception:
+            plugin_code = "Not available"
+
+        preferencesWindow.pte_plugin_code.setPlainText(plugin_code)
 
     preferencesWindow = Preferences()
     preferencesWindow.tabWidget.setCurrentIndex(0)
@@ -205,7 +235,7 @@ def preferences(self):
     preferencesWindow.lv_all_plugins.clear()
 
     for file_ in (Path(__file__).parent / "analysis_plugins").glob("*.py"):
-        if file_.name == "__init__.py":
+        if file_.name.startswith("_"):
             continue
         plugin_name = plugins.get_plugin_name(file_)
         if plugin_name is not None:
@@ -225,7 +255,7 @@ def preferences(self):
     preferencesWindow.lw_personal_plugins.clear()
     if self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, ""):
         for file_ in Path(self.config_param[cfg.PERSONAL_PLUGINS_DIR]).glob("*.py"):
-            if file_.name == "__init__.py":
+            if file_.name.startswith("_"):
                 continue
             plugin_name = plugins.get_plugin_name(file_)
             if plugin_name is None:
@@ -242,6 +272,22 @@ def preferences(self):
             item.setData(100, str(file_))
             preferencesWindow.lw_personal_plugins.addItem(item)
 
+        for file_ in Path(self.config_param[cfg.PERSONAL_PLUGINS_DIR]).glob("*.R"):
+            plugin_name = plugins.get_r_plugin_name(file_)
+            if plugin_name is None:
+                continue
+            # check if personal plugin name is in BORIS plugins (case sensitive)
+            if plugin_name in [preferencesWindow.lv_all_plugins.item(i).text() for i in range(preferencesWindow.lv_all_plugins.count())]:
+                continue
+            item = QListWidgetItem(plugin_name)
+            item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
+            if plugin_name in self.config_param.get(cfg.EXCLUDED_PLUGINS, set()):
+                item.setCheckState(Qt.Unchecked)
+            else:
+                item.setCheckState(Qt.Checked)
+            item.setData(100, str(file_))
+            preferencesWindow.lw_personal_plugins.addItem(item)
+
     # PROJET FILE INDENTATION
     preferencesWindow.combo_project_file_indentation.clear()
     preferencesWindow.combo_project_file_indentation.addItems(cfg.PROJECT_FILE_INDENTATION_COMBO_OPTIONS)
@@ -272,16 +318,21 @@ def preferences(self):
         preferencesWindow.cbSpectrogramColorMap.setCurrentIndex(cfg.SPECTROGRAM_COLOR_MAPS.index(self.spectrogram_color_map))
     except Exception:
         preferencesWindow.cbSpectrogramColorMap.setCurrentIndex(cfg.SPECTROGRAM_COLOR_MAPS.index(cfg.SPECTROGRAM_DEFAULT_COLOR_MAP))
-
-    try:
-        preferencesWindow.cbSpectrogramColorMap.setCurrentIndex(cfg.SPECTROGRAM_COLOR_MAPS.index(self.spectrogram_color_map))
-    except Exception:
-        preferencesWindow.cbSpectrogramColorMap.setCurrentIndex(cfg.SPECTROGRAM_COLOR_MAPS.index(cfg.SPECTROGRAM_DEFAULT_COLOR_MAP))
-
+    # time interval
     try:
         preferencesWindow.sb_time_interval.setValue(self.spectrogram_time_interval)
     except Exception:
         preferencesWindow.sb_time_interval.setValue(cfg.SPECTROGRAM_DEFAULT_TIME_INTERVAL)
+    # window type
+    preferencesWindow.cb_window_type.setCurrentText(self.config_param.get(cfg.SPECTROGRAM_WINDOW_TYPE, cfg.SPECTROGRAM_DEFAULT_WINDOW_TYPE))
+    # NFFT
+    preferencesWindow.cb_NFFT.setCurrentText(self.config_param.get(cfg.SPECTROGRAM_NFFT, cfg.SPECTROGRAM_DEFAULT_NFFT))
+    # noverlap
+    preferencesWindow.sb_noverlap.setValue(self.config_param.get(cfg.SPECTROGRAM_NOVERLAP, cfg.SPECTROGRAM_DEFAULT_NOVERLAP))
+    # vmin
+    preferencesWindow.sb_vmin.setValue(self.config_param.get(cfg.SPECTROGRAM_VMIN, cfg.SPECTROGRAM_DEFAULT_VMIN))
+    # vmax
+    preferencesWindow.sb_vmax.setValue(self.config_param.get(cfg.SPECTROGRAM_VMAX, cfg.SPECTROGRAM_DEFAULT_VMAX))
 
     # behavior colors
     if not self.plot_colors:
@@ -298,114 +349,137 @@ def preferences(self):
 
     gui_utilities.restore_geometry(preferencesWindow, "preferences", (700, 500))
 
-    if preferencesWindow.exec_():
-        gui_utilities.save_geometry(preferencesWindow, "preferences")
+    while True:
+        if preferencesWindow.exec():
+            if preferencesWindow.sb_vmin.value() >= preferencesWindow.sb_vmax.value():
+                QMessageBox.warning(self, cfg.programName, "Spectrogram parameters: the vmin value must be lower than the vmax value.")
+                continue
+
+            if preferencesWindow.sb_noverlap.value() >= int(preferencesWindow.cb_NFFT.currentText()):
+                QMessageBox.warning(self, cfg.programName, "Spectrogram parameters: the noverlap value must be lower than the NFFT value.")
+                continue
 
-        if preferencesWindow.flag_refresh:
-            # refresh preferences remove the config file
+            gui_utilities.save_geometry(preferencesWindow, "preferences")
 
-            logging.debug("flag refresh ")
+            if preferencesWindow.flag_refresh:
+                # refresh preferences remove the config file
 
-            self.config_param["refresh_preferences"] = True
-            self.close()
-            # check if refresh canceled for not saved project
-            if "refresh_preferences" in self.config_param:
-                if (Path.home() / ".boris").exists():
-                    os.remove(Path.home() / ".boris")
-                sys.exit()
+                logging.debug("flag refresh ")
 
-        if preferencesWindow.cbTimeFormat.currentIndex() == 0:
-            self.timeFormat = cfg.S
+                self.config_param["refresh_preferences"] = True
+                self.close()
+                # check if refresh canceled for not saved project
+                if "refresh_preferences" in self.config_param:
+                    if (Path.home() / ".boris").exists():
+                        os.remove(Path.home() / ".boris")
+                    sys.exit()
 
-        if preferencesWindow.cbTimeFormat.currentIndex() == 1:
-            self.timeFormat = cfg.HHMMSS
+            if preferencesWindow.cbTimeFormat.currentIndex() == 0:
+                self.timeFormat = cfg.S
 
-        self.fast = preferencesWindow.sbffSpeed.value()
+            if preferencesWindow.cbTimeFormat.currentIndex() == 1:
+                self.timeFormat = cfg.HHMMSS
 
-        self.config_param[cfg.ADAPT_FAST_JUMP] = preferencesWindow.cb_adapt_fast_jump.isChecked()
+            self.fast = preferencesWindow.sbffSpeed.value()
 
-        self.repositioningTimeOffset = preferencesWindow.sbRepositionTimeOffset.value()
+            self.config_param[cfg.ADAPT_FAST_JUMP] = preferencesWindow.cb_adapt_fast_jump.isChecked()
 
-        self.play_rate_step = preferencesWindow.sbSpeedStep.value()
+            self.repositioningTimeOffset = preferencesWindow.sbRepositionTimeOffset.value()
 
-        self.automaticBackup = preferencesWindow.sbAutomaticBackup.value()
-        if self.automaticBackup:
-            self.automaticBackupTimer.start(self.automaticBackup * 60000)
-        else:
-            self.automaticBackupTimer.stop()
+            self.play_rate_step = preferencesWindow.sbSpeedStep.value()
 
-        self.behav_seq_separator = preferencesWindow.leSeparator.text()
+            self.automaticBackup = preferencesWindow.sbAutomaticBackup.value()
+            if self.automaticBackup:
+                self.automaticBackupTimer.start(self.automaticBackup * 60000)
+            else:
+                self.automaticBackupTimer.stop()
 
-        self.close_the_same_current_event = preferencesWindow.cbCloseSameEvent.isChecked()
+            self.behav_seq_separator = preferencesWindow.leSeparator.text()
 
-        self.confirmSound = preferencesWindow.cbConfirmSound.isChecked()
+            self.close_the_same_current_event = preferencesWindow.cbCloseSameEvent.isChecked()
 
-        self.beep_every = preferencesWindow.sbBeepEvery.value()
+            self.confirmSound = preferencesWindow.cbConfirmSound.isChecked()
 
-        self.alertNoFocalSubject = preferencesWindow.cbAlertNoFocalSubject.isChecked()
+            self.beep_every = preferencesWindow.sbBeepEvery.value()
 
-        self.trackingCursorAboveEvent = preferencesWindow.cbTrackingCursorAboveEvent.isChecked()
+            self.alertNoFocalSubject = preferencesWindow.cbAlertNoFocalSubject.isChecked()
 
-        self.checkForNewVersion = preferencesWindow.cbCheckForNewVersion.isChecked()
+            self.trackingCursorAboveEvent = preferencesWindow.cbTrackingCursorAboveEvent.isChecked()
 
-        self.config_param[cfg.DISPLAY_SUBTITLES] = preferencesWindow.cb_display_subtitles.isChecked()
+            self.checkForNewVersion = preferencesWindow.cbCheckForNewVersion.isChecked()
 
-        self.pause_before_addevent = preferencesWindow.cb_pause_before_addevent.isChecked()
+            self.config_param[cfg.DISPLAY_SUBTITLES] = preferencesWindow.cb_display_subtitles.isChecked()
 
-        # MPV hwdec
-        self.config_param[cfg.MPV_HWDEC] = cfg.MPV_HWDEC_OPTIONS[preferencesWindow.cb_hwdec.currentIndex()]
+            self.pause_before_addevent = preferencesWindow.cb_pause_before_addevent.isChecked()
 
-        # check project integrity
-        self.config_param[cfg.CHECK_PROJECT_INTEGRITY] = preferencesWindow.cb_check_integrity_at_opening.isChecked()
+            # MPV hwdec
+            self.config_param[cfg.MPV_HWDEC] = cfg.MPV_HWDEC_OPTIONS[preferencesWindow.cb_hwdec.currentIndex()]
 
-        # update BORIS analysis plugins
-        self.config_param[cfg.ANALYSIS_PLUGINS] = {}
-        self.config_param[cfg.EXCLUDED_PLUGINS] = set()
-        for i in range(preferencesWindow.lv_all_plugins.count()):
-            if preferencesWindow.lv_all_plugins.item(i).checkState() == Qt.Checked:
-                self.config_param[cfg.ANALYSIS_PLUGINS][preferencesWindow.lv_all_plugins.item(i).text()] = (
-                    preferencesWindow.lv_all_plugins.item(i).data(100)
-                )
-            else:
-                self.config_param[cfg.EXCLUDED_PLUGINS].add(preferencesWindow.lv_all_plugins.item(i).text())
-
-        # update personal plugins
-        self.config_param[cfg.PERSONAL_PLUGINS_DIR] = preferencesWindow.le_personal_plugins_dir.text()
-        for i in range(preferencesWindow.lw_personal_plugins.count()):
-            if preferencesWindow.lw_personal_plugins.item(i).checkState() == Qt.Checked:
-                self.config_param[cfg.ANALYSIS_PLUGINS][preferencesWindow.lw_personal_plugins.item(i).text()] = (
-                    preferencesWindow.lw_personal_plugins.item(i).data(100)
-                )
-            else:
-                self.config_param[cfg.EXCLUDED_PLUGINS].add(preferencesWindow.lw_personal_plugins.item(i).text())
+            # check project integrity
+            self.config_param[cfg.CHECK_PROJECT_INTEGRITY] = preferencesWindow.cb_check_integrity_at_opening.isChecked()
 
-        plugins.load_plugins(self)
-        plugins.add_plugins_to_menu(self)
+            # update BORIS analysis plugins
+            self.config_param[cfg.ANALYSIS_PLUGINS] = {}
+            self.config_param[cfg.EXCLUDED_PLUGINS] = set()
+            for i in range(preferencesWindow.lv_all_plugins.count()):
+                if preferencesWindow.lv_all_plugins.item(i).checkState() == Qt.Checked:
+                    self.config_param[cfg.ANALYSIS_PLUGINS][preferencesWindow.lv_all_plugins.item(i).text()] = (
+                        preferencesWindow.lv_all_plugins.item(i).data(100)
+                    )
+                else:
+                    self.config_param[cfg.EXCLUDED_PLUGINS].add(preferencesWindow.lv_all_plugins.item(i).text())
 
-        # project file indentation
-        self.config_param[cfg.PROJECT_FILE_INDENTATION] = cfg.PROJECT_FILE_INDENTATION_OPTIONS[
-            preferencesWindow.combo_project_file_indentation.currentIndex()
-        ]
+            # update personal plugins
+            self.config_param[cfg.PERSONAL_PLUGINS_DIR] = preferencesWindow.le_personal_plugins_dir.text()
+            for i in range(preferencesWindow.lw_personal_plugins.count()):
+                if preferencesWindow.lw_personal_plugins.item(i).checkState() == Qt.Checked:
+                    self.config_param[cfg.ANALYSIS_PLUGINS][preferencesWindow.lw_personal_plugins.item(i).text()] = (
+                        preferencesWindow.lw_personal_plugins.item(i).data(100)
+                    )
+                else:
+                    self.config_param[cfg.EXCLUDED_PLUGINS].add(preferencesWindow.lw_personal_plugins.item(i).text())
 
-        if self.observationId:
-            self.load_tw_events(self.observationId)
-            self.display_statusbar_info(self.observationId)
+            plugins.load_plugins(self)
+            plugins.add_plugins_to_menu(self)
 
-        self.ffmpeg_cache_dir = preferencesWindow.leFFmpegCacheDir.text()
+            # project file indentation
+            self.config_param[cfg.PROJECT_FILE_INDENTATION] = cfg.PROJECT_FILE_INDENTATION_OPTIONS[
+                preferencesWindow.combo_project_file_indentation.currentIndex()
+            ]
+
+            if self.observationId:
+                self.load_tw_events(self.observationId)
+                self.display_statusbar_info(self.observationId)
+
+            self.ffmpeg_cache_dir = preferencesWindow.leFFmpegCacheDir.text()
 
-        # spectrogram
-        self.spectrogram_color_map = preferencesWindow.cbSpectrogramColorMap.currentText()
-        # self.spectrogramHeight = preferencesWindow.sbSpectrogramHeight.value()
-        self.spectrogram_time_interval = preferencesWindow.sb_time_interval.value()
+            # spectrogram
+            self.spectrogram_color_map = preferencesWindow.cbSpectrogramColorMap.currentText()
+            self.spectrogram_time_interval = preferencesWindow.sb_time_interval.value()
+            # window type
+            self.config_param[cfg.SPECTROGRAM_WINDOW_TYPE] = preferencesWindow.cb_window_type.currentText()
+            # NFFT
+            self.config_param[cfg.SPECTROGRAM_NFFT] = preferencesWindow.cb_NFFT.currentText()
+            # noverlap
+            self.config_param[cfg.SPECTROGRAM_NOVERLAP] = preferencesWindow.sb_noverlap.value()
+            # vmin
+            self.config_param[cfg.SPECTROGRAM_VMIN] = preferencesWindow.sb_vmin.value()
+            # vmax
+            self.config_param[cfg.SPECTROGRAM_VMAX] = preferencesWindow.sb_vmax.value()
 
-        # behav colors
-        self.plot_colors = preferencesWindow.te_behav_colors.toPlainText().split()
-        # category colors
-        self.behav_category_colors = preferencesWindow.te_category_colors.toPlainText().split()
+            # behav colors
+            self.plot_colors = preferencesWindow.te_behav_colors.toPlainText().split()
+            # category colors
+            self.behav_category_colors = preferencesWindow.te_category_colors.toPlainText().split()
 
-        # interface
-        self.config_param[cfg.TOOLBAR_ICON_SIZE] = preferencesWindow.sb_toolbar_icon_size.value()
+            # interface
+            self.config_param[cfg.TOOLBAR_ICON_SIZE] = preferencesWindow.sb_toolbar_icon_size.value()
 
-        menu_options.update_menu(self)
+            menu_options.update_menu(self)
 
-        config_file.save(self)
+            config_file.save(self)
+
+            break
+
+        else:
+            break