boris-behav-obs 9.7.8__py3-none-any.whl → 9.7.9__py3-none-any.whl

boris/analysis_plugins/_export_to_feral.py

@@ -0,0 +1,225 @@
+"""
+BORIS plugin
+
+Export to FERAL (getferal.ai)
+"""
+
+import pandas as pd
+import json
+from pathlib import Path
+
+from PySide6.QtWidgets import QFileDialog
+
+# dependencies for CategoryDialog
+from PySide6.QtWidgets import QListWidget, QListWidgetItem, QLabel, QPushButton, QVBoxLayout, QHBoxLayout, QDialog
+from PySide6.QtCore import Qt
+
+
+__version__ = "0.1.1"
+__version_date__ = "2025-11-28"
+__plugin_name__ = "Export observations to FERAL"
+__author__ = "Olivier Friard - University of Torino - Italy"
+
+
+class CategoryDialog(QDialog):
+    def __init__(self, items, parent=None):
+        super().__init__(parent)
+
+        self.setWindowTitle("Organize the videos in categories")
+
+        self.setModal(True)
+
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        lists_layout = QHBoxLayout()
+
+        # All videos
+        self.list_unclassified = self._create_list_widget()
+        self.label_unclassified = QLabel("All videos")
+        col0_layout = QVBoxLayout()
+        col0_layout.addWidget(self.label_unclassified)
+        col0_layout.addWidget(self.list_unclassified)
+
+        self.list_cat1 = self._create_list_widget()
+        self.label_cat1 = QLabel("train")
+        col1_layout = QVBoxLayout()
+        col1_layout.addWidget(self.label_cat1)
+        col1_layout.addWidget(self.list_cat1)
+
+        self.list_cat2 = self._create_list_widget()
+        self.label_cat2 = QLabel("val")
+        col2_layout = QVBoxLayout()
+        col2_layout.addWidget(self.label_cat2)
+        col2_layout.addWidget(self.list_cat2)
+
+        self.list_cat3 = self._create_list_widget()
+        self.label_cat3 = QLabel("test")
+        col3_layout = QVBoxLayout()
+        col3_layout.addWidget(self.label_cat3)
+        col3_layout.addWidget(self.list_cat3)
+
+        self.list_cat4 = self._create_list_widget()
+        self.label_cat4 = QLabel("inference")
+        col4_layout = QVBoxLayout()
+        col4_layout.addWidget(self.label_cat4)
+        col4_layout.addWidget(self.list_cat4)
+
+        # Add all columns to the horizontal layout
+        lists_layout.addLayout(col0_layout)
+        lists_layout.addLayout(col1_layout)
+        lists_layout.addLayout(col2_layout)
+        lists_layout.addLayout(col3_layout)
+        lists_layout.addLayout(col4_layout)
+
+        main_layout.addLayout(lists_layout)
+
+        buttons_layout = QHBoxLayout()
+        self.btn_ok = QPushButton("OK")
+        self.btn_cancel = QPushButton("Cancel")
+
+        self.btn_ok.clicked.connect(self.accept)
+        self.btn_cancel.clicked.connect(self.reject)
+
+        buttons_layout.addStretch()
+        buttons_layout.addWidget(self.btn_ok)
+        buttons_layout.addWidget(self.btn_cancel)
+
+        main_layout.addLayout(buttons_layout)
+
+        # Populate "Unclassified" with input items
+        for text in items:
+            QListWidgetItem(text, self.list_unclassified)
+
+    def _create_list_widget(self):
+        """
+        Create a QListWidget ready for drag & drop.
+        """
+        lw = QListWidget()
+        lw.setSelectionMode(QListWidget.ExtendedSelection)
+        lw.setDragEnabled(True)
+        lw.setAcceptDrops(True)
+        lw.setDropIndicatorShown(True)
+        lw.setDragDropMode(QListWidget.DragDrop)
+        lw.setDefaultDropAction(Qt.MoveAction)
+        return lw
+
+    def get_categories(self):
+        """
+        Return the content of all categories as a dictionary of lists.
+        """
+
+        def collect(widget):
+            return [widget.item(i).text().rstrip("*") for i in range(widget.count())]
+
+        return {
+            "unclassified": collect(self.list_unclassified),
+            "train": collect(self.list_cat1),
+            "val": collect(self.list_cat2),
+            "test": collect(self.list_cat3),
+            "inference": collect(self.list_cat4),
+        }
+
+
+def run(df: pd.DataFrame, project: dict):
+    """
+    Export observations to FERAL
+    See https://www.getferal.ai/ > Label Preparation
+    """
+
+    out: dict = {
+        "is_multilabel": False,
+        "splits": {
+            "train": [],
+            "val": [],
+            "test": [],
+            "inference": [],
+        },
+    }
+
+    log: list = []
+
+    # class names
+    class_names = {x: project["behaviors_conf"][x]["code"] for x in project["behaviors_conf"]}
+    out["class_names"] = class_names
+    reversed_class_names = {project["behaviors_conf"][x]["code"]: int(x) for x in project["behaviors_conf"]}
+    log.append(f"{class_names=}")
+
+    observations: list = sorted([x for x in project["observations"]])
+    log.append(f"Selected observation: {observations}")
+
+    labels: dict = {}
+    video_list: list = []
+    for observation_id in observations:
+        log.append("---")
+        log.append(observation_id)
+
+        # check number of media file in player #1
+        if len(project["observations"][observation_id]["file"]["1"]) != 1:
+            log.append(f"The observation {observation_id} contains more than one video")
+            continue
+
+        # check number of coded subjects
+        if len(set([x[1] for x in project["observations"][observation_id]["events"]])) > 1:
+            log.append(f"The observation {observation_id} contains more than one subject")
+            continue
+
+        media_file_path: str = project["observations"][observation_id]["file"]["1"][0]
+        media_file_name = str(Path(media_file_path).name)
+
+        # skip if no events
+        if not project["observations"][observation_id]["events"]:
+            video_list.append(media_file_name)
+            log.append(f"No events for observation {observation_id}")
+            continue
+        else:
+            video_list.append(media_file_name + "*")
+
+        # extract FPS
+        FPS = project["observations"][observation_id]["media_info"]["fps"][media_file_path]
+        log.append(f"{media_file_name} {FPS=}")
+        # extract media duration
+        duration = project["observations"][observation_id]["media_info"]["length"][media_file_path]
+        log.append(f"{media_file_name} {duration=}")
+
+        number_of_frames = int(duration / (1 / FPS))
+        log.append(f"{number_of_frames=}")
+
+        labels[media_file_name] = [0] * number_of_frames
+
+        for idx in range(number_of_frames):
+            t = idx * (1 / FPS)
+            behaviors = (
+                df[(df["Observation id"] == observation_id) & (df["Start (s)"] <= t) & (df["Stop (s)"] >= t)]["Behavior"].unique().tolist()
+            )
+            if len(behaviors) > 1:
+                log.append(f"The observation {observation_id} contains more than one behavior for frame {idx}")
+                del labels[media_file_name]
+                break
+            if behaviors:
+                behaviors_idx = reversed_class_names[behaviors[0]]
+                labels[media_file_name][idx] = behaviors_idx
+
+    out["labels"] = labels
+
+    # splits
+    dlg = CategoryDialog(video_list)
+
+    if dlg.exec():  # Dialog accepted
+        result = dlg.get_categories()
+        del result["unclassified"]
+        out["splits"] = result
+
+        filename, _ = QFileDialog.getSaveFileName(
+            None,
+            "Choose a file to save",
+            "",  # start directory
+            "JSON files (*.json);;All files (*.*)",
+        )
+        if filename:
+            with open(filename, "w") as f_out:
+                f_out.write(json.dumps(out, separators=(",", ": "), indent=1))
+
+    else:
+        log.append("splits section missing")
+
+    return "\n".join(log)

