boris-behav-obs 9.1.1__tar.gz → 9.2.1__tar.gz

{boris_behav_obs-9.1.1 → boris_behav_obs-9.2.1}/PKG-INFO

@@ -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 → boris_behav_obs-9.2.1}/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_behav_obs-9.2.1/boris/analysis_plugins/number_of_occurences.py

@@ -0,0 +1,22 @@
+"""
+BORIS plugin
+
+number of occurences of behaviors
+"""
+
+import pandas as pd
+
+__version__ = "0.3.0"
+__version_date__ = "2025-03-17"
+__plugin_name__ = "Number of occurences of behaviors"
+__author__ = "Olivier Friard - University of Torino - Italy"
+
+
+def run(df: pd.DataFrame):
+    """
+    Calculate the number of occurrences of behaviors by subject.
+    """
+
+    df_results: pd.DataFrame = df.groupby(["Subject", "Behavior"])["Behavior"].count().reset_index(name="number of occurences")
+
+    return df_results

boris_behav_obs-9.2.1/boris/analysis_plugins/number_of_occurences_by_independent_variable.py

@@ -0,0 +1,34 @@
+"""
+BORIS plugin
+
+number of occurences of behaviors by independent_variable
+"""
+
+import pandas as pd
+
+__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"
+
+
+def run(df: pd.DataFrame):
+    """
+    Calculate the number of occurrences of behaviors by subject and by independent_variable.
+
+    This plugin returns a Pandas dataframe
+    """
+
+    df_results: df.DataFrame = (
+        df.groupby(
+            [
+                "independent variable 'Weather'",
+                "Subject",
+                "Behavior",
+            ]
+        )["Behavior"]
+        .count()
+        .reset_index(name="number of occurences")
+    )
+
+    return df_results

{boris_behav_obs-9.1.1 → boris_behav_obs-9.2.1}/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_behav_obs-9.1.1 → boris_behav_obs-9.2.1}/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_behav_obs-9.1.1 → boris_behav_obs-9.2.1}/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_behav_obs-9.1.1 → boris_behav_obs-9.2.1}/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_behav_obs-9.1.1 → boris_behav_obs-9.2.1}/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_behav_obs-9.1.1 → boris_behav_obs-9.2.1}/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_behav_obs-9.1.1 → boris_behav_obs-9.2.1}/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_behav_obs-9.1.1 → boris_behav_obs-9.2.1}/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)