boris-behav-obs 9.7.1__py3-none-any.whl → 9.7.12__py3-none-any.whl

boris/observation_operations.py

@@ -26,7 +26,7 @@ from decimal import Decimal as dec
 import json
 from math import log2, floor
 import os
-import pathlib as pl
+from pathlib import Path
 import socket
 import subprocess
 import sys
@@ -89,10 +89,10 @@ def export_observations_list_clicked(self):
         return
 
     output_format = cfg.FILE_NAME_SUFFIX[filter_]
-    if pl.Path(file_name).suffix != "." + output_format:
-        file_name = str(pl.Path(file_name)) + "." + output_format
+    if Path(file_name).suffix != "." + output_format:
+        file_name = str(Path(file_name)) + "." + output_format
         # check if file name with extension already exists
-        if pl.Path(file_name).is_file():
+        if Path(file_name).is_file():
             if dialog.MessageDialog(cfg.programName, f"The file {file_name} already exists.", [cfg.CANCEL, cfg.OVERWRITE]) == cfg.CANCEL:
                 return
 
@@ -113,6 +113,8 @@ def observations_list(self):
     result, selected_obs = select_observations.select_observations2(self, cfg.SINGLE)
 
     if not selected_obs:
+        # activate main window
+        self.activateWindow()
         return
 
     if self.observationId:
@@ -122,6 +124,9 @@ def observations_list(self):
         )
         if response == cfg.NO:
             self.show_data_files()
+            # activate main window
+            self.activateWindow()
+
             return ""
         else:
             close_observation(self)
@@ -145,6 +150,8 @@ def observations_list(self):
             )
 
     logging.debug("end observations list")
+    # activate main window
+    self.activateWindow()
 
 
 def open_observation(self, mode: str) -> str:
@@ -594,7 +601,7 @@ def new_observation(self, mode: str = cfg.NEW, obsId: str = "") -> None:
             close_observation(self)
 
     observationWindow = observation.Observation(
-        tmp_dir=self.ffmpeg_cache_dir if (self.ffmpeg_cache_dir and pl.Path(self.ffmpeg_cache_dir).is_dir()) else tempfile.gettempdir(),
+        tmp_dir=self.ffmpeg_cache_dir if (self.ffmpeg_cache_dir and Path(self.ffmpeg_cache_dir).is_dir()) else tempfile.gettempdir(),
         project_path=self.projectFileName,
         converters=self.pj.get(cfg.CONVERTERS, {}),
         time_format=self.timeFormat,
@@ -1151,6 +1158,9 @@ def close_observation(self):
         logging.info("Stop plot timer")
         self.plot_timer.stop()
 
+        if self.MPV_IPC_MODE:
+            self.main_window_activation_timer.stop()
+
         for i, player in enumerate(self.dw_player):
             if (
                 str(i + 1) in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE]
@@ -1304,7 +1314,7 @@ def check_creation_date(self) -> Tuple[int, dict]:
 
         if ret == 1:  #  use file creation time
             for media in not_tagged_media_list:
-                media_creation_time[media] = pl.Path(media).stat().st_ctime
+                media_creation_time[media] = Path(media).stat().st_ctime
             return (0, media_creation_time)  # OK use media file creation date/time
         else:
             return (1, {})
@@ -1340,8 +1350,6 @@ def initialize_new_media_observation(self) -> bool:
         self.playerType = cfg.VIEWER_MEDIA
         return True
 
-        # print(f"{self.process=}")
-
     self.playerType = cfg.MEDIA
     self.fps = 0
 
@@ -1365,7 +1373,7 @@ def initialize_new_media_observation(self) -> bool:
 
     # add all media files to media lists
     self.setDockOptions(QMainWindow.AnimatedDocks | QMainWindow.AllowNestedDocks)
-    self.dw_player: list = []
+    self.dw_player = []
 
     # check if media creation time used as offset
     # TODO check if cfg.MEDIA_CREATION_TIME dict is present
@@ -1831,8 +1839,8 @@ def initialize_new_media_observation(self) -> bool:
         self.dw_player[i].resize_signal.connect(self.resize_dw)
 
         # add durations list
-        self.dw_player[i].media_durations: list = []
-        self.dw_player[i].cumul_media_durations: List[int] = [0]  # [idx for idx,x in enumerate(l) if l[idx-1]<pos<=x]
+        self.dw_player[i].media_durations = []
+        self.dw_player[i].cumul_media_durations = [0]  # [idx for idx,x in enumerate(l) if l[idx-1]<pos<=x]
 
         # add fps list
         self.dw_player[i].fps = {}
@@ -1844,6 +1852,13 @@ def initialize_new_media_observation(self) -> bool:
                 if r:
                     break
 
+            # start timer for activating the main window
+            self.main_window_activation_timer = QTimer()
+            self.main_window_activation_timer.setInterval(500)
+            # self.main_window_activation_timer.timeout.connect(self.activateWindow)
+            self.main_window_activation_timer.timeout.connect(self.activate_main_window)
+            self.main_window_activation_timer.start()
+
         for mediaFile in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][n_player]:
             logging.debug(f"media file: {mediaFile}")
 
