boris-behav-obs 9.1.1__py2.py3-none-any.whl → 9.2.1__py2.py3-none-any.whl

boris/advanced_event_filtering.py

@@ -359,8 +359,10 @@ def event_filtering(self):
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
-        start_interval=start_interval,
-        end_interval=end_interval,
+        # start_interval=start_interval,
+        # end_interval=end_interval,
+        start_interval=None,
+        end_interval=None,
         maxTime=max_media_duration_all_obs,
         show_include_modifiers=False,
         show_exclude_non_coded_behaviors=False,
@@ -368,7 +370,7 @@ def event_filtering(self):
         n_observations=len(selected_observations),
     )
 
-    if parameters == {}:
+    if not parameters:
         return
 
     if not parameters[cfg.SELECTED_SUBJECTS] or not parameters[cfg.SELECTED_BEHAVIORS]:

boris/analysis_plugins/number_of_occurences.py

@@ -6,8 +6,8 @@ number of occurences of behaviors
 
 import pandas as pd
 
-__version__ = "0.2.0"
-__version_date__ = "2025-01-25"
+__version__ = "0.3.0"
+__version_date__ = "2025-03-17"
 __plugin_name__ = "Number of occurences of behaviors"
 __author__ = "Olivier Friard - University of Torino - Italy"
 
@@ -20,43 +20,3 @@ def run(df: pd.DataFrame):
     df_results: pd.DataFrame = df.groupby(["Subject", "Behavior"])["Behavior"].count().reset_index(name="number of occurences")
 
     return df_results
-
-
-def main(df: pd.DataFrame, observations_list: list = [], parameters: dict = {}) -> pd.DataFrame:
-    """
-    filter by selected observations.
-    filter by selected subjects.
-    filter by selected behaviors.
-    filter by time interval.
-    """
-
-    # filter selected observations
-    if observations_list:
-        df = df[df["Observation id"].isin(observations_list)]
-
-    if parameters:
-        # filter selected subjects
-        df = df[df["Subject"].isin(parameters["selected subjects"])]
-
-        # filter selected behaviors
-        df = df[df["Behavior"].isin(parameters["selected behaviors"])]
-
-        # filter selected time interval
-        if parameters["start time"] is not None and parameters["end time"] is not None:
-            MIN_TIME = parameters["start time"]
-            MAX_TIME = parameters["end time"]
-            df_interval = df[
-                (
-                    ((df["Start (s)"] >= MIN_TIME) & (df["Start (s)"] <= MAX_TIME))
-                    | ((df["Stop (s)"] >= MIN_TIME) & (df["Stop (s)"] <= MAX_TIME))
-                )
-                | ((df["Start (s)"] < MIN_TIME) & (df["Stop (s)"] > MAX_TIME))
-            ]
-            df_interval.loc[df["Start (s)"] < MIN_TIME, "Start (s)"] = MIN_TIME
-            df_interval.loc[df["Stop (s)"] > MAX_TIME, "Stop (s)"] = MAX_TIME
-
-            df_interval.loc[:, "Duration (s)"] = df_interval["Stop (s)"] - df_interval["Start (s)"]
-
-            df = df_interval
-
-    return run(df)

boris/analysis_plugins/number_of_occurences_by_independent_variable.py

@@ -6,8 +6,8 @@ number of occurences of behaviors by independent_variable
 
 import pandas as pd
 
-__version__ = "0.2.0"
-__version_date__ = "2025-01-25"
+__version__ = "0.3.0"
+__version_date__ = "2025-03-17"
 __plugin_name__ = "Number of occurences of behaviors by subject by independent_variable"
 __author__ = "Olivier Friard - University of Torino - Italy"
 
@@ -15,9 +15,9 @@ __author__ = "Olivier Friard - University of Torino - Italy"
 def run(df: pd.DataFrame):
     """
     Calculate the number of occurrences of behaviors by subject and by independent_variable.
-    """
 
-    str_results: str = ""
+    This plugin returns a Pandas dataframe
+    """
 
     df_results: df.DataFrame = (
         df.groupby(
@@ -31,44 +31,4 @@ def run(df: pd.DataFrame):
         .reset_index(name="number of occurences")
     )
 
-    return df_results, str_results
-
-
-def main(df: pd.DataFrame, observations_list: list = [], parameters: dict = {}) -> pd.DataFrame:
-    """
-    filter by selected observations.
-    filter by selected subjects.
-    filter by selected behaviors.
-    filter by time interval.
-    """
-
-    # filter selected observations
-    if observations_list:
-        df = df[df["Observation id"].isin(observations_list)]
-
-    if parameters:
-        # filter selected subjects
-        df = df[df["Subject"].isin(parameters["selected subjects"])]
-
-        # filter selected behaviors
-        df = df[df["Behavior"].isin(parameters["selected behaviors"])]
-
-        # filter selected time interval
-        if parameters["start time"] is not None and parameters["end time"] is not None:
-            MIN_TIME = parameters["start time"]
-            MAX_TIME = parameters["end time"]
-            df_interval = df[
-                (
-                    ((df["Start (s)"] >= MIN_TIME) & (df["Start (s)"] <= MAX_TIME))
-                    | ((df["Stop (s)"] >= MIN_TIME) & (df["Stop (s)"] <= MAX_TIME))
-                )
-                | ((df["Start (s)"] < MIN_TIME) & (df["Stop (s)"] > MAX_TIME))
-            ]
-            df_interval.loc[df["Start (s)"] < MIN_TIME, "Start (s)"] = MIN_TIME
-            df_interval.loc[df["Stop (s)"] > MAX_TIME, "Stop (s)"] = MAX_TIME
-
-            df_interval.loc[:, "Duration (s)"] = df_interval["Stop (s)"] - df_interval["Start (s)"]
-
-            df = df_interval
-
-    return run(df)
+    return df_results

boris/analysis_plugins/time_budget.py

@@ -7,8 +7,8 @@ Time budget
 import pandas as pd
 import numpy as np
 
-__version__ = "0.2.0"
-__version_date__ = "2025-01-25"
+__version__ = "0.3.0"
+__version_date__ = "2025-03-17"
 __plugin_name__ = "Time budget"
 __author__ = "Olivier Friard - University of Torino - Italy"
 
@@ -18,7 +18,7 @@ def run(df: pd.DataFrame):
     Calculate the following values:
 
     - Total number of occurences of behavior
-    - Total duration of behavior (in seconds)
+    - Total duration of behavior (in seconds)  (pandas.DataFrame.sum() ignore NaN values when computing the sum. Use min_count=1)
     - Duration mean of behavior (in seconds)
     - Standard deviation of behavior duration (in seconds)
     - Inter-event intervals mean (in seconds)
@@ -26,11 +26,15 @@ def run(df: pd.DataFrame):
     - % of total subject observation duration
     """
 
