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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: boris-behav-obs
-Version: 9.1.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.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.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.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.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.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)

boris_behav_obs-9.2/boris/plugins.py

@@ -0,0 +1,247 @@
+"""
+BORIS
+Behavioral Observation Research Interactive Software
+Copyright 2012-2025 Olivier Friard
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  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, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+  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 . import project_functions
+from . import dialog
+from . import view_df
+
+
+def add_plugins_to_menu(self):
+    """
+    add plugins to the plugins menu
+    """
+    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=lambda checked=False, name=plugin_name: run_plugin(self, name))
+        action.setText(plugin_name)
+
+        self.menu_plugins.addAction(action)
+
+
+def get_plugin_name(plugin_path: str):
+    """
+    get name of plugin
+    """
+    # search plugin name
+    plugin_name = None
+    with open(plugin_path, "r") as f_in:
+        for line in f_in:
+            if line.startswith("__plugin_name__"):
+                plugin_name = line.split("=")[1].strip().replace('"', "")
+                break
+    return plugin_name
+
+
+def load_plugins(self):
+    """
+    load selected plugins in analysis menu
+    """
+    self.menu_plugins.clear()
+    self.config_param[cfg.ANALYSIS_PLUGINS] = {}
+
+    # load BORIS plugins
+    for file_ in (Path(__file__).parent / "analysis_plugins").glob("*.py"):
+        if file_.name == "__init__.py":
+            continue
+        plugin_name = get_plugin_name(file_)
+        if plugin_name is not None and plugin_name not in self.config_param.get(cfg.EXCLUDED_PLUGINS, set()):
+            self.config_param[cfg.ANALYSIS_PLUGINS][plugin_name] = str(file_)
+
+    # load personal plugins
+    if self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, ""):
+        for file_ in Path(self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, "")).glob("*.py"):
+            if file_.name == "__init__.py":
+                continue
+            plugin_name = get_plugin_name(file_)
+            if plugin_name is not None and plugin_name not in self.config_param.get(cfg.EXCLUDED_PLUGINS, set()):
+                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,
+            )