@@ -1887,7 +1902,7 @@ def initialize_new_media_observation(self) -> bool:
             self.dw_player[i].player.playlist_append(media_full_path)
 
             # add media file name to player window title
-            self.dw_player[i].setWindowTitle(f"Player #{i + 1} ({pl.Path(media_full_path).name})")
+            self.dw_player[i].setWindowTitle(f"Player #{i + 1} ({Path(media_full_path).name})")
 
         # media duration cumuled in seconds
         self.dw_player[i].cumul_media_durations_sec = [round(dec(x / 1000), 3) for x in self.dw_player[i].cumul_media_durations]
@@ -1964,7 +1979,7 @@ def initialize_new_media_observation(self) -> bool:
 
     menu_options.update_menu(self)
 
-    if not self.MPV_IPC_MODE:
+    if self.MPV_IPC_MODE:
         # activate timer
         self.ipc_mpv_timer = QTimer()
         self.ipc_mpv_timer.setInterval(500)
@@ -1996,7 +2011,7 @@ def initialize_new_media_observation(self) -> bool:
         tmp_dir = self.ffmpeg_cache_dir if self.ffmpeg_cache_dir and os.path.isdir(self.ffmpeg_cache_dir) else tempfile.gettempdir()
 
         wav_file_path = (
-            pl.Path(tmp_dir) / pl.Path(self.dw_player[0].player.playlist[self.dw_player[0].player.playlist_pos]["filename"] + ".wav").name
+            Path(tmp_dir) / Path(self.dw_player[0].player.playlist[self.dw_player[0].player.playlist_pos]["filename"] + ".wav").name
         )
 
         if not wav_file_path.is_file():
@@ -2012,7 +2027,7 @@ def initialize_new_media_observation(self) -> bool:
         tmp_dir = self.ffmpeg_cache_dir if self.ffmpeg_cache_dir and os.path.isdir(self.ffmpeg_cache_dir) else tempfile.gettempdir()
 
         wav_file_path = (
-            pl.Path(tmp_dir) / pl.Path(self.dw_player[0].player.playlist[self.dw_player[0].player.playlist_pos]["filename"] + ".wav").name
+            Path(tmp_dir) / Path(self.dw_player[0].player.playlist[self.dw_player[0].player.playlist_pos]["filename"] + ".wav").name
         )
 
         if not wav_file_path.is_file():
@@ -2296,8 +2311,8 @@ def initialize_new_images_observation(self):
                 sorted(
                     list(
                         set(
-                            [str(x) for x in pl.Path(full_dir_path).glob(pattern)]
-                            + [str(x) for x in pl.Path(full_dir_path).glob(pattern.upper())]
+                            [str(x) for x in Path(full_dir_path).glob(pattern)]
+                            + [str(x) for x in Path(full_dir_path).glob(pattern.upper())]
                         )
                     )
                 )
@@ -2422,26 +2437,31 @@ def event2media_file_name(observation: dict, timestamp: dec) -> Optional[str]:
 
 def create_observations(self):
     """
-    Create observations from a media file directory
+    Create observations from a directory of media files
     """