+    print("running time budget plugin")
+
+    print(df)
+
     group_by = ["Subject", "Behavior"]
 
     dfs = [
         df.groupby(group_by)["Behavior"].count().reset_index(name="number of occurences"),
-        df.groupby(group_by)["Duration (s)"].sum().reset_index(name="total duration"),
+        df.groupby(group_by)["Duration (s)"].sum(min_count=1).reset_index(name="total duration"),
         df.groupby(group_by)["Duration (s)"].mean().astype(float).round(3).reset_index(name="duration mean"),
         df.groupby(group_by)["Duration (s)"].std().astype(float).round(3).reset_index(name="duration std dev"),
     ]
@@ -48,7 +52,7 @@ def run(df: pd.DataFrame):
     interval = (df.groupby(["Subject"])["Stop (s)"].max() - df.groupby(["Subject"])["Start (s)"].min()).replace(0, np.nan)
 
     dfs.append(
-        (100 * df.groupby(group_by)["Duration (s)"].sum() / interval)
+        (100 * df.groupby(group_by)["Duration (s)"].sum(min_count=1) / interval)
         .astype(float)
         .round(3)
         .reset_index(name="% of total subject observation duration")
@@ -59,45 +63,3 @@ def run(df: pd.DataFrame):
         merged_df = pd.merge(merged_df, df, on=group_by)
 
     return merged_df
-
-
-def main(df: pd.DataFrame, observations_list: list = [], parameters: dict = {}) -> pd.DataFrame:
-    """
-    filter by selected observations.
-    filter by selected subjects.
-    filter by selected behaviors.
-    filter by time interval.
-    """
-
-    # filter selected observations
-    if observations_list:
-        df = df[df["Observation id"].isin(observations_list)]
-
-    if parameters:
-        # filter selected subjects
-        df = df[df["Subject"].isin(parameters["selected subjects"])]
-
-        # filter selected behaviors
-        df = df[df["Behavior"].isin(parameters["selected behaviors"])]
-
-        # filter selected time interval
-        if parameters["start time"] is not None and parameters["end time"] is not None:
-            MIN_TIME = parameters["start time"]
-            MAX_TIME = parameters["end time"]
-
-            df_interval = df[
-                (
-                    ((df["Start (s)"] >= MIN_TIME) & (df["Start (s)"] <= MAX_TIME))
-                    | ((df["Stop (s)"] >= MIN_TIME) & (df["Stop (s)"] <= MAX_TIME))
-                )
-                | ((df["Start (s)"] < MIN_TIME) & (df["Stop (s)"] > MAX_TIME))
-            ]
-
-            df_interval.loc[df["Start (s)"] < MIN_TIME, "Start (s)"] = MIN_TIME
-            df_interval.loc[df["Stop (s)"] > MAX_TIME, "Stop (s)"] = MAX_TIME
-
-            df_interval.loc[:, "Duration (s)"] = df_interval["Stop (s)"] - df_interval["Start (s)"]
-
-            df = df_interval
-
-    return run(df)

boris/behavior_binary_table.py

@@ -216,6 +216,8 @@ def behavior_binary_table(self):
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
+        # start_interval=start_interval,
+        # end_interval=end_interval,
         start_interval=start_interval,
         end_interval=end_interval,
         maxTime=max_media_duration_all_obs,
@@ -224,7 +226,7 @@ def behavior_binary_table(self):
         by_category=False,
         n_observations=len(selected_observations),
     )
-    if parameters == {}:
+    if not parameters:
         return
     if not parameters[cfg.SELECTED_SUBJECTS] or not parameters[cfg.SELECTED_BEHAVIORS]:
         QMessageBox.warning(None, cfg.programName, "Select subject(s) and behavior(s) to analyze")

boris/cooccurence.py

@@ -98,6 +98,7 @@ def get_cooccurence(self):
 
     start_interval, end_interval = observation_operations.time_intervals_range(self.pj[cfg.OBSERVATIONS], selected_observations)
 
+    # loop on choose subjects /behaviors until parameters are OK
     while True:
         flag_ok: bool = True
         parameters = select_subj_behav.choose_obs_subj_behav_category(
@@ -105,15 +106,17 @@ def get_cooccurence(self):
             selected_observations,
             start_coding=start_coding,
             end_coding=end_coding,
-            start_interval=start_interval,
-            end_interval=end_interval,
+            # start_interval=start_interval,
+            # end_interval=end_interval,
+            start_interval=None,
+            end_interval=None,
             maxTime=max_media_duration_all_obs,
             n_observations=len(selected_observations),
             show_include_modifiers=False,
             show_exclude_non_coded_behaviors=True,
         )
 
-        if parameters == {}:  # cancel button pressed
+        if not parameters:  # cancel button pressed
             return
 
         if not parameters[cfg.SELECTED_SUBJECTS]:

boris/core.py

@@ -34,7 +34,6 @@ import json
 import logging
 import pathlib as pl
 import platform
-import importlib
 import re
 import PIL.Image
 import PIL.ImageEnhance
@@ -52,7 +51,6 @@ from decimal import Decimal as dec
 from decimal import ROUND_DOWN
 import gzip
 from collections import deque
-import pandas as pd
 import matplotlib
 import zipfile
 import shutil
@@ -129,7 +127,6 @@ from . import config_file
 from . import select_subj_behav
 from . import observation_operations
 from . import write_event
-from . import view_df
 
 
 # matplotlib.pyplot.switch_backend("Qt5Agg")
@@ -3634,6 +3631,18 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         else:
             current_time = self.getLaps()
 
+        # check if observation time interval
+        if self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[1]:
+            # check if current time outside of interval
+            if current_time >= self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[1]:
+                self.beep("beep")
+                self.liveTimer.stop()
+                self.liveObservationStarted = False
+                # set current time to end of observation interval
+                current_time = dec(self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[1])                
+                self.pb_live_obs.setText("Live observation finished")
+
+
         self.lb_current_media_time.setText(util.convertTime(self.timeFormat, current_time))
 
         # extract State events
@@ -3663,13 +3672,6 @@ class MainWindow(QMainWindow, Ui_MainWindow):
                 self.liveTimer.stop()
                 self.pb_live_obs.setText("Live observation stopped (scan sampling)")
 
