boris-behav-obs 9.6__tar.gz → 9.6.2__tar.gz

{boris_behav_obs-9.6/boris_behav_obs.egg-info → boris_behav_obs-9.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boris-behav-obs
-Version: 9.6
+Version: 9.6.2
 Summary: BORIS - Behavioral Observation Research Interactive Software
 Author-email: Olivier Friard <olivier.friard@unito.it>
 License-Expression: GPL-3.0-only
@@ -27,6 +27,7 @@ Requires-Dist: pyreadr
 Requires-Dist: pyside6==6.9
 Requires-Dist: hachoir>=3.3.0
 Requires-Dist: scipy>=1.15.3
+Requires-Dist: scikit-learn>=1.7.1
 Provides-Extra: dev
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest; extra == "dev"

{boris_behav_obs-9.6 → boris_behav_obs-9.6.2}/boris/add_modifier.py

@@ -123,11 +123,7 @@ class addModifierDialog(QDialog, Ui_Dialog):
             if (
                 dialog.MessageDialog(
                     cfg.programName,
-                    (
-                        "You are working on a behavior.<br>"
-                        "If you close the window it will be lost.<br>"
-                        "Do you want to change modifiers set"
-                    ),
+                    ("You are working on a behavior.<br>If you close the window it will be lost.<br>Do you want to change modifiers set"),
                     [cfg.CLOSE, cfg.CANCEL],
                 )
                 == cfg.CANCEL

boris_behav_obs-9.6.2/boris/analysis_plugins/irr_cohen_kappa.py

@@ -0,0 +1,72 @@
+"""
+BORIS plugin
+
+Inter Rater Reliability (IRR) Unweighted Cohen Kappa
+"""
+
+import pandas as pd
+from sklearn.metrics import cohen_kappa_score
+
+__version__ = "0.0.1"
+__version_date__ = "2025-08-25"
+__plugin_name__ = "Inter Rater Reliability - Unweighted Cohen Kappa"
+__author__ = "Olivier Friard - University of Torino - Italy"
+
+
+def run(df: pd.DataFrame):
+    """
+    Calculate the Inter Rater Reliability - Unweighted Cohen Kappa
+    """
+
+    # attribute a code for each interval
+    def get_code(t_start, obs):
+        for seg in obs:
+            if t_start >= seg[0] and t_start < seg[1]:
+                return seg[2]
+        return ""
+
+    # Get unique values as a numpy array
+    unique_obs = df["Observation id"].unique()
+
+    # Convert to a list
+    unique_obs_list = unique_obs.tolist()
+
+    # Convert to tuples grouped by observation
+    grouped = {
+        obs: [
+            (row[0], row[1], row[2] + "|" + row[3])  # concatenate subject and behavior with |
+            for row in group[["Start (s)", "Stop (s)", "Subject", "Behavior"]].itertuples(index=False, name=None)
+        ]
+        for obs, group in df.groupby("Observation id")
+    }
+
+    ck_results: dict = {}
+    for idx1, obs_id1 in enumerate(unique_obs_list):
+        obs1 = grouped[obs_id1]
+
+        ck_results[(obs_id1, obs_id1)] = "1.000"
+
+        for obs_id2 in unique_obs_list[idx1 + 1 :]:
+            obs2 = grouped[obs_id2]
+
+            # get all the break points
+            time_points = sorted(set([t for seg in obs1 for t in seg[:2]] + [t for seg in obs2 for t in seg[:2]]))
+
+            # elementary intervals
+            elementary_intervals = [(time_points[i], time_points[i + 1]) for i in range(len(time_points) - 1)]
+
+            obs1_codes = [get_code(t[0], obs1) for t in elementary_intervals]
+
+            obs2_codes = [get_code(t[0], obs2) for t in elementary_intervals]
+
+            # Cohen's Kappa
+            kappa = cohen_kappa_score(obs1_codes, obs2_codes)
+            print(f"{obs_id1} -  {obs_id2}:  Cohen's Kappa : {kappa:.3f}")
+
+            ck_results[(obs_id1, obs_id2)] = f"{kappa:.3f}"
+            ck_results[(obs_id2, obs_id1)] = f"{kappa:.3f}"
+
+    # DataFrame conversion
+    df_results = pd.Series(ck_results).unstack()
+
+    return df_results

boris_behav_obs-9.6.2/boris/analysis_plugins/irr_cohen_kappa_with_modifiers.py

@@ -0,0 +1,77 @@
+"""
+BORIS plugin
+
+Inter Rater Reliability (IRR) Unweighted Cohen Kappa with modifiers
+"""
+
+import pandas as pd
+from sklearn.metrics import cohen_kappa_score
+
+__version__ = "0.0.1"
+__version_date__ = "2025-08-25"
+__plugin_name__ = "Inter Rater Reliability - Unweighted Cohen Kappa with modifiers"
+__author__ = "Olivier Friard - University of Torino - Italy"
+
+
+def run(df: pd.DataFrame):
+    """
+    Calculate the Inter Rater Reliability - Unweighted Cohen Kappa with modifiers
+    """
+
+    # attribute a code for each interval
+    def get_code(t_start, obs):
+        for seg in obs:
+            if t_start >= seg[0] and t_start < seg[1]:
+                return seg[2]
+        return ""
+
+    # Get unique values as a numpy array
+    unique_obs = df["Observation id"].unique()
+
+    # Convert to a list
+    unique_obs_list = unique_obs.tolist()
+
+    # Convert to tuples grouped by observation
+    grouped: dict = {}
+    modifiers: list = []
+    for col in df.columns:
+        if isinstance(col, tuple):
+            modifiers.append(col)
+
+    for obs, group in df.groupby("Observation id"):
+        o: list = []
+        for row in group[["Start (s)", "Stop (s)", "Subject", "Behavior"] + modifiers].itertuples(index=False, name=None):
+            modif_list = [row[i] for idx, i in enumerate(range(4, 4 + len(modifiers))) if modifiers[idx][0] == row[3]]
+            o.append((row[0], row[1], row[2] + "|" + row[3] + "|" + ",".join(modif_list)))
+        grouped[obs] = o
+
+    ck_results: dict = {}
+    for idx1, obs_id1 in enumerate(unique_obs_list):
+        obs1 = grouped[obs_id1]
+
+        ck_results[(obs_id1, obs_id1)] = "1.000"
+
+        for obs_id2 in unique_obs_list[idx1 + 1 :]:
+            obs2 = grouped[obs_id2]
+
+            # get all the break points
+            time_points = sorted(set([t for seg in obs1 for t in seg[:2]] + [t for seg in obs2 for t in seg[:2]]))
+
+            # elementary intervals
+            elementary_intervals = [(time_points[i], time_points[i + 1]) for i in range(len(time_points) - 1)]
+
+            obs1_codes = [get_code(t[0], obs1) for t in elementary_intervals]
+
+            obs2_codes = [get_code(t[0], obs2) for t in elementary_intervals]
+
+            # Cohen's Kappa
+            kappa = cohen_kappa_score(obs1_codes, obs2_codes)
+            print(f"{obs_id1} -  {obs_id2}:  Cohen's Kappa : {kappa:.3f}")
+
+            ck_results[(obs_id1, obs_id2)] = f"{kappa:.3f}"
+            ck_results[(obs_id2, obs_id1)] = f"{kappa:.3f}"
+
+    # DataFrame conversion
+    df_results = pd.Series(ck_results).unstack()
+
+    return df_results

boris_behav_obs-9.6.2/boris/analysis_plugins/irr_weighted_cohen_kappa.py

@@ -0,0 +1,120 @@
+"""
+BORIS plugin
+
+Inter Rater Reliability (IRR) Weighted Cohen Kappa
+"""
+
+import pandas as pd
+from typing import List, Tuple, Dict, Optional
+
+__version__ = "0.0.1"
+__version_date__ = "2025-08-25"
+__plugin_name__ = "Inter Rater Reliability - Weighted Cohen Kappa"
+__author__ = "Olivier Friard - University of Torino - Italy"
+
+
+def run(df: pd.DataFrame):
+    """
+    Calculate the Inter Rater Reliability - Weighted Cohen Kappa
+    """
+
+    def cohen_kappa_weighted_by_time(
+        obs1: List[Tuple[float, float, str]], obs2: List[Tuple[float, float, str]]
+    ) -> Tuple[float, float, float, Dict[Tuple[Optional[str], Optional[str]], float]]:
+        """
+        Compute Cohen's Kappa weighted by time duration.
+
+        Args:
+            obs1: List of (start_time, end_time, code) for observer 1
+            obs2: List of (start_time, end_time, code) for observer 2
+
+        Returns:
+            kappa (float): Cohen's Kappa weighted by duration
+            po (float): Observed agreement proportion (weighted)
+            pe (float): Expected agreement proportion by chance (weighted)
+            contingency (dict): Contingency table {(code1, code2): total_duration}
+        """
+
+        # 1. Collect all time boundaries from both observers
+        time_points = sorted(set([t for seg in obs1 for t in seg[:2]] + [t for seg in obs2 for t in seg[:2]]))
+
+        # 2. Build elementary intervals (non-overlapping time bins)
+        elementary_intervals = [(time_points[i], time_points[i + 1]) for i in range(len(time_points) - 1)]
+
+        # 3. Helper: get the active code for an observer at a given time
+        def get_code(t: float, obs: List[Tuple[float, float, str]]) -> Optional[str]:
+            for seg in obs:
+                if seg[0] <= t < seg[1]:
+                    return seg[2]
+            return None  # in case no segment covers this time
+
+        # 4. Build weighted contingency table (durations instead of counts)
+        contingency: Dict[Tuple[Optional[str], Optional[str]], float] = {}
+        total_time = 0.0
+
+        for start, end in elementary_intervals:
+            c1 = get_code(start, obs1)
+            c2 = get_code(start, obs2)
+            duration = end - start
+            total_time += duration
+            contingency[(c1, c2)] = contingency.get((c1, c2), 0.0) + duration
+
+        # 5. Observed agreement (po)
+        po = sum(duration for (c1, c2), duration in contingency.items() if c1 == c2) / total_time
+
+        # Marginal distributions for each observer
+        codes1: Dict[Optional[str], float] = {}
+        codes2: Dict[Optional[str], float] = {}
+        for (c1, c2), duration in contingency.items():
+            codes1[c1] = codes1.get(c1, 0.0) + duration
+            codes2[c2] = codes2.get(c2, 0.0) + duration
+
+        # 6. Expected agreement (pe), using marginal proportions
+        all_codes = set(codes1) | set(codes2)
+        pe = sum((codes1.get(c, 0.0) / total_time) * (codes2.get(c, 0.0) / total_time) for c in all_codes)
+
+        # 7. Kappa calculation
+        kappa = (po - pe) / (1 - pe) if (1 - pe) != 0 else 0.0
+
+        return kappa, po, pe, contingency
+
+    # Get unique values as a numpy array
+    unique_obs = df["Observation id"].unique()
+
+    # Convert to a list
+    unique_obs_list = unique_obs.tolist()
+
+    # Convert to tuples grouped by observation
+    grouped = {
+        obs: [
+            (row[0], row[1], row[2] + "|" + row[3])  # concatenate subject and behavior with |
+            for row in group[["Start (s)", "Stop (s)", "Subject", "Behavior"]].itertuples(index=False, name=None)
+        ]
+        for obs, group in df.groupby("Observation id")
+    }
+
+    ck_results: dict = {}
+    str_results: str = ""
+    for idx1, obs_id1 in enumerate(unique_obs_list):
+        obs1 = grouped[obs_id1]
+
+        ck_results[(obs_id1, obs_id1)] = "1.000"
+
+        for obs_id2 in unique_obs_list[idx1 + 1 :]:
+            obs2 = grouped[obs_id2]
+
+            # Cohen's Kappa
+            kappa, po, pe, table = cohen_kappa_weighted_by_time(obs1, obs2)
+
+            print(f"{obs_id1} -  {obs_id2}:  Cohen's Kappa: {kappa:.3f}   Expected agreement: {pe:.3f}  Observed agreement: {po:.3f}")
+            str_results += (
+                f"{obs_id1} -  {obs_id2}:  Cohen's Kappa: {kappa:.3f}   Expected agreement: {pe:.3f}  Observed agreement: {po:.3f}\n"
+            )
+
+            ck_results[(obs_id1, obs_id2)] = f"{kappa:.3f}"
+            ck_results[(obs_id2, obs_id1)] = f"{kappa:.3f}"
+
+    # DataFrame conversion
+    df_results = pd.Series(ck_results).unstack()
+
+    return df_results, str_results

boris_behav_obs-9.6.2/boris/analysis_plugins/irr_weighted_cohen_kappa_with_modifiers.py

@@ -0,0 +1,125 @@
+"""
+BORIS plugin
+
+Inter Rater Reliability (IRR) Weighted Cohen Kappa with modifiers
+"""
+
+import pandas as pd
+from typing import List, Tuple, Dict, Optional
+
+__version__ = "0.0.1"
+__version_date__ = "2025-08-25"
+__plugin_name__ = "Inter Rater Reliability - Weighted Cohen Kappa with modifiers"
+__author__ = "Olivier Friard - University of Torino - Italy"
+
+
+def run(df: pd.DataFrame):
+    """
+    Calculate the Inter Rater Reliability - Weighted Cohen Kappa with modifiers
+    """
+
+    def cohen_kappa_weighted_by_time(
+        obs1: List[Tuple[float, float, str]], obs2: List[Tuple[float, float, str]]
+    ) -> Tuple[float, float, float, Dict[Tuple[Optional[str], Optional[str]], float]]:
+        """
+        Compute Cohen's Kappa weighted by time duration with modifiers.
+
+        Args:
+            obs1: List of (start_time, end_time, code) for observer 1
+            obs2: List of (start_time, end_time, code) for observer 2
+
+        Returns:
+            kappa (float): Cohen's Kappa weighted by duration
+            po (float): Observed agreement proportion (weighted)
+            pe (float): Expected agreement proportion by chance (weighted)
+            contingency (dict): Contingency table {(code1, code2): total_duration}
+        """
+
+        # 1. Collect all time boundaries from both observers
+        time_points = sorted(set([t for seg in obs1 for t in seg[:2]] + [t for seg in obs2 for t in seg[:2]]))
+
+        # 2. Build elementary intervals (non-overlapping time bins)
+        elementary_intervals = [(time_points[i], time_points[i + 1]) for i in range(len(time_points) - 1)]
+
+        # 3. Helper: get the active code for an observer at a given time
+        def get_code(t: float, obs: List[Tuple[float, float, str]]) -> Optional[str]:
+            for seg in obs:
+                if seg[0] <= t < seg[1]:
+                    return seg[2]
+            return None  # in case no segment covers this time
+
+        # 4. Build weighted contingency table (durations instead of counts)
+        contingency: Dict[Tuple[Optional[str], Optional[str]], float] = {}
+        total_time = 0.0
+
+        for start, end in elementary_intervals:
+            c1 = get_code(start, obs1)
+            c2 = get_code(start, obs2)
+            duration = end - start
+            total_time += duration
+            contingency[(c1, c2)] = contingency.get((c1, c2), 0.0) + duration
+
+        # 5. Observed agreement (po)
+        po = sum(duration for (c1, c2), duration in contingency.items() if c1 == c2) / total_time
+
+        # Marginal distributions for each observer
+        codes1: Dict[Optional[str], float] = {}
+        codes2: Dict[Optional[str], float] = {}
+        for (c1, c2), duration in contingency.items():
+            codes1[c1] = codes1.get(c1, 0.0) + duration
+            codes2[c2] = codes2.get(c2, 0.0) + duration
+
+        # 6. Expected agreement (pe), using marginal proportions
+        all_codes = set(codes1) | set(codes2)
+        pe = sum((codes1.get(c, 0.0) / total_time) * (codes2.get(c, 0.0) / total_time) for c in all_codes)
+
+        # 7. Kappa calculation
+        kappa = (po - pe) / (1 - pe) if (1 - pe) != 0 else 0.0
+
+        return kappa, po, pe, contingency
+
+    # Get unique values as a numpy array
+    unique_obs = df["Observation id"].unique()
+
+    # Convert to a list
+    unique_obs_list = unique_obs.tolist()
+
+    # Convert to tuples grouped by observation
+    grouped: dict = {}
+    modifiers: list = []
+    for col in df.columns:
+        if isinstance(col, tuple):
+            modifiers.append(col)
+
+    for obs, group in df.groupby("Observation id"):
+        o = []
+        for row in group[["Start (s)", "Stop (s)", "Subject", "Behavior"] + modifiers].itertuples(index=False, name=None):
+            modif_list = [row[i] for idx, i in enumerate(range(4, 4 + len(modifiers))) if modifiers[idx][0] == row[3]]
+            o.append((row[0], row[1], row[2] + "|" + row[3] + "|" + ",".join(modif_list)))
+        grouped[obs] = o
+
+    ck_results: dict = {}
+    str_results: str = ""
+    for idx1, obs_id1 in enumerate(unique_obs_list):
+        obs1 = grouped[obs_id1]
+
+        ck_results[(obs_id1, obs_id1)] = "1.000"
+
+        for obs_id2 in unique_obs_list[idx1 + 1 :]:
+            obs2 = grouped[obs_id2]
+
+            # Cohen's Kappa
+            kappa, po, pe, table = cohen_kappa_weighted_by_time(obs1, obs2)
+
+            print(f"{obs_id1} -  {obs_id2}:  Cohen's Kappa: {kappa:.3f}   Expected agreement: {pe:.3f}  Observed agreement: {po:.3f}")
+            str_results += (
+                f"{obs_id1} -  {obs_id2}:  Cohen's Kappa: {kappa:.3f}   Expected agreement: {pe:.3f}  Observed agreement: {po:.3f}\n"
+            )
+
+            ck_results[(obs_id1, obs_id2)] = f"{kappa:.3f}"
+            ck_results[(obs_id2, obs_id1)] = f"{kappa:.3f}"
+
+    # DataFrame conversion
+    df_results = pd.Series(ck_results).unstack()
+
+    return df_results, str_results

boris_behav_obs-9.6.2/boris/analysis_plugins/number_of_occurences_by_independent_variable.py

@@ -0,0 +1,54 @@
+"""
+BORIS plugin
+
+number of occurences of behaviors by independent_variable
+"""
+
+import pandas as pd
+
+__version__ = "0.4.0"
+__version_date__ = "2025-07-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_list: list = []
+
+    flag_variable_found = False
+
+    for column in df.columns:
+        if isinstance(column, tuple) or (isinstance(column, str) and not column.startswith("independent variable '")):
+            continue
+
+        flag_variable_found = True
+        grouped_df: df.DataFrame = (
+            df.groupby(
+                [
+                    column,
+                    "Subject",
+                    "Behavior",
+                ]
+            )["Behavior"]
+            .count()
+            .reset_index(name="number of occurences")
+        )
+
+        grouped_df.rename(columns={column: "Value"}, inplace=True)
+
+        grouped_df.insert(0, "independent variable name", column)
+
+        df_results_list.append(grouped_df)
+
+    df_results = pd.concat(df_results_list, ignore_index=True) if df_results_list else pd.DataFrame([])
+
+    if not flag_variable_found:
+        return "No independent variable found"
+    else:
+        return df_results

{boris_behav_obs-9.6 → boris_behav_obs-9.6.2}/boris/boris_cli.py

@@ -252,7 +252,7 @@ if args.command:
 
         K, out = irr.cohen_kappa(cursor, observations_id_list[0], observations_id_list[1], interval, subjects, include_modifiers)
 
-        print(("Cohen's Kappa - Index of Inter-Rater Reliability\n\n" "Interval time: {interval:.3f} s\n").format(interval=interval))
+        print(("Cohen's Kappa - Index of Inter-Rater Reliability\n\nInterval time: {interval:.3f} s\n").format(interval=interval))
 
         print(out)
         sys.exit()

{boris_behav_obs-9.6 → boris_behav_obs-9.6.2}/boris/core.py

@@ -4263,7 +4263,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
                 self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].extend(events_to_add)
                 self.project_changed()
-                self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].sort()
+                self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].sort(key=lambda x: x[:3])
 
                 self.load_tw_events(self.observationId)
 
