boris-behav-obs 8.27.9__tar.gz → 9.0.1__tar.gz

{boris_behav_obs-8.27.9/boris_behav_obs.egg-info → boris_behav_obs-9.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: boris-behav-obs
-Version: 8.27.9
+Version: 9.0.1
 Summary: BORIS - Behavioral Observation Research Interactive Software
 Author-email: Olivier Friard <olivier.friard@unito.it>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -701,8 +701,9 @@ Requires-Dist: numpy>=1.26.4
 Requires-Dist: matplotlib>=3.3.3
 Requires-Dist: pandas>=2.2.2
 Requires-Dist: tablib[cli,html,ods,pandas,xls,xlsx]>=3
-Requires-Dist: pyqt5>=5.15
 Requires-Dist: pyreadr
+Requires-Dist: pyside6==6.8.0.2
+Requires-Dist: hachoir>=3.3.0
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: ruff; extra == "dev"

{boris_behav_obs-8.27.9 → boris_behav_obs-9.0.1}/boris/about.py

@@ -31,9 +31,9 @@ from . import config as cfg
 from . import utilities as util
 
 
-from PyQt5.QtCore import QT_VERSION_STR, PYQT_VERSION_STR
-from PyQt5.QtGui import QPixmap
-from PyQt5.QtWidgets import QMessageBox
+from PySide6.QtCore import qVersion
+from PySide6.QtGui import QPixmap
+from PySide6.QtWidgets import QMessageBox
 
 
 def actionAbout_activated(self):
@@ -41,6 +41,8 @@ def actionAbout_activated(self):
     About dialog
     """
 
+    import PySide6
+
     programs_versions: list = ["MPV media player"]
 
     mpv_lib_version, mpv_lib_file_path, mpv_api_version = util.mpv_lib_version()
@@ -112,7 +114,7 @@ def actionAbout_activated(self):
         f"Operating system: {current_system.system} {current_system.release} {current_system.version} \n"
         f"CPU: {current_system.machine} {current_system.processor}\n\n"
         f"Python {platform.python_version()} ({'64-bit' if sys.maxsize > 2**32 else '32-bit'})"
-        f" - Qt {QT_VERSION_STR} - PyQt {PYQT_VERSION_STR}\n\n"
+        f"Qt {qVersion()} - PySide {PySide6.__version__}\n"
     )
 
     r, memory = util.mem_info()
@@ -137,4 +139,4 @@ def actionAbout_activated(self):
 
     about_dialog.setDetailedText(details)
 
-    _ = about_dialog.exec_()
+    _ = about_dialog.exec()

{boris_behav_obs-8.27.9 → boris_behav_obs-9.0.1}/boris/add_modifier.py

@@ -16,15 +16,15 @@ This file is part of BORIS.
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
-  along with this program; if not see <http://www.gnu.org/licenses/>.
+  along with this program; if not see <http://www.gnu.org/licPbehav_enses/>.
 
 """
 
 import logging
 import json
 
-from PyQt5.QtGui import QIcon
-from PyQt5.QtWidgets import QDialog, QWidget, QFileDialog, QMessageBox
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QDialog, QWidget, QFileDialog, QMessageBox
 
 from . import dialog
 from .add_modifier_ui import Ui_Dialog
@@ -158,38 +158,38 @@ class addModifierDialog(QDialog, Ui_Dialog):
         add modifiers from file
         """
 
-        fn = QFileDialog().getOpenFileName(self, "Load modifiers from file", "", "All files (*)")
-        file_name = fn[0] if type(fn) is tuple else fn
-        if file_name:
-            try:
-                with open(file_name) as f_in:
-                    for line in f_in:
-                        if line.strip():
-                            for c in cfg.CHAR_FORBIDDEN_IN_MODIFIERS:
-                                if c in line.strip():
-                                    QMessageBox.critical(
-                                        self,
-                                        cfg.programName,
-                                        (
-                                            f"The character <b>{c}</b> is not allowed.<br>"
-                                            "The following characters are not allowed in modifiers:<br>"
-                                            f"<b>{cfg.CHAR_FORBIDDEN_IN_MODIFIERS}</b>"
-                                        ),
-                                    )
-                                    break
-                            else:
-                                if line.strip() not in [self.lwModifiers.item(x).text() for x in range(self.lwModifiers.count())]:
-                                    if self.itemPositionMem != -1:
-                                        self.lwModifiers.insertItem(self.itemPositionMem, line.strip())
-                                    else:
-                                        self.lwModifiers.addItem(line.strip())
-
-                self.modifiers_sets_dict[str(self.tabWidgetModifiersSets.currentIndex())]["values"] = [
-                    self.lwModifiers.item(x).text() for x in range(self.lwModifiers.count())
-                ]
-            except Exception:
-                QMessageBox.warning(self, cfg.programName, f"Error reading modifiers from file:<br>{file_name}")
-                logging.warning(f"Error reading modifiers from file<br>{file_name}")
+        file_name, _ = QFileDialog.getOpenFileName(self, "Load modifiers from file", "", "All files (*)")
+        if not file_name:
+            return
+        try:
+            with open(file_name) as f_in:
+                for line in f_in:
+                    if line.strip():
+                        for c in cfg.CHAR_FORBIDDEN_IN_MODIFIERS:
+                            if c in line.strip():
+                                QMessageBox.critical(
+                                    self,
+                                    cfg.programName,
+                                    (
+                                        f"The character <b>{c}</b> is not allowed.<br>"
+                                        "The following characters are not allowed in modifiers:<br>"
+                                        f"<b>{cfg.CHAR_FORBIDDEN_IN_MODIFIERS}</b>"
+                                    ),
+                                )
+                                break
+                        else:
+                            if line.strip() not in [self.lwModifiers.item(x).text() for x in range(self.lwModifiers.count())]:
+                                if self.itemPositionMem != -1:
+                                    self.lwModifiers.insertItem(self.itemPositionMem, line.strip())
+                                else:
+                                    self.lwModifiers.addItem(line.strip())
+
+            self.modifiers_sets_dict[str(self.tabWidgetModifiersSets.currentIndex())]["values"] = [
+                self.lwModifiers.item(x).text() for x in range(self.lwModifiers.count())
+            ]
+        except Exception:
+            QMessageBox.warning(self, cfg.programName, f"Error reading modifiers from file:<br>{file_name}")
+            logging.warning(f"Error reading modifiers from file<br>{file_name}")
 
     def sort_modifiers(self):
         """

boris_behav_obs-9.0.1/boris/add_modifier_ui.py

@@ -0,0 +1,285 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+## Form generated from reading UI file 'add_modifier.ui'
+##
+## Created by: Qt User Interface Compiler version 6.8.0
+##
+## WARNING! All changes made in this file will be lost when recompiling UI file!
+################################################################################
+
+from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
+    QMetaObject, QObject, QPoint, QRect,
+    QSize, QTime, QUrl, Qt)
+from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
+    QFont, QFontDatabase, QGradient, QIcon,
+    QImage, QKeySequence, QLinearGradient, QPainter,
+    QPalette, QPixmap, QRadialGradient, QTransform)
+from PySide6.QtWidgets import (QApplication, QCheckBox, QComboBox, QDialog,
+    QHBoxLayout, QLabel, QLineEdit, QListWidget,
+    QListWidgetItem, QPushButton, QSizePolicy, QSpacerItem,
+    QTabWidget, QVBoxLayout, QWidget)
+
+class Ui_Dialog(object):
+    def setupUi(self, Dialog):
+        if not Dialog.objectName():
+            Dialog.setObjectName(u"Dialog")
+        Dialog.resize(1088, 654)
+        self.verticalLayout_5 = QVBoxLayout(Dialog)
+        self.verticalLayout_5.setObjectName(u"verticalLayout_5")
+        self.cb_ask_at_stop = QCheckBox(Dialog)
+        self.cb_ask_at_stop.setObjectName(u"cb_ask_at_stop")
+
+        self.verticalLayout_5.addWidget(self.cb_ask_at_stop)
+
+        self.verticalLayout_4 = QVBoxLayout()
+        self.verticalLayout_4.setObjectName(u"verticalLayout_4")
+        self.horizontalLayout_5 = QHBoxLayout()
+        self.horizontalLayout_5.setObjectName(u"horizontalLayout_5")
+        self.verticalLayout_2 = QVBoxLayout()
+        self.verticalLayout_2.setObjectName(u"verticalLayout_2")
+        self.lbModifier = QLabel(Dialog)
+        self.lbModifier.setObjectName(u"lbModifier")
+
+        self.verticalLayout_2.addWidget(self.lbModifier)
+
+        self.leModifier = QLineEdit(Dialog)
+        self.leModifier.setObjectName(u"leModifier")
+
+        self.verticalLayout_2.addWidget(self.leModifier)
+
+        self.lbCode = QLabel(Dialog)
+        self.lbCode.setObjectName(u"lbCode")
+
+        self.verticalLayout_2.addWidget(self.lbCode)
+
+        self.leCode = QLineEdit(Dialog)
+        self.leCode.setObjectName(u"leCode")
+
+        self.verticalLayout_2.addWidget(self.leCode)
+
+        self.lbCodeHelp = QLabel(Dialog)
+        self.lbCodeHelp.setObjectName(u"lbCodeHelp")
+        self.lbCodeHelp.setWordWrap(True)
+
+        self.verticalLayout_2.addWidget(self.lbCodeHelp)
+
+        self.verticalSpacer = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+
+        self.verticalLayout_2.addItem(self.verticalSpacer)
+
+
+        self.horizontalLayout_5.addLayout(self.verticalLayout_2)
+
+        self.verticalLayout_3 = QVBoxLayout()
+        self.verticalLayout_3.setObjectName(u"verticalLayout_3")
+        self.pbAddModifier = QPushButton(Dialog)
+        self.pbAddModifier.setObjectName(u"pbAddModifier")
+
+        self.verticalLayout_3.addWidget(self.pbAddModifier)
+
+        self.pbModifyModifier = QPushButton(Dialog)
+        self.pbModifyModifier.setObjectName(u"pbModifyModifier")
+
+        self.verticalLayout_3.addWidget(self.pbModifyModifier)
+
+        self.verticalSpacer_2 = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+
+        self.verticalLayout_3.addItem(self.verticalSpacer_2)
+
+
+        self.horizontalLayout_5.addLayout(self.verticalLayout_3)
+
+        self.verticalLayout = QVBoxLayout()
+        self.verticalLayout.setObjectName(u"verticalLayout")
+        self.tabWidgetModifiersSets = QTabWidget(Dialog)
+        self.tabWidgetModifiersSets.setObjectName(u"tabWidgetModifiersSets")
+        self.tabWidgetModifiersSets.setMaximumSize(QSize(16777215, 30))
+        self.tabWidgetModifiersSets.setTabPosition(QTabWidget.North)
+        self.tabWidgetModifiersSets.setTabShape(QTabWidget.Rounded)
+        self.tabWidgetModifiersSets.setElideMode(Qt.ElideNone)
+        self.tabWidgetModifiersSets.setDocumentMode(True)
+
+        self.verticalLayout.addWidget(self.tabWidgetModifiersSets)
+
+        self.lb_name = QLabel(Dialog)
+        self.lb_name.setObjectName(u"lb_name")
+
+        self.verticalLayout.addWidget(self.lb_name)
+
+        self.le_name = QLineEdit(Dialog)
+        self.le_name.setObjectName(u"le_name")
+
+        self.verticalLayout.addWidget(self.le_name)
+
+        self.lb_description = QLabel(Dialog)
+        self.lb_description.setObjectName(u"lb_description")
+
+        self.verticalLayout.addWidget(self.lb_description)
+
+        self.le_description = QLineEdit(Dialog)
+        self.le_description.setObjectName(u"le_description")
+
+        self.verticalLayout.addWidget(self.le_description)
+
+        self.lbType = QLabel(Dialog)
+        self.lbType.setObjectName(u"lbType")
+
+        self.verticalLayout.addWidget(self.lbType)
+
+        self.cbType = QComboBox(Dialog)
+        self.cbType.addItem("")
+        self.cbType.addItem("")
+        self.cbType.addItem("")
+        self.cbType.addItem("")
+        self.cbType.setObjectName(u"cbType")
+
+        self.verticalLayout.addWidget(self.cbType)
+
+        self.lbValues = QLabel(Dialog)
+        self.lbValues.setObjectName(u"lbValues")
+
+        self.verticalLayout.addWidget(self.lbValues)
+
+        self.lwModifiers = QListWidget(Dialog)
+        self.lwModifiers.setObjectName(u"lwModifiers")
+
+        self.verticalLayout.addWidget(self.lwModifiers)
+
+        self.horizontalLayout = QHBoxLayout()
+        self.horizontalLayout.setObjectName(u"horizontalLayout")
+        self.pbMoveUp = QPushButton(Dialog)
+        self.pbMoveUp.setObjectName(u"pbMoveUp")
+
+        self.horizontalLayout.addWidget(self.pbMoveUp)
+
+        self.pbMoveDown = QPushButton(Dialog)
+        self.pbMoveDown.setObjectName(u"pbMoveDown")
+
+        self.horizontalLayout.addWidget(self.pbMoveDown)
+
+        self.pbRemoveModifier = QPushButton(Dialog)
+        self.pbRemoveModifier.setObjectName(u"pbRemoveModifier")
+
+        self.horizontalLayout.addWidget(self.pbRemoveModifier)
+
+
+        self.verticalLayout.addLayout(self.horizontalLayout)
+
+        self.pb_sort_modifiers = QPushButton(Dialog)
+        self.pb_sort_modifiers.setObjectName(u"pb_sort_modifiers")
+
+        self.verticalLayout.addWidget(self.pb_sort_modifiers)
+
+        self.horizontalLayout_3 = QHBoxLayout()
+        self.horizontalLayout_3.setObjectName(u"horizontalLayout_3")
+        self.pbAddSet = QPushButton(Dialog)
+        self.pbAddSet.setObjectName(u"pbAddSet")
+
+        self.horizontalLayout_3.addWidget(self.pbAddSet)
+
+        self.pbRemoveSet = QPushButton(Dialog)
+        self.pbRemoveSet.setObjectName(u"pbRemoveSet")
+
+        self.horizontalLayout_3.addWidget(self.pbRemoveSet)
+
+
+        self.verticalLayout.addLayout(self.horizontalLayout_3)
+
+        self.horizontalLayout_4 = QHBoxLayout()
+        self.horizontalLayout_4.setObjectName(u"horizontalLayout_4")
+        self.pbMoveSetLeft = QPushButton(Dialog)
+        self.pbMoveSetLeft.setObjectName(u"pbMoveSetLeft")
+
+        self.horizontalLayout_4.addWidget(self.pbMoveSetLeft)
+
+        self.pbMoveSetRight = QPushButton(Dialog)
+        self.pbMoveSetRight.setObjectName(u"pbMoveSetRight")
+
+        self.horizontalLayout_4.addWidget(self.pbMoveSetRight)
+
+
+        self.verticalLayout.addLayout(self.horizontalLayout_4)
+
+        self.pb_add_subjects = QPushButton(Dialog)
+        self.pb_add_subjects.setObjectName(u"pb_add_subjects")
+
+        self.verticalLayout.addWidget(self.pb_add_subjects)
+
+        self.pb_load_file = QPushButton(Dialog)
+        self.pb_load_file.setObjectName(u"pb_load_file")
+
+        self.verticalLayout.addWidget(self.pb_load_file)
+
+        self.verticalSpacer_3 = QSpacerItem(20, 40, QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Expanding)
+
+        self.verticalLayout.addItem(self.verticalSpacer_3)
+
+
+        self.horizontalLayout_5.addLayout(self.verticalLayout)
+
+
+        self.verticalLayout_4.addLayout(self.horizontalLayout_5)
+
+        self.horizontalLayout_2 = QHBoxLayout()
+        self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
+        self.horizontalSpacer = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
+
+        self.horizontalLayout_2.addItem(self.horizontalSpacer)
+
+        self.pbCancel = QPushButton(Dialog)
+        self.pbCancel.setObjectName(u"pbCancel")
+
+        self.horizontalLayout_2.addWidget(self.pbCancel)
+
+        self.pbOK = QPushButton(Dialog)
+        self.pbOK.setObjectName(u"pbOK")
+
+        self.horizontalLayout_2.addWidget(self.pbOK)
+
+
+        self.verticalLayout_4.addLayout(self.horizontalLayout_2)
+
+
+        self.verticalLayout_5.addLayout(self.verticalLayout_4)
+
+
+        self.retranslateUi(Dialog)
+
+        self.tabWidgetModifiersSets.setCurrentIndex(-1)
+
+
+        QMetaObject.connectSlotsByName(Dialog)
+    # setupUi
+
+    def retranslateUi(self, Dialog):
+        Dialog.setWindowTitle(QCoreApplication.translate("Dialog", u"Set modifiers", None))
+        self.cb_ask_at_stop.setText(QCoreApplication.translate("Dialog", u"Ask for modifier(s) when behavior stops", None))
+        self.lbModifier.setText(QCoreApplication.translate("Dialog", u"Modifier", None))
+        self.lbCode.setText(QCoreApplication.translate("Dialog", u"Key code", None))
+        self.lbCodeHelp.setText(QCoreApplication.translate("Dialog", u"Key code is case sensitive. Type one character or a function key (F1, F2... F12)", None))
+        self.pbAddModifier.setText("")
+        self.pbModifyModifier.setText("")
+        self.lb_name.setText(QCoreApplication.translate("Dialog", u"Set name", None))
+        self.lb_description.setText(QCoreApplication.translate("Dialog", u"Description", None))
+        self.lbType.setText(QCoreApplication.translate("Dialog", u"Modifier type", None))
+        self.cbType.setItemText(0, QCoreApplication.translate("Dialog", u"Single selection", None))
+        self.cbType.setItemText(1, QCoreApplication.translate("Dialog", u"Multiple selection", None))
+        self.cbType.setItemText(2, QCoreApplication.translate("Dialog", u"Numeric", None))
+        self.cbType.setItemText(3, QCoreApplication.translate("Dialog", u"Value from external data file", None))
+
+        self.lbValues.setText(QCoreApplication.translate("Dialog", u"Values", None))
+        self.pbMoveUp.setText(QCoreApplication.translate("Dialog", u"Move modifier up", None))
+        self.pbMoveDown.setText(QCoreApplication.translate("Dialog", u"Move modifier down", None))
+        self.pbRemoveModifier.setText(QCoreApplication.translate("Dialog", u"Remove modifier", None))
+        self.pb_sort_modifiers.setText(QCoreApplication.translate("Dialog", u"Sort modifiers", None))
+        self.pbAddSet.setText(QCoreApplication.translate("Dialog", u"Add set of modifiers", None))
+        self.pbRemoveSet.setText(QCoreApplication.translate("Dialog", u"Remove set of modifiers", None))
+        self.pbMoveSetLeft.setText(QCoreApplication.translate("Dialog", u"Move set left", None))
+        self.pbMoveSetRight.setText(QCoreApplication.translate("Dialog", u"Move set right", None))
+        self.pb_add_subjects.setText(QCoreApplication.translate("Dialog", u"Add subjects as modifiers", None))
+        self.pb_load_file.setText(QCoreApplication.translate("Dialog", u"Load modifiers from file", None))
+        self.pbCancel.setText(QCoreApplication.translate("Dialog", u"Cancel", None))
+        self.pbOK.setText(QCoreApplication.translate("Dialog", u"OK", None))
+    # retranslateUi
+