-        # observation time interval
-        if self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[1]:
-            if current_time >= self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[1]:
-                self.beep("beep")
-                self.liveTimer.stop()
-                self.liveObservationStarted = False
-                self.pb_live_obs.setText("Live observation finished")
 
     def start_live_observation(self):
         """
@@ -3772,8 +3774,10 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             selected_observations,
             start_coding=start_coding,
             end_coding=end_coding,
-            start_interval=start_interval,
-            end_interval=end_interval,
+            # start_interval=start_interval,
+            # end_interval=end_interval,
+            start_interval=None,
+            end_interval=None,
             maxTime=max_media_duration_all_obs,
             show_include_modifiers=False,
             show_exclude_non_coded_behaviors=False,
@@ -5762,6 +5766,9 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             self.extract_frame(self.dw_player[0])
 
     def obs_param(self):
+        """
+        allow user to select observations and then subjects and behaviors
+        """
         _, selected_observations = select_observations.select_observations2(self, mode=cfg.MULTIPLE, windows_title="")
 
         if not selected_observations:
@@ -5786,8 +5793,14 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
         start_coding, end_coding, _ = observation_operations.coding_time(self.pj[cfg.OBSERVATIONS], selected_observations)
 
+        print(f"{start_coding=}")
+        print(f"{end_coding=}")
+
         start_interval, end_interval = observation_operations.time_intervals_range(self.pj[cfg.OBSERVATIONS], selected_observations)
 
+        print(f"{start_interval=}")
+        print(f"{end_interval=}")
+
         parameters: dict = select_subj_behav.choose_obs_subj_behav_category(
             self,
             selected_observations,
@@ -5803,6 +5816,8 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         if parameters == {}:
             return [], {}
 
+        print(f"{parameters=}")
+
         if not parameters[cfg.SELECTED_SUBJECTS] or not parameters[cfg.SELECTED_BEHAVIORS]:
             QMessageBox.warning(None, cfg.programName, "Select subject(s) and behavior(s) to analyze")
             return [], {}
@@ -5810,94 +5825,6 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         logging.debug(f"{parameters=}")
         return selected_observations, parameters
 
-    def run_plugin(self):
-        """
-        run plugin
-        """
-        if not self.project:
-            QMessageBox.warning(
-                self,
-                cfg.programName,
-                "No observations found. Open a project first",
-                QMessageBox.Ok | QMessageBox.Default,
-                QMessageBox.NoButton,
-            )
-            return
-
-        logging.debug(f"{self.config_param.get(cfg.ANALYSIS_PLUGINS, {})=}")
-
-        plugin_name = self.sender().text()
-        if plugin_name not in self.config_param.get(cfg.ANALYSIS_PLUGINS, {}):
-            QMessageBox.critical(self, cfg.programName, f"Plugin '{plugin_name}' not found")
-            return
-
-        plugin_path = self.config_param.get(cfg.ANALYSIS_PLUGINS, {})[plugin_name]
-
-        logging.debug(f"{plugin_path=}")
-
-        if not pl.Path(plugin_path).is_file():
-            QMessageBox.critical(self, cfg.programName, f"The plugin {plugin_path} was not found.")
-            return
-
-        logging.debug(f"run plugin from {plugin_path}")
-
-        module_name = pl.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__')}"
-        )
-
-        selected_observations, parameters = self.obs_param()
-        if not selected_observations:
-            return
-
-        df = project_functions.project2dataframe(self.pj, selected_observations)
-
-        logging.debug("dataframe info")
-        logging.debug(f"{df.info()}")
-        logging.debug(f"{df.head()}")
-
-        # df_results, str_results = plugin_module.main(df, observations_list=selected_observations, parameters=parameters)
-
-        plugin_results = plugin_module.main(df, observations_list=selected_observations, parameters=parameters)
-        # test if tuple: if not transform to tuple
-        if not isinstance(plugin_results, tuple):
-            plugin_results = tuple([plugin_results])
-
-        self.plugin_visu: list = []
-        for result in plugin_results:
-            if isinstance(result, str):
-                self.plugin_visu.append(dialog.Results_dialog())
-                self.plugin_visu[-1].setWindowTitle(self.sender().text())
-                self.plugin_visu[-1].ptText.clear()
-                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(self.sender().text(), f"{plugin_module.__version__} ({plugin_module.__version_date__})", result)
-                )
-                self.plugin_visu[-1].show()
-            else:
-                # result is not str nor dataframe
-                QMessageBox.critical(
-                    None,
-                    cfg.programName,
-                    (
-                        f"Plugin returns an unknown object type: {type(result)}\n\n"
-                        "Plugins must return str and/or Pandas Dataframes.\n"
-                        "Check the plugin code."
-                    ),
-                    QMessageBox.Ok | QMessageBox.Default,
-                    QMessageBox.NoButton,
-                )
-
 
 def main():
     # QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)

boris/export_events.py

@@ -76,7 +76,7 @@ def export_events_as_behavioral_sequences(self, separated_subjects=False, timed=
     else:
         max_media_duration_all_obs = None
         start_coding, end_coding = dec("NaN"), dec("NaN")
-        start_interval, end_interval = dec("NaN"), dec("NaN")
+        start_interval, end_interval = None, None
 
     parameters = select_subj_behav.choose_obs_subj_behav_category(
         self,
@@ -169,7 +169,7 @@ def export_tabular_events(self, mode: str = "tabular") -> None:
     else:
         max_media_duration_all_obs = None
         start_coding, end_coding = dec("NaN"), dec("NaN")
-        start_interval, end_interval = dec("NaN"), dec("NaN")
+        start_interval, end_interval = None, None
 
     parameters = select_subj_behav.choose_obs_subj_behav_category(
         self,
@@ -373,7 +373,7 @@ def export_aggregated_events(self):
     else:
         max_media_duration_all_obs = None
         start_coding, end_coding = dec("NaN"), dec("NaN")
-        start_interval, end_interval = dec("NaN"), dec("NaN")
+        start_interval, end_interval = None, None
 
     parameters = select_subj_behav.choose_obs_subj_behav_category(
         self,
@@ -681,8 +681,10 @@ def export_events_as_textgrid(self) -> None:
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
-        start_interval=start_interval,
-        end_interval=end_interval,
+        # start_interval=start_interval,
+        # end_interval=end_interval,
+        start_interval=None,
+        end_interval=None,
         show_include_modifiers=False,
         show_exclude_non_coded_behaviors=False,
         maxTime=max_obs_length,

boris/gui_utilities.py

@@ -31,32 +31,40 @@ def save_geometry(widget: QWidget, widget_name: str):
     save window geometry in ini file
     """
 
-    try:
-        ini_file_path = pl.Path.home() / pl.Path(".boris")
-        if ini_file_path.is_file():
+    ini_file_path = pl.Path.home() / pl.Path(".boris")
+    if ini_file_path.is_file():
+        try:
             settings = QSettings(str(ini_file_path), QSettings.IniFormat)
             settings.setValue(f"{widget_name} geometry", widget.saveGeometry())
-    except Exception:
-        logging.warning(f"error during saving {widget_name} geometry")
+        except Exception:
+            logging.warning(f"error during saving {widget_name} geometry")
 
 
-def restore_geometry(widget: QWidget, widget_name: str, default_geometry):
+def restore_geometry(widget: QWidget, widget_name: str, default_width_height):
     """
     restore window geometry in ini file
     """
+    def default_resize(widget, default_width_height):
+        if default_width_height != (0, 0):
+            try:
+                widget.resize(default_width_height[0], default_width_height[1])
+            except Exception:
+                logging.warning("Error during restoring default")
+
 