@@ -4361,14 +4361,12 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
                     events_to_add = project_functions.fix_unpaired_state_events2(self.pj[cfg.ETHOGRAM], events, time_to_stop)
 
-                    # print(f"{events_to_add=}")
-
                     if events_to_add:
                         self.statusbar.showMessage("The playlist has finished. Some ongoing state events were stopped automatically", 0)
 
                         self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].extend(events_to_add)
                         self.project_changed()
-                        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].sort()
+                        self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].sort(key=lambda x: x[:3])
 
                         self.load_tw_events(self.observationId)
 

{boris_behav_obs-9.6 → boris_behav_obs-9.6.2}/boris/core_qrc.py

@@ -15946,10 +15946,13 @@ qt_resource_struct = b"\
 \x00\x00\x01\x95k&\xa4B\
 "
 
+
 def qInitResources():
     QtCore.qRegisterResourceData(0x03, qt_resource_struct, qt_resource_name, qt_resource_data)
 
+
 def qCleanupResources():
     QtCore.qUnregisterResourceData(0x03, qt_resource_struct, qt_resource_name, qt_resource_data)
 
+
 qInitResources()

{boris_behav_obs-9.6 → boris_behav_obs-9.6.2}/boris/exclusion_matrix.py

@@ -42,7 +42,7 @@ class ExclusionMatrix(QDialog):
 
         self.label = QLabel()
         self.label.setText(
-            ("Check if behaviors are mutually exclusive.\n" "The Point events (displayed on blue background) cannot be excluded)")
+            ("Check if behaviors are mutually exclusive.\nThe Point events (displayed on blue background) cannot be excluded)")
         )
         hbox.addWidget(self.label)
 

