boris-behav-obs 9.1__tar.gz → 9.2__tar.gz

{boris_behav_obs-9.1 → boris_behav_obs-9.2}/PKG-INFO

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

boris_behav_obs-9.2/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/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 → boris_behav_obs-9.2}/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 → boris_behav_obs-9.2}/boris/connections.py

@@ -160,7 +160,9 @@ def connections(self):
     self.actionAll_transitions.triggered.connect(lambda: transitions.transitions_matrix(self, "frequency"))
     self.actionNumber_of_transitions.triggered.connect(lambda: transitions.transitions_matrix(self, "number"))
 
-    self.actionFrequencies_of_transitions_after_behaviors.triggered.connect(lambda: self.transitions_matrix("frequencies_after_behaviors"))
+    self.actionFrequencies_of_transitions_after_behaviors.triggered.connect(
+        lambda: transitions.transitions_matrix(self, "frequencies_after_behaviors")
+    )
 
     # menu playback
     self.actionJumpTo.triggered.connect(self.jump_to)

{boris_behav_obs-9.1 → boris_behav_obs-9.2}/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(
@@ -113,7 +114,7 @@ def get_cooccurence(self):
             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 → boris_behav_obs-9.2}/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")
@@ -5762,6 +5759,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 +5786,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 +5809,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 +5818,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 → boris_behav_obs-9.2}/boris/dialog.py

@@ -20,15 +20,16 @@ This file is part of BORIS.
 
 """
 
+from decimal import Decimal as dec
+from typing import Union
+import datetime as dt
 import logging
-import sys
+import math
 import pathlib as pl
-import traceback
 import platform
-import datetime as dt
 import subprocess
-from decimal import Decimal as dec
-from typing import Union
+import sys
+import traceback
 
 from PySide6.QtCore import Qt, Signal, qVersion, QRect, QTime, QDateTime, QSize
 from PySide6.QtWidgets import (
@@ -409,6 +410,9 @@ class get_time_widget(QWidget):
         set time on time widget
         """
 
+        if math.isnan(new_time):
+            return
+
         self.pb_sign.setText("-" if new_time < 0 else "+")
 
         # seconds

{boris_behav_obs-9.1 → boris_behav_obs-9.2}/boris/edit_event.py

@@ -21,6 +21,7 @@ This file is part of BORIS.
 """
 
 from decimal import Decimal as dec
+import math
 
 from PySide6.QtWidgets import (
     QDialog,
@@ -67,14 +68,7 @@ class DlgEditEvent(QDialog, Ui_Form):
             for w in (self.lb_frame_idx, self.sb_frame_idx, self.cb_set_frame_idx_na):
                 w.setVisible(False)
 
-        if (observation_type in (cfg.LIVE, cfg.MEDIA)) or (observation_type == cfg.IMAGES and self.time_value != cfg.NA):
-            # self.time_widget = duration_widget.Duration_widget(self.time_value)
-            # if time_format == cfg.S:
-            #    self.time_widget.set_format_s()
-            # if time_format == cfg.HHMMSS:
-            #    self.time_widget.set_format_hhmmss()
-
-            # future time widget
+        if (observation_type in (cfg.LIVE, cfg.MEDIA)) or (observation_type == cfg.IMAGES and not math.isnan(self.time_value)):
             self.time_widget = dialog.get_time_widget(self.time_value)
 
             if time_format == cfg.S:
@@ -87,6 +81,7 @@ class DlgEditEvent(QDialog, Ui_Form):
             self.horizontalLayout_2.insertWidget(0, self.time_widget)
 
         if observation_type == cfg.IMAGES:
+            self.time_widget = dialog.get_time_widget(self.time_value)
             # hide frame index widgets
             for w in (self.lb_frame_idx, self.sb_frame_idx, self.cb_set_frame_idx_na, self.pb_set_to_current_time):
                 w.setVisible(False)

{boris_behav_obs-9.1 → boris_behav_obs-9.2}/boris/event_operations.py

@@ -78,10 +78,13 @@ def add_event(self):
     )
     editWindow.setWindowTitle("Add a new event")
 
-    sortedSubjects = [""] + sorted([self.pj[cfg.SUBJECTS][x][cfg.SUBJECT_NAME] for x in self.pj[cfg.SUBJECTS]])
+    sortedSubjects = [cfg.NO_FOCAL_SUBJECT] + sorted([self.pj[cfg.SUBJECTS][x][cfg.SUBJECT_NAME] for x in self.pj[cfg.SUBJECTS]])
+
+    print(f"{sortedSubjects=}")
 
     editWindow.cobSubject.addItems(sortedSubjects)
-    editWindow.cobSubject.setCurrentIndex(editWindow.cobSubject.findText(self.currentSubject, Qt.MatchFixedString))
+    if self.currentSubject:
+        editWindow.cobSubject.setCurrentIndex(editWindow.cobSubject.findText(self.currentSubject, Qt.MatchFixedString))
 
     sortedCodes = sorted([self.pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in self.pj[cfg.ETHOGRAM]])
 
@@ -103,7 +106,9 @@ def add_event(self):
                 if self.pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] == editWindow.cobCode.currentText():
                     event = self.full_event(idx)
 
-                    event[cfg.SUBJECT] = editWindow.cobSubject.currentText()
+                    event[cfg.SUBJECT] = (
+                        "" if editWindow.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else editWindow.cobSubject.currentText()
+                    )
                     if editWindow.leComment.toPlainText():
                         event[cfg.COMMENT] = editWindow.leComment.toPlainText()
 
@@ -152,7 +157,9 @@ def add_event(self):
                 if self.pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] == editWindow.cobCode.currentText():
                     event = self.full_event(idx)
 
-                    event[cfg.SUBJECT] = editWindow.cobSubject.currentText()
+                    event[cfg.SUBJECT] = (
+                        "" if editWindow.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else editWindow.cobSubject.currentText()
+                    )
                     if editWindow.leComment.toPlainText():
                         event[cfg.COMMENT] = editWindow.leComment.toPlainText()
 
@@ -684,10 +691,9 @@ def edit_event(self):
                     if self.pj[cfg.ETHOGRAM][key][cfg.BEHAVIOR_CODE] == edit_window.cobCode.currentText():
                         event = self.full_event(key)
                         # subject
-                        if edit_window.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT:
-                            event[cfg.SUBJECT] = ""
-                        else:
-                            event[cfg.SUBJECT] = edit_window.cobSubject.currentText()
+                        event[cfg.SUBJECT] = (
+                            "" if edit_window.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else edit_window.cobSubject.currentText()
+                        )
 
                         event[cfg.COMMENT] = edit_window.leComment.toPlainText()
 
@@ -746,7 +752,9 @@ def edit_event(self):
                         else:
                             event[cfg.TIME] = edit_window.time_widget.get_time()
 
-                        event[cfg.SUBJECT] = edit_window.cobSubject.currentText()
+                        event[cfg.SUBJECT] = (
+                            "" if edit_window.cobSubject.currentText() == cfg.NO_FOCAL_SUBJECT else edit_window.cobSubject.currentText()
+                        )
                         event[cfg.COMMENT] = edit_window.leComment.toPlainText()
                         event["row"] = pj_event_idx
                         event["original_modifiers"] = self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][pj_event_idx][

{boris_behav_obs-9.1 → boris_behav_obs-9.2}/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 → boris_behav_obs-9.2}/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)