+    logging.debug(f'restore geometry function for {widget_name}')
     try:
         ini_file_path = pl.Path.home() / pl.Path(".boris")
         if ini_file_path.is_file():
             settings = QSettings(str(ini_file_path), QSettings.IniFormat)
+            print(settings.value(f"{widget_name} geometry"))
             widget.restoreGeometry(settings.value(f"{widget_name} geometry"))
+            logging.debug(f'geometry restored for {widget_name}  {settings.value(f"{widget_name} geometry")}')
+        else:
+            default_resize(widget, default_width_height)
     except Exception:
         logging.warning(f"error during restoring {widget_name} geometry")
-        if default_geometry != (0, 0):
-            try:
-                widget.resize(default_geometry[0], default_geometry[1])
-            except Exception:
-                logging.warning("Error during restoring default")
+        default_resize(widget, default_width_height)
 
 
 def set_icons(self, theme_mode: str) -> None:

boris/observation_operations.py

@@ -43,9 +43,8 @@ from PySide6.QtWidgets import (
     QSlider,
     QMainWindow,
     QDockWidget,
-    QPushButton,
 )
-from PySide6.QtCore import Qt, QDateTime, QTimer, QObject, QEvent
+from PySide6.QtCore import Qt, QDateTime, QTimer
 from PySide6.QtGui import QFont, QIcon, QTextCursor
 
 from PySide6 import QtTest
@@ -365,8 +364,9 @@ def time_intervals_range(observations: dict, observations_list: list) -> Tuple[O
     for obs_id in observations_list:
         observation = observations[obs_id]
         offset = observation[cfg.TIME_OFFSET]
-        start_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][0]) + offset)
-        end_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][1]) + offset)
+        if dec(observation[cfg.OBSERVATION_TIME_INTERVAL][0]) + offset and dec(observation[cfg.OBSERVATION_TIME_INTERVAL][1]) + offset:
+            start_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][0]) + offset)
+            end_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][1]) + offset)
 
     if not start_interval_list:
         earliest_start_interval = None