{boris_behav_obs-9.6 → boris_behav_obs-9.6.2}/boris/irr.py

@@ -126,7 +126,7 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     first_event = cursor.execute(
         (
             "SELECT min(start) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
+            f"WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "
         ),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
@@ -134,21 +134,18 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     logging.debug(f"first_event: {first_event}")
 
     last_event = cursor.execute(
-        (
-            "SELECT max(stop) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT max(stop) FROM aggregated_events WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
 
     logging.debug(f"last_event: {last_event}")
 
     nb_events1 = cursor.execute(
-        ("SELECT COUNT(*) FROM aggregated_events " f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1,) + tuple(selected_subjects),
     ).fetchone()[0]
     nb_events2 = cursor.execute(
-        ("SELECT COUNT(*) FROM aggregated_events " f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid2,) + tuple(selected_subjects),
     ).fetchone()[0]
 
@@ -201,11 +198,7 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     logging.debug(f"contingency_table:\n {contingency_table}")
 
     template = (
-        "Observation: {obsid1}\n"
-        "number of events: {nb_events1}\n\n"
-        "Observation: {obsid2}\n"
-        "number of events: {nb_events2:.0f}\n\n"
-        "K = {K:.3f}"
+        "Observation: {obsid1}\nnumber of events: {nb_events1}\n\nObservation: {obsid2}\nnumber of events: {nb_events2:.0f}\n\nK = {K:.3f}"
     )
 
     # out += "Observation length: <b>{:.3f} s</b><br>".format(self.observationTotalMediaLength(obsid1))
@@ -470,7 +463,7 @@ def needleman_wunsch_identity(cursor, obsid1: str, obsid2: str, interval, select
     first_event = cursor.execute(
         (
             "SELECT min(start) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
+            f"WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "
         ),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
@@ -483,22 +476,19 @@ def needleman_wunsch_identity(cursor, obsid1: str, obsid2: str, interval, select
     logging.debug(f"first_event: {first_event}")
 
     last_event = cursor.execute(
-        (
-            "SELECT max(stop) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT max(stop) FROM aggregated_events WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
 
     logging.debug(f"last_event: {last_event}")
 
     nb_events1 = cursor.execute(
-        ("SELECT COUNT(*) FROM aggregated_events " f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1,) + tuple(selected_subjects),
     ).fetchone()[0]
 
     nb_events2 = cursor.execute(
-        ("SELECT COUNT(*) FROM aggregated_events " f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid2,) + tuple(selected_subjects),
     ).fetchone()[0]
 
@@ -606,9 +596,7 @@ def needleman_wunch(self):
 
     cursor = db_connector.cursor()
     out = (
-        "Needleman-Wunsch similarity\n\n"
-        f"Time unit: {interval:.3f} s\n"
-        f"Selected subjects: {', '.join(parameters[cfg.SELECTED_SUBJECTS])}\n\n"
+        f"Needleman-Wunsch similarity\n\nTime unit: {interval:.3f} s\nSelected subjects: {', '.join(parameters[cfg.SELECTED_SUBJECTS])}\n\n"
     )
     mem_done = []
     nws_results = np.ones((len(selected_observations), len(selected_observations)))

{boris_behav_obs-9.6 → boris_behav_obs-9.6.2}/boris/menu_options.py

@@ -143,6 +143,8 @@ def update_menu(self):
         self.actionJumpForward,
         self.actionJumpBackward,
         self.actionJumpTo,
+        self.action_change_time_offset_of_players,
+        self.action_deinterlace,
         self.actionZoom_level,
         self.actionRotate_current_video,
         self.actionDisplay_subtitles,

boris_behav_obs-9.6.2/boris/portion/__init__.py

@@ -0,0 +1,31 @@
+from .const import Bound, inf
+from .interval import Interval, open, closed, openclosed, closedopen, empty, singleton
+from .func import iterate
+from .io import from_string, to_string, from_data, to_data
+
+# disabled because BORIS does not need IntervalDict
+# so the sortedcontainers module is not required
+# from .dict import IntervalDict
+
+
+__all__ = [
+    "inf",
+    "CLOSED",
+    "OPEN",
+    "Interval",
+    "open",
+    "closed",
+    "openclosed",
+    "closedopen",
+    "singleton",
+    "empty",
+    "iterate",
+    "from_string",
+    "to_string",
+    "from_data",
+    "to_data",
+    "IntervalDict",
+]
+
+CLOSED = Bound.CLOSED
+OPEN = Bound.OPEN