boris/core.py

@@ -1500,7 +1500,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         logging.debug("previous media file")
 
         if self.playerType == cfg.MEDIA:
-            #if len(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][cfg.PLAYER1]) == 1:
+            # if len(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.FILE][cfg.PLAYER1]) == 1:
             #    self.seek_mediaplayer(dec(0))
             #    return
 
@@ -1510,7 +1510,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
             elif self.dw_player[0].player.playlist_count == 1:
                 self.seek_mediaplayer(dec(0))
-                #self.statusbar.showMessage("There is only one media file", 5000)
+                # self.statusbar.showMessage("There is only one media file", 5000)
 
             if hasattr(self, "spectro"):
                 self.spectro.memChunk = -1
@@ -4151,8 +4151,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         called only in IPC mode
         """
         # check if eof reached
-        #print(f"{self.dw_player[0].player.playlist_pos=}")
-        #print(f"{self.dw_player[0].player.playlist_count=}")
+        # print(f"{self.dw_player[0].player.playlist_pos=}")
+        # print(f"{self.dw_player[0].player.playlist_count=}")
         if self.dw_player[0].player.eof_reached and self.dw_player[0].player.core_idle:
             logging.debug("end of playlist reached")
             if self.dw_player[0].player.playlist_pos is not None and self.dw_player[0].player.playlist_count is not None:
@@ -4220,8 +4220,11 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
                 # sync players 2..8 if time diff >= 1 s
                 if not math.isnan(ct) and not math.isnan(ct0):
-                    if abs(ct0 - (ct + dec(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.OFFSET][str(n_player + 1)]))) >= 1:
-                        self.sync_time(n_player, ct0)  # self.seek_mediaplayer(ct0, n_player)
+                    if (
+                        abs(ct0 - (ct + dec(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO][cfg.OFFSET][str(n_player + 1)])))
+                        >= 1
+                    ):
+                        self.sync_time(n_player, float(ct0))  # self.seek_mediaplayer(ct0, n_player)
 
         currentTimeOffset = dec(cumulative_time_pos + self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TIME_OFFSET])
 
@@ -5485,7 +5488,6 @@ class MainWindow(QMainWindow, Ui_MainWindow):
                 if self.dw_player[0].player.playlist_pos == self.dw_player[0].player.playlist_count - 1:
                     self.seek_mediaplayer(dec(0))
 
-
         # check if player 1 is ended
         for i, dw in enumerate(self.dw_player):
             if (
@@ -5867,7 +5869,7 @@ def main():
             QMessageBox.warning(
                 None,
                 cfg.programName,
-                (f"This version of BORIS for macOS is still EXPERIMENTAL and should be used at your own risk."),
+                ("This version of BORIS for macOS is still EXPERIMENTAL and should be used at your own risk."),
                 QMessageBox.Ok | QMessageBox.Default,
                 QMessageBox.NoButton,
             )
@@ -5898,4 +5900,3 @@ def main():
     del window
 
     sys.exit(return_code)
-

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
 
@@ -131,7 +131,6 @@ def observations_list(self):
         else:
             close_observation(self)
 
-
         QtTest.QTest.qWait(1000)
 
     if result == cfg.OPEN:
@@ -602,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,
@@ -1315,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, {})
@@ -1856,10 +1855,9 @@ def initialize_new_media_observation(self) -> bool:
             # 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.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}")
@@ -1904,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]
@@ -2013,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():
@@ -2029,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():
@@ -2313,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())]
                         )
                     )
                 )
@@ -2439,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_():
@@ -2467,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():
@@ -2479,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(
@@ -2535,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/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/utilities.py

@@ -126,6 +126,15 @@ if (sys.platform.startswith("win") or sys.platform.startswith("linux")) and ("-i
             sys.exit(5)
 
 
+def is_subdir(a: Path, b: Path) -> bool:
+    """
+    Return True if directory A is inside directory B.
+    """
+    a = a.resolve()
+    b = b.resolve()
+    return a.is_relative_to(b)
+
+
 def test_mpv_ipc(socket_path: str = cfg.MPV_SOCKET) -> bool:
     """
     test if socket available