{boris_behav_obs-8.27.9 → boris_behav_obs-9.0.1}/boris/advanced_event_filtering.py

@@ -25,9 +25,9 @@ import statistics
 import sys
 
 import tablib
-from PyQt5.QtCore import Qt
-from PyQt5.QtGui import QIcon
-from PyQt5.QtWidgets import (
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import (
     QDialog,
     QFileDialog,
     QHBoxLayout,

boris_behav_obs-9.0.1/boris/analysis_plugins/number_of_occurences.py

@@ -0,0 +1,60 @@
+"""
+BORIS plugin
+
+number of occurences of behaviors
+"""
+
+import pandas as pd
+
+__version__ = "0.1.0"
+__version_date__ = "2024-11-14"
+__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.
+    """
+
+    return df.groupby(["Subject", "Behavior"])["Behavior"].count().reset_index(name="number of occurences")
+
+
+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.0.1/boris/analysis_plugins/number_of_occurences_by_independent_variable.py

@@ -0,0 +1,72 @@
+"""
+BORIS plugin
+
+number of occurences of behaviors by independent_variable
+"""
+
+import pandas as pd
+
+__version__ = "0.1.0"
+__version_date__ = "2024-11-14"
+__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.
+    """
+
+    results = (
+        df.groupby(
+            [
+                "independent variable 'Weather'",
+                "Subject",
+                "Behavior",
+            ]
+        )["Behavior"]
+        .count()
+        .reset_index(name="number of occurences")
+    )
+
+    return 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_behav_obs-9.0.1/boris/analysis_plugins/time_budget.py

@@ -0,0 +1,95 @@
+"""
+BORIS plugin
+"""
+
+import pandas as pd
+
+__version__ = "0.1.0"
+__version_date__ = "2024-11-14"
+__plugin_name__ = "Time budget"
+__author__ = "Olivier Friard - University of Torino - Italy"
+
+
+def run(df: pd.DataFrame):
+    """
+    Calculate the following values:
+
+    - Total number of occurences of behavior
+    - Total duration of behavior (in seconds)
+    - Duration mean of behavior (in seconds)
+    - Standard deviation of behavior duration (in seconds)
+    - Inter-event intervals mean (in seconds)
+    - Inter-event intervals standard deviation (in seconds)
+    - % of total duration
+    """
+
+    dfs = [
+        df.groupby(["Subject", "Behavior"])["Behavior"].count().reset_index(name="number of occurences"),
+        df.groupby(["Subject", "Behavior"])["Duration (s)"].sum().reset_index(name="total duration"),
+        df.groupby(["Subject", "Behavior"])["Duration (s)"].mean().astype(float).round(3).reset_index(name="duration mean"),
+        df.groupby(["Subject", "Behavior"])["Duration (s)"].std().astype(float).round(3).reset_index(name="duration std dev"),
+    ]
+
+    # inter events
+    df2 = df.sort_values(by=["Observation id", "Subject", "Behavior", "Start (s)"])
+    df2["diff"] = df2.groupby(["Observation id", "Subject", "Behavior"])["Start (s)"].shift(periods=-1) - df2["Stop (s)"]
+
+    dfs.append(df2.groupby(["Subject", "Behavior"])["diff"].mean().astype(float).round(3).reset_index(name="inter-event intervals mean"))
+
+    dfs.append(df2.groupby(["Subject", "Behavior"])["diff"].std().astype(float).round(3).reset_index(name="inter-event intervals std dev"))
+
+    # % of time
+    dfs.append(
+        (100 * df.groupby(["Subject", "Behavior"])["Duration (s)"].sum() / df.groupby(["Subject"])["Duration (s)"].sum())
+        .astype(float)
+        .round(3)
+        .reset_index(name="% of total duration")
+    )
+
+    merged_df = dfs[0]
+    for df in dfs[1:]:
+        merged_df = pd.merge(merged_df, df, on=["Subject", "Behavior"])
+
+    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)