-    # print(self.pj[cfg.OBSERVATIONS])
 
-    dir_path = QFileDialog.getExistingDirectory(None, "Select directory", os.getenv("HOME"))
-    if not dir_path:
+    if not (dir_path := QFileDialog.getExistingDirectory(None, "Select directory", os.getenv("HOME"))):
         return
 
-    dlg = dialog.Input_dialog(
-        label_caption="Set the following observation parameters",
-        elements_list=[
+    elements_list: list = []
+    if util.is_subdir(Path(dir_path), Path(self.projectFileName).parent):
+        elements_list.append(("cb", "Use relative paths", False))
+
+    elements_list.extend(
+        [
             ("cb", "Recurse the subdirectories", False),
-            ("cb", "Save the absolute media file path", True),
             ("cb", "Visualize spectrogram", False),
             ("cb", "Visualize waveform", False),
             ("cb", "Media creation date as offset", False),
             ("cb", "Close behaviors between videos", False),
             ("dsb", "Time offset (in seconds)", 0.0, 86400, 1, 0, 3),
             ("dsb", "Media scan sampling duration (in seconds)", 0.0, 86400, 1, 0, 3),
-        ],
+        ]
+    )
+
+    dlg = dialog.Input_dialog(
+        label_caption="Set the following observation parameters",
+        elements_list=elements_list,
         title="Observation parameters",
     )
     if not dlg.exec_():
@@ -2450,9 +2470,9 @@ def create_observations(self):
     file_count: int = 0
 
     if dlg.elements["Recurse the subdirectories"].isChecked():
-        files_list = pl.Path(dir_path).rglob("*")
+        files_list = Path(dir_path).rglob("*")
     else:
-        files_list = pl.Path(dir_path).glob("*")
+        files_list = Path(dir_path).glob("*")
 
     for file in files_list:
         if not file.is_file():
@@ -2462,22 +2482,25 @@ def create_observations(self):
             if not r.get("frames_number", 0):
                 continue
 
-            if dlg.elements["Save the absolute media file path"].isChecked():
-                media_file = str(file)
+            if "Use relative paths" in dlg.elements and dlg.elements["Use relative paths"].isChecked():
+                media_file = str(file.relative_to(Path(self.projectFileName).parent))
             else:
-                try:
-                    media_file = str(file.relative_to(pl.Path(self.projectFileName).parent))
-                except ValueError:
-                    QMessageBox.critical(
-                        self,
-                        cfg.programName,
-                        (
-                            f"the media file <b>{file}</b> can not be relative to the project directory "
-                            f"(<b>{pl.Path(self.projectFileName).parent}</b>)"
-                            "<br><br>Aborting the creation of observations"
-                        ),
-                    )
-                    return
+                media_file = str(file)
+
+            # else:
+            #    try:
+            #        media_file = str(file.relative_to(Path(self.projectFileName).parent))
+            #    except ValueError:
+            #        QMessageBox.critical(
+            #            self,
+            #            cfg.programName,
+            #            (
+            #                f"the media file <b>{file}</b> can not be relative to the project directory "
+            #                f"(<b>{Path(self.projectFileName).parent}</b>)"
+            #                "<br><br>Aborting the creation of observations"
+            #            ),
+            #        )
+            #        return
 
             if media_file in self.pj[cfg.OBSERVATIONS]:
                 QMessageBox.critical(
@@ -2518,4 +2541,6 @@ def create_observations(self):
     else:
         message: str = f"No media file were found in {dir_path}"
 
+    menu_options.update_menu(self)
+
     QMessageBox.information(self, cfg.programName, message)

boris/plot_data_module.py

@@ -134,6 +134,8 @@ class Plot_data(QWidget):
             column_converter=column_converter,
         )
 
+        print(f"{error_msg=}")
+
         if not result:
             self.error_msg = error_msg
             return

boris/plot_spectrogram_rt.py

@@ -205,6 +205,9 @@ class Plot_spectrogram_RT(QWidget):
         vmin = self.config_param.get(cfg.SPECTROGRAM_VMIN, cfg.SPECTROGRAM_DEFAULT_VMIN)
         vmax = self.config_param.get(cfg.SPECTROGRAM_VMAX, cfg.SPECTROGRAM_DEFAULT_VMAX)
 
+        if current_time is None:
+            return
+
         # start
         if current_time <= self.interval / 2:
             self.ax.specgram(

boris/plot_waveform_rt.py

@@ -156,7 +156,7 @@ class Plot_waveform_RT(QWidget):
         self.interval += 5 * action
         self.plot_waveform(current_time=self.time_mem, force_plot=True)
 
-    def plot_waveform(self, current_time: float, force_plot: bool = False):
+    def plot_waveform(self, current_time: float, force_plot: bool = False) -> None:
         """
         plot sound waveform centered on the current time
 
@@ -172,6 +172,9 @@ class Plot_waveform_RT(QWidget):
 
         self.ax.clear()
 
+        if current_time is None:
+            return
+
         # start
         if current_time <= self.interval / 2:
             time_ = np.linspace(

boris/plugins.py

@@ -24,6 +24,8 @@ import logging
 import numpy as np
 import pandas as pd
 from pathlib import Path
+import copy
+import inspect
 
 from PySide6.QtGui import QAction
 from PySide6.QtWidgets import QMessageBox
@@ -297,6 +299,7 @@ def run_plugin(self, plugin_name):
 
     logging.debug(f"{plugin_path=}")
 
+    # check if plugin file exists
     if not Path(plugin_path).is_file():
         QMessageBox.critical(self, cfg.programName, f"The plugin {plugin_path} was not found.")
         return
@@ -308,27 +311,7 @@ def run_plugin(self, plugin_name):
     if not selected_observations:
         return
 
-    logging.info("preparing dataframe for plugin")
-
-    message, df = project_functions.project2dataframe(self.pj, selected_observations)
-    if message:
-        logging.critical(message)
-        QMessageBox.critical(self, cfg.programName, message)
-        return
-
-    logging.info("done")
-
-    """
-    logging.debug("dataframe info")
-    logging.debug(f"{df.info()}")
-    logging.debug(f"{df.head()}")
-    """
-
-    # filter the dataframe with parameters
-    logging.info("filtering dataframe for plugin")
-    filtered_df = plugin_df_filter(df, observations_list=selected_observations, parameters=parameters)
-    logging.info("done")
-
+    # Python plugin
     if Path(plugin_path).suffix == ".py":
         # load plugin as module
         module_name = Path(plugin_path).stem
@@ -347,9 +330,48 @@ def run_plugin(self, plugin_name):
             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)
+        # check arguments required by the run function of the plugin
+        dataframe_required = False
+        project_required = False
+        # for param in inspect.signature(plugin_module.run).parameters.values():
+        for name, annotation in inspect.getfullargspec(plugin_module.run).annotations.items():
+            if name == "df" and annotation is pd.DataFrame:
+                dataframe_required = True
+            if name == "project" and annotation is dict:
+                project_required = True
+
+        # create arguments for the plugin run function
+        plugin_kwargs: dict = {}
+
+        if dataframe_required:
+            logging.info("preparing dataframe for plugin")
+            message, df = project_functions.project2dataframe(self.pj, selected_observations)
+            if message:
+                logging.critical(message)
+                QMessageBox.critical(self, cfg.programName, message)
+                return
+            logging.info("done")
+
+            # filter the dataframe with parameters
+            logging.info("filtering dataframe for plugin")
+            filtered_df = plugin_df_filter(df, observations_list=selected_observations, parameters=parameters)
+            logging.info("done")
 
+            plugin_kwargs["df"] = filtered_df
+
+        if project_required:
+            pj_copy = copy.deepcopy(self.pj)
+
+            # remove unselected observations from project
+            for obs_id in self.pj[cfg.OBSERVATIONS]:
+                if obs_id not in selected_observations:
+                    del pj_copy[cfg.OBSERVATIONS][obs_id]
+
+            plugin_kwargs["project"] = pj_copy
+
+        plugin_results = plugin_module.run(**plugin_kwargs)
+
+    # R plugin
     if Path(plugin_path).suffix in (".R", ".r"):
         try:
             from rpy2 import robjects
@@ -360,6 +382,21 @@ def run_plugin(self, plugin_name):
             QMessageBox.critical(self, cfg.programName, "The rpy2 Python module is not installed. R plugins cannot be used")
             return
 
+        logging.info("preparing dataframe for plugin")
+
+        message, df = project_functions.project2dataframe(self.pj, selected_observations)
+        if message:
+            logging.critical(message)
+            QMessageBox.critical(self, cfg.programName, message)
+            return
+
+        logging.info("done")
+
+        # filter the dataframe with parameters
+        logging.info("filtering dataframe for plugin")
+        filtered_df = plugin_df_filter(df, observations_list=selected_observations, parameters=parameters)
+        logging.info("done")
+
         # Read code from file
         try:
             with open(plugin_path, "r") as f:

boris/preferences.py

@@ -221,6 +221,9 @@ def preferences(self):
     preferencesWindow.cbConfirmSound.setChecked(self.confirmSound)
     # beep every
     preferencesWindow.sbBeepEvery.setValue(self.beep_every)
+    # frame step size
+    # preferencesWindow.sb_frame_step_size.setValue(self.config_param.get(cfg.FRAME_STEP_SIZE, cfg.FRAME_STEP_SIZE_DEFAULT_VALUE))
+
     # alert no focal subject
     preferencesWindow.cbAlertNoFocalSubject.setChecked(self.alertNoFocalSubject)
     # tracking cursor above event
@@ -418,6 +421,9 @@ def preferences(self):
 
             self.beep_every = preferencesWindow.sbBeepEvery.value()
 
+            # frame step size
+            # self.config_param[cfg.FRAME_STEP_SIZE] = preferencesWindow.sb_frame_step_size.value()
+
             self.alertNoFocalSubject = preferencesWindow.cbAlertNoFocalSubject.isChecked()
 
             self.trackingCursorAboveEvent = preferencesWindow.cbTrackingCursorAboveEvent.isChecked()
@@ -499,3 +505,6 @@ def preferences(self):
 
         else:
             break
+
+    # activate main window
+    self.activateWindow()

boris/preferences_ui.py

@@ -3,7 +3,7 @@
 ################################################################################
 ## Form generated from reading UI file 'preferences.ui'
 ##
-## Created by: Qt User Interface Compiler version 6.9.0
+## Created by: Qt User Interface Compiler version 6.10.0
 ##
 ## WARNING! All changes made in this file will be lost when recompiling UI file!
 ################################################################################
@@ -145,11 +145,10 @@ class Ui_prefDialog(object):
 
         self.horizontalLayout_4.addWidget(self.label_4)
 
-        self.sbffSpeed = QSpinBox(self.tab_observations)
+        self.sbffSpeed = QDoubleSpinBox(self.tab_observations)
         self.sbffSpeed.setObjectName(u"sbffSpeed")
-        self.sbffSpeed.setMinimum(0)
-        self.sbffSpeed.setMaximum(10000)
-        self.sbffSpeed.setValue(10)
+        self.sbffSpeed.setDecimals(3)
+        self.sbffSpeed.setMaximum(1000000.000000000000000)
 
         self.horizontalLayout_4.addWidget(self.sbffSpeed)
 
@@ -244,6 +243,26 @@ class Ui_prefDialog(object):
 
         self.verticalLayout.addWidget(self.cb_pause_before_addevent)
 
+        self.horizontalLayout_23 = QHBoxLayout()
+        self.horizontalLayout_23.setObjectName(u"horizontalLayout_23")
+        self.label_24 = QLabel(self.tab_observations)
+        self.label_24.setObjectName(u"label_24")
+        self.label_24.setEnabled(False)
+
+        self.horizontalLayout_23.addWidget(self.label_24)
+
+        self.sb_frame_step_size = QSpinBox(self.tab_observations)
+        self.sb_frame_step_size.setObjectName(u"sb_frame_step_size")
+        self.sb_frame_step_size.setEnabled(False)
+        self.sb_frame_step_size.setMinimum(1)
+        self.sb_frame_step_size.setMaximum(1000)
+        self.sb_frame_step_size.setValue(1)
+
+        self.horizontalLayout_23.addWidget(self.sb_frame_step_size)
+
+
+        self.verticalLayout.addLayout(self.horizontalLayout_23)
+
         self.verticalSpacer_4 = QSpacerItem(20, 391, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
 
         self.verticalLayout.addItem(self.verticalSpacer_4)
@@ -256,35 +275,35 @@ class Ui_prefDialog(object):
         self.splitter_2 = QSplitter(self.tab_analysis_plugins)
         self.splitter_2.setObjectName(u"splitter_2")
         self.splitter_2.setOrientation(Qt.Orientation.Horizontal)
-        self.widget = QWidget(self.splitter_2)
-        self.widget.setObjectName(u"widget")
-        self.verticalLayout_11 = QVBoxLayout(self.widget)
+        self.layoutWidget = QWidget(self.splitter_2)
+        self.layoutWidget.setObjectName(u"layoutWidget")
+        self.verticalLayout_11 = QVBoxLayout(self.layoutWidget)
         self.verticalLayout_11.setObjectName(u"verticalLayout_11")
         self.verticalLayout_11.setContentsMargins(0, 0, 0, 0)
-        self.label_13 = QLabel(self.widget)
+        self.label_13 = QLabel(self.layoutWidget)
         self.label_13.setObjectName(u"label_13")
 
         self.verticalLayout_11.addWidget(self.label_13)
 
-        self.lv_all_plugins = QListWidget(self.widget)
+        self.lv_all_plugins = QListWidget(self.layoutWidget)
         self.lv_all_plugins.setObjectName(u"lv_all_plugins")
 
         self.verticalLayout_11.addWidget(self.lv_all_plugins)
 
-        self.label_15 = QLabel(self.widget)
+        self.label_15 = QLabel(self.layoutWidget)
         self.label_15.setObjectName(u"label_15")
 
         self.verticalLayout_11.addWidget(self.label_15)
 
         self.horizontalLayout_16 = QHBoxLayout()
         self.horizontalLayout_16.setObjectName(u"horizontalLayout_16")
-        self.le_personal_plugins_dir = QLineEdit(self.widget)
+        self.le_personal_plugins_dir = QLineEdit(self.layoutWidget)
         self.le_personal_plugins_dir.setObjectName(u"le_personal_plugins_dir")
         self.le_personal_plugins_dir.setReadOnly(True)
 
         self.horizontalLayout_16.addWidget(self.le_personal_plugins_dir)
 
-        self.pb_browse_plugins_dir = QPushButton(self.widget)
+        self.pb_browse_plugins_dir = QPushButton(self.layoutWidget)
         self.pb_browse_plugins_dir.setObjectName(u"pb_browse_plugins_dir")
 
         self.horizontalLayout_16.addWidget(self.pb_browse_plugins_dir)
@@ -292,49 +311,49 @@ class Ui_prefDialog(object):
 
         self.verticalLayout_11.addLayout(self.horizontalLayout_16)
 
-        self.lw_personal_plugins = QListWidget(self.widget)
+        self.lw_personal_plugins = QListWidget(self.layoutWidget)
         self.lw_personal_plugins.setObjectName(u"lw_personal_plugins")
 
         self.verticalLayout_11.addWidget(self.lw_personal_plugins)
 
-        self.splitter_2.addWidget(self.widget)
+        self.splitter_2.addWidget(self.layoutWidget)
         self.splitter = QSplitter(self.splitter_2)
         self.splitter.setObjectName(u"splitter")
         self.splitter.setOrientation(Qt.Orientation.Vertical)
-        self.widget1 = QWidget(self.splitter)
-        self.widget1.setObjectName(u"widget1")
-        self.verticalLayout_12 = QVBoxLayout(self.widget1)
+        self.layoutWidget1 = QWidget(self.splitter)
+        self.layoutWidget1.setObjectName(u"layoutWidget1")
+        self.verticalLayout_12 = QVBoxLayout(self.layoutWidget1)
         self.verticalLayout_12.setObjectName(u"verticalLayout_12")
         self.verticalLayout_12.setContentsMargins(0, 0, 0, 0)
-        self.label_14 = QLabel(self.widget1)
+        self.label_14 = QLabel(self.layoutWidget1)
         self.label_14.setObjectName(u"label_14")
 
         self.verticalLayout_12.addWidget(self.label_14)
 
-        self.pte_plugin_description = QPlainTextEdit(self.widget1)
+        self.pte_plugin_description = QPlainTextEdit(self.layoutWidget1)
         self.pte_plugin_description.setObjectName(u"pte_plugin_description")
         self.pte_plugin_description.setReadOnly(True)
 
         self.verticalLayout_12.addWidget(self.pte_plugin_description)
 
-        self.splitter.addWidget(self.widget1)
-        self.widget2 = QWidget(self.splitter)
-        self.widget2.setObjectName(u"widget2")
-        self.verticalLayout_14 = QVBoxLayout(self.widget2)
+        self.splitter.addWidget(self.layoutWidget1)
+        self.layoutWidget2 = QWidget(self.splitter)
+        self.layoutWidget2.setObjectName(u"layoutWidget2")
+        self.verticalLayout_14 = QVBoxLayout(self.layoutWidget2)
         self.verticalLayout_14.setObjectName(u"verticalLayout_14")
         self.verticalLayout_14.setContentsMargins(0, 0, 0, 0)
-        self.label_23 = QLabel(self.widget2)
+        self.label_23 = QLabel(self.layoutWidget2)
         self.label_23.setObjectName(u"label_23")
 
         self.verticalLayout_14.addWidget(self.label_23)
 
-        self.pte_plugin_code = QPlainTextEdit(self.widget2)
+        self.pte_plugin_code = QPlainTextEdit(self.layoutWidget2)
         self.pte_plugin_code.setObjectName(u"pte_plugin_code")
         self.pte_plugin_code.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
 
         self.verticalLayout_14.addWidget(self.pte_plugin_code)
 
-        self.splitter.addWidget(self.widget2)
+        self.splitter.addWidget(self.layoutWidget2)
         self.splitter_2.addWidget(self.splitter)
 
         self.verticalLayout_15.addWidget(self.splitter_2)
@@ -676,7 +695,7 @@ class Ui_prefDialog(object):
 
         self.retranslateUi(prefDialog)
 
-        self.tabWidget.setCurrentIndex(2)
+        self.tabWidget.setCurrentIndex(1)
 
 
         QMetaObject.connectSlotsByName(prefDialog)
@@ -707,6 +726,7 @@ class Ui_prefDialog(object):
         self.cbTrackingCursorAboveEvent.setText(QCoreApplication.translate("prefDialog", u"Tracking cursor above current event", None))
         self.cbAlertNoFocalSubject.setText(QCoreApplication.translate("prefDialog", u"Alert if focal subject is not set", None))
         self.cb_pause_before_addevent.setText(QCoreApplication.translate("prefDialog", u"Pause media before \"Add event\" command", None))
+        self.label_24.setText(QCoreApplication.translate("prefDialog", u"Frame step size", None))
         self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_observations), QCoreApplication.translate("prefDialog", u"Observations", None))
         self.label_13.setText(QCoreApplication.translate("prefDialog", u"BORIS plugins", None))
         self.label_15.setText(QCoreApplication.translate("prefDialog", u"Personal plugins", None))

boris/project.py

@@ -1977,7 +1977,7 @@ class projectDialog(QDialog, Ui_dlgProject):
         self.pj[cfg.INDEPENDENT_VARIABLES] = dict(self.indVar)
 
         # converters
-        converters = {}
+        converters: dict = {}
         for row in range(self.tw_converters.rowCount()):
             converters[self.tw_converters.item(row, 0).text()] = {
                 "name": self.tw_converters.item(row, 0).text(),