boris/version.py

@@ -20,5 +20,5 @@ This file is part of BORIS.
 
 """
 
-__version__ = "9.7.8"
-__version_date__ = "2025-11-19"
+__version__ = "9.7.9"
+__version_date__ = "2025-11-27"

{boris_behav_obs-9.7.8.dist-info → boris_behav_obs-9.7.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boris-behav-obs
-Version: 9.7.8
+Version: 9.7.9
 Summary: BORIS - Behavioral Observation Research Interactive Software
 Author-email: Olivier Friard <olivier.friard@unito.it>
 License-Expression: GPL-3.0-only
@@ -51,7 +51,7 @@ It provides also some analysis tools like time budget and some plotting function
 <!-- The BO-RIS paper has more than [![BORIS citations counter](https://penelope.unito.it/friard/boris_scopus_citations.png) citations](https://www.boris.unito.it/citations) in peer-reviewed scientific publications. -->
 
 
-The BORIS paper has more than 2442 citations in peer-reviewed scientific publications.
+The BORIS paper has more than 2443 citations in peer-reviewed scientific publications.
 
 
 

{boris_behav_obs-9.7.8.dist-info → boris_behav_obs-9.7.9.dist-info}/RECORD

@@ -16,7 +16,7 @@ boris/connections.py,sha256=KsC17LnS4tRM6O3Nu3mD1H9kQ7uYhhad9229jXfGF94,19774
 boris/converters.py,sha256=n6gDM9x2hS-ZOoHLruiifuXxnC7ERsUukiFokhHZPoQ,11678
 boris/converters_ui.py,sha256=uu7LOBV_fKv2DBdOqsqPwjGsjgONr5ODBoscAA-EP48,9900
 boris/cooccurence.py,sha256=tVERC-V8MWjWHlGEfDuu08iS94qjt4do-38jwI62QaY,10367
-boris/core.py,sha256=gTlVvKH_khobEZ0aBwtZaKFH3BIitR8XjqkAz93Vr6c,234295
+boris/core.py,sha256=PfpWAsA7vWVPSYkCcZ79xsPgwOc-dP4V-yCD9XgybtQ,234375
 boris/core_qrc.py,sha256=Hz51Xw70ZIlDbYB281nfGtCm43_ItYhamMu2T5X8Tu8,639882
 boris/core_ui.py,sha256=uDAI9mbadBe2mSsgugzNfRHxASc6Mu5kUf5tB9CZCjY,77445
 boris/db_functions.py,sha256=TfCJ0Hq0pTFOKrZz3RzdvnR-NKCmrPHU2qL9BSXeeGQ,13379
@@ -47,7 +47,7 @@ boris/modifiers_coding_map.py,sha256=oT56ZY_PXhEJsMoblEsyNMAPbDpv7ZMOCnvmt7Ibx_Y
 boris/mpv.py,sha256=EfzIHjPbgewG4w3smEtqEUPZoVwYmMQkL4Q8ZyW-a58,76410
 boris/mpv2.py,sha256=IUI4t4r9GYX7G5OXTjd3RhMMOkDdfal_15buBgksLsk,92152
 boris/observation.py,sha256=K-Xi99BMLSohx6pPLKk-Eqi56fLWDFLScHxXKkoFAlg,57507
-boris/observation_operations.py,sha256=YYbaaecwd2C0zxQYAxes-rUx-XY6aQ94hzkPazmPcFw,106339
+boris/observation_operations.py,sha256=HPPat_-6c_Fu0cFs0wQD86AIE7g7eKHutOGi_xexMAM,106581
 boris/observation_ui.py,sha256=DAnU94QBNvkLuHT6AxTwqSk_D_n6VUhSl8PexZv_dUk,33309
 boris/observations_list.py,sha256=NqwECGHtHYmKhSe-qCfqPmJ24SSfzlXvIXS2i3op_zE,10591
 boris/otx_parser.py,sha256=70QvilzFHXbjAHR88YH0aEXJ3xxheLS5fZGgHFHGpNE,16367
@@ -59,7 +59,7 @@ boris/plot_events.py,sha256=tKiUWH0TNSkK7xz5Vf0tAD3KiuAalv6UZEVtOnoFpWY,24059
 boris/plot_events_rt.py,sha256=xJmjwqhQxCN4FDBYRQ0O2eHm356Rbexzr3m1qTefMDU,8326
 boris/plot_spectrogram_rt.py,sha256=wDhnkqwjd2UfCxrfOejOUxoNOqfMNo6vo1JSvYgM-2A,10925
 boris/plot_waveform_rt.py,sha256=RNXhcBzRKnoGoVjRAHsVvOaj0BJbbI2cpCMjMUiGqX0,7534
-boris/plugins.py,sha256=sn2r8kMxkzaO8kNhem-cTlTBrym9MlFPyRT9Av9rHGg,15603
+boris/plugins.py,sha256=AzjKLPsqBk-K8wPM3HXe4w-sNaDU1bQm2XEoLr4Zx0k,17234
 boris/preferences.py,sha256=YcGBaXRfimH4jpFLfcUAgCAGESXSLhB6cli_cg4cDl0,21902
 boris/preferences_ui.py,sha256=zkmbQbkb0WqhPyMtnU-DU9Y2enSph_r-LnwsmEOgzkk,35090
 boris/project.py,sha256=4dE4nqo8at1lz9KykprF5Rr62R78yu4vBrTfde1gQ-g,86438
@@ -77,8 +77,8 @@ boris/synthetic_time_budget.py,sha256=3Eb9onMLmgqCLd50CuxV9L8RV2ESzfaMWvPK_bXUMM
 boris/time_budget_functions.py,sha256=SbGyTF2xySEqBdRJZeWFTirruvK3r6pwM6e4Gz17W1s,52186
 boris/time_budget_widget.py,sha256=z-tyITBtIz-KH1H2OdMB5a8x9QQLK7Wu96-zkC6NVDA,43213
 boris/transitions.py,sha256=okyDCO-Vn4p_Fixd8cGiSIaUhUxG5ePIOqGSuP52g_c,12246
-boris/utilities.py,sha256=hZF3yTNgjKN057VGLvy6gLYZsjV8b_DHCDGy6_DERd8,58621
-boris/version.py,sha256=lcCIuAdOq-j1yLj0CPlt2bedzEeQSaKQemxANe9BGpA,787
+boris/utilities.py,sha256=Ae3YjXkulJYQxbE4Fpvle4tX2nA_qJQhAn980sTFHqw,58805
+boris/version.py,sha256=WD0mTHLHZshmktAU-U6dY_d9wm09W0c_v9t3wdvW5-I,787
 boris/video_equalizer.py,sha256=cm2JXe1eAPkqDzxYB2OMKyuveMBdq4a9-gD1bBorbn4,5823
 boris/video_equalizer_ui.py,sha256=1CG3s79eM4JAbaCx3i1ILZXLceb41_gGXlOLNfpBgnw,10142
 boris/video_operations.py,sha256=YlwcX3rgVsv6h78ylQYS9ITZs5MsXT8h0XsyaBU5mN8,11015
@@ -86,6 +86,7 @@ boris/view_df.py,sha256=fhcNMFFVbQ4ZTpPwN_4Bg66DDIoV25zaPryZUsOxsKg,3338
 boris/view_df_ui.py,sha256=CaMeRH_vQ00CTDDFQn73ZZaS-r8BSTWpL-dMCFqzJ_Q,2775
 boris/write_event.py,sha256=xC-dUjgPS4-tvrQfvyL7O_xi-tyQI7leSiSV8_x8hgg,23817
 boris/analysis_plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boris/analysis_plugins/_export_to_feral.py,sha256=_eirrreEn3Udp4POBG8cA1Gno4e-x_LFYXfvDhy11fg,7417
 boris/analysis_plugins/_latency.py,sha256=9kCdFDtb5Zdao1xFpioi_exm_IxyGm6RlY3Opn6GUFo,2030
 boris/analysis_plugins/irr_cohen_kappa.py,sha256=OqmivIE6i1hTcFVMp0EtY0Sr7C1Jm9t0D4IKbDfTJ7U,4268
 boris/analysis_plugins/irr_cohen_kappa_with_modifiers.py,sha256=DtzFLRToR9GdkmWYDcCmpSvxHGpguVp-_n8F-t7ND7c,4461
@@ -101,9 +102,9 @@ boris/portion/dict.py,sha256=uNM-LEY52CZ2VNMMW_C9QukoyTvPlQf8vcbGa1lQBHI,11281
 boris/portion/func.py,sha256=mSQr20YS1ug7R1fRqBg8LifjtXDRvJ6Kjc3WOeL9P34,2172
 boris/portion/interval.py,sha256=sOlj3MAGGaB-JxCkigS-n3qw0fY7TANAsXv1pavr8J4,19931
 boris/portion/io.py,sha256=kpq44pw3xnIyAlPwaR5qRHKRdZ72f8HS9YVIWs5k2pk,6367
-boris_behav_obs-9.7.8.dist-info/licenses/LICENSE.TXT,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
-boris_behav_obs-9.7.8.dist-info/METADATA,sha256=1ehrEM-hNzY-uiRRZn8x2xRwnMUV7cG8CmbW5U-MS0o,5203
-boris_behav_obs-9.7.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-boris_behav_obs-9.7.8.dist-info/entry_points.txt,sha256=k__8XvFi4vaA4QFvQehCZjYkKmZH34HSAJI2iYCWrMs,52
-boris_behav_obs-9.7.8.dist-info/top_level.txt,sha256=fJSgm62S7WesiwTorGbOO4nNN0yzgZ3klgfGi3Px4qI,6
-boris_behav_obs-9.7.8.dist-info/RECORD,,
+boris_behav_obs-9.7.9.dist-info/licenses/LICENSE.TXT,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
+boris_behav_obs-9.7.9.dist-info/METADATA,sha256=aZnGCR1F6i4L1MqgrpzSsraISOgHo_rcBGDzx1xvS7k,5203
+boris_behav_obs-9.7.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+boris_behav_obs-9.7.9.dist-info/entry_points.txt,sha256=k__8XvFi4vaA4QFvQehCZjYkKmZH34HSAJI2iYCWrMs,52
+boris_behav_obs-9.7.9.dist-info/top_level.txt,sha256=fJSgm62S7WesiwTorGbOO4nNN0yzgZ3klgfGi3Px4qI,6
+boris_behav_obs-9.7.9.dist-info/RECORD,,