@@ -376,7 +376,7 @@ def time_intervals_range(observations: dict, observations_list: list) -> Tuple[O
     if not end_interval_list:
         latest_end_interval = None
     else:
-        latest_end_interval = min([x for x in end_interval_list])
+        latest_end_interval = max([x for x in end_interval_list])
 
     return earliest_start_interval, latest_end_interval
 

boris/param_panel.py

@@ -95,7 +95,13 @@ class Param_panel(QDialog, Ui_Dialog):
             if not ((self.start_interval is None) or self.start_interval.is_nan()):
                 # Set start_time and end_time widgets values even if it is not shown with
                 # more than 1 observation as some analyses might use it (eg: advanced event filtering)
+
+                print(f"{self.end_interval=}")
+
                 end_interval = self.end_interval if self.end_interval != 0 else self.media_duration
+
+                print(f"{end_interval=}")
+
                 self.start_time.set_time(self.start_interval)
                 self.end_time.set_time(end_interval)
                 self.frm_time_interval.setEnabled(False)

boris/plugins.py

@@ -19,10 +19,19 @@ Copyright 2012-2025 Olivier Friard
   MA 02110-1301, USA.
 """
 
+import importlib
 import logging
+import numpy as np
+import pandas as pd
+from pathlib import Path
+
 from PySide6.QtGui import QAction
+from PySide6.QtWidgets import QMessageBox
+
 from . import config as cfg
-from pathlib import Path
+from . import project_functions
+from . import dialog
+from . import view_df
 
 
 def add_plugins_to_menu(self):
@@ -32,7 +41,7 @@ def add_plugins_to_menu(self):
     for plugin_name in self.config_param.get(cfg.ANALYSIS_PLUGINS, {}):
         logging.debug(f"adding plugin '{plugin_name}' to menu")
         # Create an action for each submenu option
-        action = QAction(self, triggered=self.run_plugin)
+        action = QAction(self, triggered=lambda checked=False, name=plugin_name: run_plugin(self, name))
         action.setText(plugin_name)
 
         self.menu_plugins.addAction(action)
@@ -77,3 +86,162 @@ def load_plugins(self):
                 self.config_param[cfg.ANALYSIS_PLUGINS][plugin_name] = str(file_)
 
     logging.debug(f"{self.config_param.get(cfg.ANALYSIS_PLUGINS, {})=}")
+
+
+def plugin_df_filter(df: pd.DataFrame, observations_list: list = [], parameters: dict = {}) -> pd.DataFrame:
+    """
+    filter the dataframe following parameters
+
+    filter by selected observations.
+    filter by selected subjects.
+    filter by selected behaviors.
+    filter by time interval.
+    """
+
+    # filter selected observations
+    df = df[df["Observation id"].isin(observations_list)]
+
+    if parameters:
+        # filter selected subjects
+        df = df[df["Subject"].isin(parameters["selected subjects"])]
+
+        # filter selected behaviors
+        df = df[df["Behavior"].isin(parameters["selected behaviors"])]
+
+        if parameters["time"] == "interval of observation":
+            # filter each observation with observation interval start/stop
+
+            # keep events between observation interval start time and observation interval stop/end
+            df_interval = df[
+                (
+                    ((df["Start (s)"] >= df["Observation interval start"]) & (df["Start (s)"] <= df["Observation interval stop"]))
+                    | ((df["Stop (s)"] >= df["Observation interval start"]) & (df["Stop (s)"] <= df["Observation interval stop"]))
+                )
+                | ((df["Start (s)"] < df["Observation interval start"]) & (df["Stop (s)"] > df["Observation interval stop"]))
+            ]
+
+            df_interval.loc[df["Start (s)"] < df["Observation interval start"], "Start (s)"] = df["Observation interval start"]
+            df_interval.loc[df["Stop (s)"] > df["Observation interval stop"], "Stop (s)"] = df["Observation interval stop"]
+
+            df_interval.loc[:, "Duration (s)"] = (df_interval["Stop (s)"] - df_interval["Start (s)"]).replace(0, np.nan)
+
+            df = df_interval
+
+        else:
+            # filter selected time interval
+            if parameters["start time"] is not None and parameters["end time"] is not None:
+                MIN_TIME = parameters["start time"]
+                MAX_TIME = parameters["end time"]
+
+                # keep events between start time and end_time
+                df_interval = df[
+                    (
+                        ((df["Start (s)"] >= MIN_TIME) & (df["Start (s)"] <= MAX_TIME))
+                        | ((df["Stop (s)"] >= MIN_TIME) & (df["Stop (s)"] <= MAX_TIME))
+                    )
+                    | ((df["Start (s)"] < MIN_TIME) & (df["Stop (s)"] > MAX_TIME))
+                ]
+
+                df_interval.loc[df["Start (s)"] < MIN_TIME, "Start (s)"] = MIN_TIME
+                df_interval.loc[df["Stop (s)"] > MAX_TIME, "Stop (s)"] = MAX_TIME
+
+                df_interval.loc[:, "Duration (s)"] = (df_interval["Stop (s)"] - df_interval["Start (s)"]).replace(0, np.nan)
+
+                df = df_interval
+
+    print("filtered")
+    print("=" * 50)
+
+    print(f"{df=}")
+
+    return df
+
+
+def run_plugin(self, plugin_name):
+    """
+    run plugin
+    """
+
+    if not self.project:
+        QMessageBox.warning(
+            self,
+            cfg.programName,
+            "No observations found. Open a project first",
+            QMessageBox.Ok | QMessageBox.Default,
+            QMessageBox.NoButton,
+        )
+        return
+
+    logging.debug(f"{self.config_param.get(cfg.ANALYSIS_PLUGINS, {})=}")
+
+    if plugin_name not in self.config_param.get(cfg.ANALYSIS_PLUGINS, {}):
+        QMessageBox.critical(self, cfg.programName, f"Plugin '{plugin_name}' not found")
+        return
+
+    plugin_path = self.config_param.get(cfg.ANALYSIS_PLUGINS, {})[plugin_name]
+
+    logging.debug(f"{plugin_path=}")
+
+    if not Path(plugin_path).is_file():
+        QMessageBox.critical(self, cfg.programName, f"The plugin {plugin_path} was not found.")
+        return
+
+    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__')}"
+    )
+
+    selected_observations, parameters = self.obs_param()
+    if not selected_observations:
+        return
+
+    df = project_functions.project2dataframe(self.pj, selected_observations)
+
+    """
+    logging.debug("dataframe info")
+    logging.debug(f"{df.info()}")
+    logging.debug(f"{df.head()}")
+    """
+
+    # filter the dataframe with parameters
+    filtered_df = plugin_df_filter(df, observations_list=selected_observations, parameters=parameters)
+
+    plugin_results = plugin_module.run(filtered_df)
+    # test if plugin_tests is a tuple: if not transform to tuple
+    if not isinstance(plugin_results, tuple):
+        plugin_results = tuple([plugin_results])
+
+    self.plugin_visu: list = []
+    for result in plugin_results:
+        if isinstance(result, str):
+            self.plugin_visu.append(dialog.Results_dialog())
+            self.plugin_visu[-1].setWindowTitle(plugin_name)
+            self.plugin_visu[-1].ptText.clear()
+            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[-1].show()
+        else:
+            # result is not str nor dataframe
+            QMessageBox.critical(
+                None,
+                cfg.programName,
+                (
+                    f"Plugin returns an unknown object type: {type(result)}\n\n"
+                    "Plugins must return str and/or Pandas Dataframes.\n"
+                    "Check the plugin code."
+                ),
+                QMessageBox.Ok | QMessageBox.Default,
+                QMessageBox.NoButton,
+            )

boris/project_functions.py

@@ -39,7 +39,6 @@ from . import db_functions
 from . import dialog
 from . import observation_operations
 from . import portion as I
-from . import project_functions
 from . import utilities as util
 from . import version
 
@@ -1806,9 +1805,11 @@ def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
 
     data = {
         "Observation id": [],
-        # "Observation date": [],
-        # "Description": [],
-        # "Observation type": [],
+        "Observation date": [],
+        "Description": [],
+        "Observation type": [],
+        "Observation interval start": [],
+        "Observation interval stop": [],
         # "Source": [],
         # "Time offset (s)": [],
         # "Coding duration": [],
@@ -1847,9 +1848,11 @@ def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
 
     type_ = {
         "Observation id": "string",
-        # "Observation date": "string",
-        # "Description": "string",
-        # "Observation type": "string",
+        "Observation date": "string",
+        "Description": "string",
+        "Observation type": "string",
+        "Observation interval start": "float64",
+        "Observation interval stop": "float64",
         # "Source": "string",
         # "Time offset (s)": "string",
         # "Coding duration": "float64",
@@ -1885,14 +1888,6 @@ def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
         "Comment stop": "string",
     }
 
-    """
-    state_behaviors = [
-        pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE]
-        for x in pj[cfg.ETHOGRAM]
-        if pj[cfg.ETHOGRAM][x]["type"] in (cfg.STATE_EVENT, cfg.STATE_EVENT_WITH_CODING_MAP)
-    ]
-    """
-
     state_behaviors = util.state_behavior_codes(pj[cfg.ETHOGRAM])
 
     for obs_id in pj[cfg.OBSERVATIONS]:
@@ -1904,9 +1899,21 @@ def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
             if idx_event in stop_event_idx:
                 continue
             data["Observation id"].append(obs_id)
-            # data["Observation date"].append(pj["observations"][obs_id]["date"])
-            # data["Description"].append(pj["observations"][obs_id]["description"])
-            # data["Observation type"].append(pj["observations"][obs_id]["type"])
+            data["Observation date"].append(pj["observations"][obs_id]["date"])
+            data["Description"].append(" ".join(pj["observations"][obs_id]["description"].splitlines()))
+            data["Observation type"].append(pj["observations"][obs_id]["type"])
+
+            data["Observation interval start"].append(
+                pj["observations"][obs_id]["observation time interval"][0]
+                if pj["observations"][obs_id]["observation time interval"][0]
+                else None
+            )
+            data["Observation interval stop"].append(
+                pj["observations"][obs_id]["observation time interval"][1]
+                if pj["observations"][obs_id]["observation time interval"][1]
+                else None
+            )
+
             # data["Source"].append("")
             # data["Time offset (s)"].append(pj["observations"][obs_id]["time offset"])
             # data["Coding duration"].append("")
@@ -1932,7 +1939,7 @@ def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
                     data[modifier_set].append(np.nan)
 
             data["Behavior type"].append(cfg.STATE_EVENT if event[2] in state_behaviors else cfg.POINT_EVENT)
-            data["Start (s)"].append(event[0])
+            data["Start (s)"].append(float(event[0]))
             if event[2] in state_behaviors:
                 # search stop
                 # print(f"==> {idx_event=} {event[1:4]=}")
@@ -1941,8 +1948,8 @@ def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
                     if event2[1:4] == event[1:4]:
                         # print("found")
                         stop_event_idx.add(idx_event2)
-                        data["Stop (s)"].append(event2[0])
-                        data["Duration (s)"].append(event2[0] - event[0])
+                        data["Stop (s)"].append(float(event2[0]))
+                        data["Duration (s)"].append(float(event2[0] - event[0]))
                         data["Comment start"].append(event[4])
                         data["Comment stop"].append(event2[4])
                         break
@@ -1950,9 +1957,17 @@ def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
                     raise ("not paired")
 
             else:  # point
-                data["Stop (s)"].append(event[0])
+                data["Stop (s)"].append(float(event[0]))
                 data["Duration (s)"].append(np.nan)
                 data["Comment start"].append(event[4])
                 data["Comment stop"].append(event[4])
 
+    # Set the display option to show all rows and columns
+    pd.set_option("display.max_rows", None)
+    pd.set_option("display.max_columns", None)
+
+    pd.DataFrame(data).info()
+
+    print(pd.DataFrame(data))
+
     return pd.DataFrame(data)

boris/select_subj_behav.py

@@ -123,6 +123,10 @@ def choose_obs_subj_behav_category(
             paramPanelWindow.start_time.set_time(start_coding)
             paramPanelWindow.end_time.set_time(end_coding)
 
+    # check observation time interval
+    if start_interval is None or start_interval.is_nan() or end_interval is None or end_interval.is_nan():
+        paramPanelWindow.rb_obs_interval.setEnabled(False)
+
     if selected_observations:
         observedSubjects = project_functions.extract_observed_subjects(self.pj, selected_observations)
     else:

boris/synthetic_time_budget.py

@@ -71,8 +71,10 @@ def synthetic_time_budget(self) -> None:
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
-        start_interval=start_interval,
-        end_interval=end_interval,
+        # start_interval=start_interval,
+        # end_interval=end_interval,
+        start_interval=None,
+        end_interval=None,
         maxTime=max_media_duration_all_obs,
         show_exclude_non_coded_behaviors=False,
         by_category=False,
@@ -201,8 +203,10 @@ def synthetic_binned_time_budget(self) -> None:
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
-        start_interval=start_interval,
-        end_interval=end_interval,
+        # start_interval=start_interval,
+        # end_interval=end_interval,
+        start_interval=None,
+        end_interval=None,
         maxTime=max_media_duration_all_obs,
         show_exclude_non_coded_behaviors=False,
         by_category=False,
@@ -221,7 +225,7 @@ def synthetic_binned_time_budget(self) -> None:
     # ask for excluding behaviors durations from total time
     cancel_pressed, synth_tb_param[cfg.EXCLUDED_BEHAVIORS] = self.filter_behaviors(
         title="Select behaviors to exclude",
-        text=("The duration of the selected behaviors will " "be subtracted from the total time"),
+        text=("The duration of the selected behaviors will be subtracted from the total time"),
         table="",
         behavior_type=[cfg.STATE_EVENT],
     )

boris/time_budget_widget.py

@@ -436,8 +436,10 @@ def time_budget(self, mode: str, mode2: str = "list"):
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
-        start_interval=start_interval,
-        end_interval=end_interval,
+        # start_interval=start_interval,
+        # end_interval=end_interval,
+        start_interval=None,
+        end_interval=None,
         maxTime=max_media_duration_all_obs,
         by_category=(mode == "by_category"),
         n_observations=len(selected_observations),
@@ -744,7 +746,7 @@ def time_budget(self, mode: str, mode2: str = "list"):
 
         self.tb.twTB.resizeColumnsToContents()
 
-        gui_utilities.restore_geometry(self.tb, "time budget", (0, 0))
+        gui_utilities.restore_geometry(self.tb, "time budget", (800, 600))
 
         self.tb.show()
 

boris/version.py

@@ -20,5 +20,5 @@ This file is part of BORIS.
 
 """
 
-__version__ = "9.1.1"
-__version_date__ = "2025-03-12"
+__version__ = "9.2.1"
+__version_date__ = "2025-03-17"

{boris_behav_obs-9.1.1.dist-info → boris_behav_obs-9.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: boris-behav-obs
-Version: 9.1.1
+Version: 9.2.1
 Summary: BORIS - Behavioral Observation Research Interactive Software
 Author-email: Olivier Friard <olivier.friard@unito.it>
 License:                     GNU GENERAL PUBLIC LICENSE

{boris_behav_obs-9.1.1.dist-info → boris_behav_obs-9.2.1.dist-info}/RECORD

@@ -3,9 +3,9 @@ boris/__main__.py,sha256=ANjTbXgXDoz2nB1tCtOIllfIVotCa602iebACX7rXaE,764
 boris/about.py,sha256=KEUz6nryrg8FceVyFsf8sMz-xWd2cGwIUfuVydHxqC4,5366
 boris/add_modifier.py,sha256=DWqxkKDBm21QH_kPvhpnltwLtFvPxne0VmZ1SY26hj8,26340
 boris/add_modifier_ui.py,sha256=Y7TLO5uS6zW7zpjXmjA4V_VIp_bFDNtjOTbJ9Q6m-mQ,11601
-boris/advanced_event_filtering.py,sha256=DyPHEj2QsTpkkYjBD0iMXqFYCkrMjMcmp1MOuSITtGk,15411
+boris/advanced_event_filtering.py,sha256=VlvU12mL6xYacZOvJAi5uLpHMcmAw5Pvuvmka-PN29c,15469
 boris/behav_coding_map_creator.py,sha256=PSEYMLvOwt0HR7H4kQZl6dli3q89wezWMv-Ri3EZWWc,37443
-boris/behavior_binary_table.py,sha256=SsaPrXyGXwWYPJ_4R0BlfqeV-q1n0vGNDo0HB3ZmQi8,12426
+boris/behavior_binary_table.py,sha256=sr2Wb7NFd-NjfXCL5fqsc_Uf7rvS0p9RxZwVbaFBeig,12502
 boris/behaviors_coding_map.py,sha256=Pat6U2JHxH8epWH42ZlwzZJ0Rmgl-BKQ5KARjp3GbNg,7291
 boris/boris_cli.py,sha256=n0OiVvZM1gM6E7yKaff9wlgmpAGK4TK052VRi8AabJo,13196
 boris/cmd_arguments.py,sha256=oWb-FvhKLbKJhATlTHy9muWu8XnnUfOZ-3Fmz2M8Yzc,1848
@@ -15,8 +15,8 @@ boris/config_file.py,sha256=1-2ZmTvKET57rwrLR1dXblt0AxMpGB1LAiHxu-Sy8es,13543
 boris/connections.py,sha256=y_KkIj3WQQEepJASATHBpZaqwT-ERyFNovy2Q8e7FAA,19321
 boris/converters.py,sha256=c1Jps-URoglY5ILQHz-pCCf6-4DFUHZLtqr_ofsrFg0,11722
 boris/converters_ui.py,sha256=uu7LOBV_fKv2DBdOqsqPwjGsjgONr5ODBoscAA-EP48,9900
-boris/cooccurence.py,sha256=NV3lPhzKptyYh_pSjx1a_FqwaKstqIwj46GpNcyJ4aY,10236
-boris/core.py,sha256=ncIjy9W5jDKkdmytTNGwq2qscZVlZ0tMd9bOOro_9dg,237708
+boris/cooccurence.py,sha256=tVERC-V8MWjWHlGEfDuu08iS94qjt4do-38jwI62QaY,10367
+boris/core.py,sha256=3NbJcsngnDTaLuXPWblgidKqjzZhJTxzL8N69pwgtkI,234818
 boris/core_qrc.py,sha256=T3ki5e2Pj0I0QBGz63MPUgZzl8F_VHZwSq074mRNBDU,650669
 boris/core_ui.py,sha256=SeC26uveDCjrCBLsRPuQ6FaapKfON_HIRcQStEDLhl4,76384
 boris/db_functions.py,sha256=Uw9wWH_Pe-qNzpV1k21YG_jKsoOmfY_iiK_7ARZHGDc,13352
@@ -29,11 +29,11 @@ boris/event_operations.py,sha256=ys1DxZ6iooMvvq_hzpPVZSW0dF9Trbx921XV3jeKOxw,382
 boris/events_cursor.py,sha256=VPY_ygD0fxE5lp25mcd2l00XQXurCR6hprffF4tKRbU,2078
 boris/events_snapshots.py,sha256=PjWzQvUGQtIcEc_7FDsRphf7fAhhTccQgYc2eQSA65g,27621
 boris/exclusion_matrix.py,sha256=ff88xD6aqc8bpIuj9ZCz9ju_HeqqgibQwoaJrIOJ6RI,5272
-boris/export_events.py,sha256=YoqE0vHXeDMAk28e6rewI3TODdfMr8YbJsNnJqiXv0Y,39720
+boris/export_events.py,sha256=8h6AenIuXJj-JWlkSS0UR38mhjUjmFv3_5QOyBSpYec,39744
 boris/export_observation.py,sha256=uPJH_5MXqGm4JSeaSlTikh1i6OKSyLIaZFzS9wp-9qk,50729
 boris/external_processes.py,sha256=vpmhA4Lj2GblBIrDD0YjesB8HPOgx4K9gSWVhTop4Cg,11927
 boris/geometric_measurement.py,sha256=4pI-AYpBSFlJBqS-f8dnkgLtj_Z2E5kwwAdh6WwZ4kk,35049
-boris/gui_utilities.py,sha256=402qypJ44JkcZ1PDeV79j8Z9faQ473TzEkjjO-scBz0,4170
+boris/gui_utilities.py,sha256=5vjIWbUOHFbqKSti-kT0GoteBBEQ5fUYdNGdMxcg_0A,4607
 boris/image_overlay.py,sha256=zZAL8MTt2i2s58CuX81Nym3rJ5pKiTeP4AO8WbIUonM,2527
 boris/import_observations.py,sha256=hwEPIag741AXTFIuxDdZLDvLrsmvaqTkjyTjQu5M_RA,8798
 boris/irr.py,sha256=o5QN3B2b-02AUkrklMJCitFGsfiUDtmI0MxUbPv2cBg,22472
@@ -47,11 +47,11 @@ boris/mpv-1.0.3.py,sha256=EXRtzQqFjOn4wMC6482Ilq3fNQ9N1GRP1VxwLzdeaBY,88077
 boris/mpv.py,sha256=EfzIHjPbgewG4w3smEtqEUPZoVwYmMQkL4Q8ZyW-a58,76410
 boris/mpv2.py,sha256=IUI4t4r9GYX7G5OXTjd3RhMMOkDdfal_15buBgksLsk,92152
 boris/observation.py,sha256=oop08nflDLZAgDbIB8GOiVdTgLhppJ_ODH0Z24cyqvE,57176
-boris/observation_operations.py,sha256=w295Vlj6qparn7xcdh1tkwgXXx2QTnq9J6KUJGh1zvg,105533
+boris/observation_operations.py,sha256=8rVC_iWb0Y8zkd64_XvDxD2e7_jsKdGfDSdyi4eDRAs,105643
 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
-boris/param_panel.py,sha256=Sna2SlJt1CSUEE_bNX2X6ibFjs2Um0-ZjtQf5-JlJTc,8693
+boris/param_panel.py,sha256=G0XzNmJIX89-n2OQTDccuY_wWMhr3p7GB4ZorbU6EWc,8786
 boris/param_panel_ui.py,sha256=4emQDFmuL4_R7bKxosLjdUb-VSPWkDm7suy38F5EKcA,13260
 boris/player_dock_widget.py,sha256=VBuuGoAb2D027oFnMBlIQPiSQcEdedhoQltNFSJq8mw,5982
 boris/plot_data_module.py,sha256=6QbLKfyGp4TYRyHnB9G45y5XrpeXLytcorltEAWfYak,16562
@@ -59,26 +59,26 @@ boris/plot_events.py,sha256=hA_Yt-ZaxbAOKjN7gYHiaEx5TPR-7HIWGJXXg4cq6lw,24048
 boris/plot_events_rt.py,sha256=xig__Uea3mQqO5raMBVB3pm3vuQkjAbJpwSS7AwIob8,8327
 boris/plot_spectrogram_rt.py,sha256=JV8N7T8133wGVhlPxmgOb426u1g1p21-LbTqgaeddkk,8361
 boris/plot_waveform_rt.py,sha256=05JN_6HCq674ROore_6PNw93GQNZJQDlDxp2ODAFkkA,7474
-boris/plugins.py,sha256=2RyrS3fdJ2lA8FhG_qymDCfaFyzK3TaRy2ll3yHjlz4,2817
+boris/plugins.py,sha256=RtC_Ew6VxAwWQqRuKQj9FgpsSBGoZmZuCZ5gPj0EiwI,8963
 boris/preferences.py,sha256=qPfd9Tyg7u30kXwVqMOgkdy2RXri9bItRa5U2-ZVQmg,16847
 boris/preferences_ui.py,sha256=D2bFLb3E0m6IwSeqKoItRDiqvPmJGoeXLHF2K02n1Zo,26293
 boris/project.py,sha256=hAeAb5pD0u_l0bezU9ePvbTOYQKfxrFGvYB2NAqSDHg,84377
-boris/project_functions.py,sha256=Bu-HD58uYL__v2ih5OhQnVF22_lPrnvX3LCw4wheC1I,79251
+boris/project_functions.py,sha256=p_CC2UoFEbb0PpKt9c5MtJulSszz-fV1o1sgFRFVQEk,79920
 boris/project_import_export.py,sha256=1FdsYFzZ_jrhPRaH7xEkcPnh-hQXN4HFz1PhsIsSoL8,38361
 boris/project_ui.py,sha256=yB-ewhHt8S8DTTRIk-dNK2tPMNU24lNji9fDW_Xazu8,38805
 boris/qrc_boris.py,sha256=aH-qUirYY1CGxmTK1SFCPvuZfazIHX4DdUKF1gxZeYM,675008
 boris/qrc_boris5.py,sha256=prnOw7VGXWXRuVCYp_yIrmWhrlG1F9rx-3BQvkPenjY,161608
 boris/select_modifiers.py,sha256=42uG9F75pfPoPJ-blp-vFgmpBpVJtL42FlIxpNpq9z4,13319
 boris/select_observations.py,sha256=HM0suMes1YxVwQ-Xakw7ROaxbN0EyeSiZFZNrTQIHAA,7886
-boris/select_subj_behav.py,sha256=5ln2e83nVEcMW1TTeOE5K1gqd4lSvh7LeiSfhloZPrU,11537
+boris/select_subj_behav.py,sha256=ulXbsRY-AIyQRSwXhVlvkNRS_eqWaCvkDKTTyOLqvoE,11742
 boris/state_events.py,sha256=R5CcT_cldnxqhQkvX_V1AMNxH0Nc6jLzMZYiWkeJwAE,7770
 boris/subjects_pad.py,sha256=lSRRGfLfD10_YpGua8RGVdKhoXlsXawGhNibPkRhuzM,3541
-boris/synthetic_time_budget.py,sha256=NwJt6TO6XZwxF2s7ETvqiDEqrz9ad30g1sQ0bVBsN9o,10364
+boris/synthetic_time_budget.py,sha256=sj-5jq7MH-bxPUwKwpi7Xud-jkKTs6PUFlN_01vgimE,10481
 boris/time_budget_functions.py,sha256=1-7_G84SDs7rp1EWr5zHInzRVDUkUdIfm_AX0516ceQ,52539
-boris/time_budget_widget.py,sha256=_yYzLa6aJRWHRataek_ciXMEKGW75HA9y0auhAJwzbA,43137
+boris/time_budget_widget.py,sha256=H_HQHTuMq7U6PlGjJ-pZO4dDaOrYSsAKK697Gb6EQoI,43201
 boris/transitions.py,sha256=_aZJfJWv3EBrtmQ7qsdTCayQo6uWU7BXqtQQgflEhr4,12250
 boris/utilities.py,sha256=zwWpH-lozAUj_8K6Gf2Hl-BSW0aRdWo37HGXTWQ86qk,52782
-boris/version.py,sha256=MwBl656ww2Munfb847fzP6VQ6OX5HrRbTL8ngrLBaS8,787
+boris/version.py,sha256=_3fXAvcL2OmwfUOC38JcxwXIb6rqJr_VIPrGA2HMk1k,787
 boris/video_equalizer.py,sha256=FartoGghFK-T53zklP70rPKYqTuzL8qdvfGlsOF2wwc,5854
 boris/video_equalizer_ui.py,sha256=1CG3s79eM4JAbaCx3i1ILZXLceb41_gGXlOLNfpBgnw,10142
 boris/video_operations.py,sha256=mh3iR__Sm2KnV44L_sW2pOo3AgLwlM7wiTnnqQiAVs4,9381
@@ -86,18 +86,18 @@ boris/view_df.py,sha256=AKScLASX2Uatw7rqPbsnio83eVT4GZYCFhL091eMvlY,3370
 boris/view_df_ui.py,sha256=CaMeRH_vQ00CTDDFQn73ZZaS-r8BSTWpL-dMCFqzJ_Q,2775
 boris/write_event.py,sha256=jKZWzvDvQ-wwFvTLjA-zUjtXQCWwVC49Y5g-1UctpYw,23821
 boris/analysis_plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-boris/analysis_plugins/number_of_occurences.py,sha256=U0NuU8leQixwDWlH26FsQmZl-wrvWKxNH_CWAWb8us4,1972
-boris/analysis_plugins/number_of_occurences_by_independent_variable.py,sha256=fkyOuc1AiOSnrz7L6Ocd742XmDHhhQEtgi2KSiTOG4c,2252
-boris/analysis_plugins/time_budget.py,sha256=_eNv_9oxwa-L6pZVyATc8YNnsmUj_3Px2F0F3Y603p0,3547
+boris/analysis_plugins/number_of_occurences.py,sha256=IDyDrdezqvSKT3BlD8QWpSYk8X9nnBBLI80OUnFJ3bY,509
+boris/analysis_plugins/number_of_occurences_by_independent_variable.py,sha256=t39bmmmZIDCSbcDvVeiKAhKNNP2SdpHp417JczHEnP4,793
+boris/analysis_plugins/time_budget.py,sha256=C1wNYwd5Jugr8h5z2aXRUBY8dF8pD4n953dPwNHY5VY,2244
 boris/portion/__init__.py,sha256=ZBUG4I7YWhRkeWdP-JEpxhxldJlUYQkeaJseTjdhtJE,602
 boris/portion/const.py,sha256=hEp26BKcEg1Js4DfZsBHmDtJJts83Tl1HWQ0CNJNwEc,1588
 boris/portion/dict.py,sha256=SyHxc7PfDw2ufNLFQycwJtzmRfL48rDp4UrM2KN7IWc,11282
 boris/portion/func.py,sha256=3TkQtFKLfsqntwd27HSGHceFhnXHmT-EbNMqktElC5Q,2174
 boris/portion/interval.py,sha256=bAdUiJjGeUAPgsBAImwNeviiwfQq5odfhFZccAWzOTA,20299
 boris/portion/io.py,sha256=ppNeRpiLNrocF1yzGeuEUIhYMf2LfsR-cji3d0nmvUs,6371
-boris_behav_obs-9.1.1.dist-info/LICENSE.TXT,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
-boris_behav_obs-9.1.1.dist-info/METADATA,sha256=zuFFmX5VePSe15dz0kKJdQR-TulX0i47xsTTwUkEnLw,42102
-boris_behav_obs-9.1.1.dist-info/WHEEL,sha256=SrDKpSbFN1G94qcmBqS9nyHcDMp9cUS9OC06hC0G3G0,109
-boris_behav_obs-9.1.1.dist-info/entry_points.txt,sha256=-Vl37ZFjZYK5wTSDf5LAzd2cVLON1Pfy1xkx490Wxak,47
-boris_behav_obs-9.1.1.dist-info/top_level.txt,sha256=fJSgm62S7WesiwTorGbOO4nNN0yzgZ3klgfGi3Px4qI,6
-boris_behav_obs-9.1.1.dist-info/RECORD,,
+boris_behav_obs-9.2.1.dist-info/LICENSE.TXT,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
+boris_behav_obs-9.2.1.dist-info/METADATA,sha256=6dLb1vMMq5FHHeDTBpefrr6TIQjgg1pz_VoSMKqA_GE,42102
+boris_behav_obs-9.2.1.dist-info/WHEEL,sha256=Kol19cahXavY536r5Aj6aAgK_6CmctrOu3bgNJMSNJA,109
+boris_behav_obs-9.2.1.dist-info/entry_points.txt,sha256=-Vl37ZFjZYK5wTSDf5LAzd2cVLON1Pfy1xkx490Wxak,47
+boris_behav_obs-9.2.1.dist-info/top_level.txt,sha256=fJSgm62S7WesiwTorGbOO4nNN0yzgZ3klgfGi3Px4qI,6
+boris_behav_obs-9.2.1.dist-info/RECORD,,

{boris_behav_obs-9.1.1.dist-info → boris_behav_obs-9.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any