boris-behav-obs 9.6.1__py2.py3-none-any.whl → 9.6.2__py2.py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/portion/__init__.py

@@ -3,18 +3,28 @@ from .interval import Interval, open, closed, openclosed, closedopen, empty, sin
 from .func import iterate
 from .io import from_string, to_string, from_data, to_data
 
-# disabled because BORIS does not need IntervalDict 
+# disabled because BORIS does not need IntervalDict
 # so the sortedcontainers module is not required
-#from .dict import IntervalDict
+# 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',
+    "inf",
+    "CLOSED",
+    "OPEN",
+    "Interval",
+    "open",
+    "closed",
+    "openclosed",
+    "closedopen",
+    "singleton",
+    "empty",
+    "iterate",
+    "from_string",
+    "to_string",
+    "from_data",
+    "to_data",
+    "IntervalDict",
 ]
 
 CLOSED = Bound.CLOSED

boris/portion/const.py

@@ -5,11 +5,12 @@ class Bound(enum.Enum):
     """
     Bound types, either CLOSED for inclusive, or OPEN for exclusive.
     """
+
     CLOSED = True
     OPEN = False
 
     def __bool__(self):
-        raise ValueError('The truth value of a bound is ambiguous.')
+        raise ValueError("The truth value of a bound is ambiguous.")
 
     def __invert__(self):
         return Bound.CLOSED if self is Bound.OPEN else Bound.OPEN
@@ -21,7 +22,7 @@ class Bound(enum.Enum):
         return self.name
 
 
-class _Singleton():
+class _Singleton:
     __instance = None
 
     def __new__(cls, *args, **kwargs):
@@ -35,21 +36,29 @@ class _PInf(_Singleton):
     Represent positive infinity.
     """
 
-    def __neg__(self): return _NInf()
+    def __neg__(self):
+        return _NInf()
 
-    def __lt__(self, o): return False
+    def __lt__(self, o):
+        return False
 
-    def __le__(self, o): return isinstance(o, _PInf)
+    def __le__(self, o):
+        return isinstance(o, _PInf)
 
-    def __gt__(self, o): return not isinstance(o, _PInf)
+    def __gt__(self, o):
+        return not isinstance(o, _PInf)
 
-    def __ge__(self, o): return True
+    def __ge__(self, o):
+        return True
 
-    def __eq__(self, o): return isinstance(o, _PInf)
+    def __eq__(self, o):
+        return isinstance(o, _PInf)
 
-    def __repr__(self): return '+inf'
+    def __repr__(self):
+        return "+inf"
 
-    def __hash__(self): return hash(float('+inf'))
+    def __hash__(self):
+        return hash(float("+inf"))
 
 
 class _NInf(_Singleton):
@@ -57,21 +66,29 @@ class _NInf(_Singleton):
     Represent negative infinity.
     """
 
-    def __neg__(self): return _PInf()
+    def __neg__(self):
+        return _PInf()
 
-    def __lt__(self, o): return not isinstance(o, _NInf)
+    def __lt__(self, o):
+        return not isinstance(o, _NInf)
 
-    def __le__(self, o): return True
+    def __le__(self, o):
+        return True
 
-    def __gt__(self, o): return False
+    def __gt__(self, o):
+        return False
 
-    def __ge__(self, o): return isinstance(o, _NInf)
+    def __ge__(self, o):
+        return isinstance(o, _NInf)
 
-    def __eq__(self, o): return isinstance(o, _NInf)
+    def __eq__(self, o):
+        return isinstance(o, _NInf)
 
-    def __repr__(self): return '-inf'
+    def __repr__(self):
+        return "-inf"
 
-    def __hash__(self): return hash(float('-inf'))
+    def __hash__(self):
+        return hash(float("-inf"))
 
 
 # Positive infinity

boris/portion/dict.py

@@ -28,7 +28,7 @@ class IntervalDict(MutableMapping):
     number of distinct values (not keys) that are stored.
     """
 
-    __slots__ = ('_storage', )
+    __slots__ = ("_storage",)
 
     def __init__(self, mapping_or_iterable=None):
         """
@@ -352,10 +352,10 @@ class IntervalDict(MutableMapping):
         return key in self.domain()
 
     def __repr__(self):
-        return '{}{}{}'.format(
-            '{',
-            ', '.join('{!r}: {!r}'.format(i, v) for i, v in self.items()),
-            '}',
+        return "{}{}{}".format(
+            "{",
+            ", ".join("{!r}: {!r}".format(i, v) for i, v in self.items()),
+            "}",
         )
 
     def __eq__(self, other):

boris/portion/func.py

@@ -31,7 +31,7 @@ def iterate(interval, step, *, base=None, reverse=False):
     :return: a lazy iterator.
     """
     if base is None:
-        base = (lambda x: x)
+        base = lambda x: x
 
     exclude = operator.lt if not reverse else operator.gt
     include = operator.le if not reverse else operator.ge
@@ -39,7 +39,7 @@ def iterate(interval, step, *, base=None, reverse=False):
 
     value = base(interval.lower if not reverse else interval.upper)
     if (value == -inf and not reverse) or (value == inf and reverse):
-        raise ValueError('Cannot start iteration with infinity.')
+        raise ValueError("Cannot start iteration with infinity.")
 
     for i in interval if not reverse else reversed(interval):
         value = base(i.lower if not reverse else i.upper)

boris/portion/interval.py

@@ -2,7 +2,7 @@ from collections import namedtuple
 from .const import Bound, inf
 
 
-Atomic = namedtuple('Atomic', ['left', 'lower', 'upper', 'right'])
+Atomic = namedtuple("Atomic", ["left", "lower", "upper", "right"])
 
 
 def mergeable(a, b):
@@ -96,7 +96,7 @@ class Interval:
     one of the helpers provided in this module (open, closed, openclosed, etc.)
     """
 
-    __slots__ = ('_intervals',)
+    __slots__ = ("_intervals",)
 
     def __init__(self, *intervals):
         """
@@ -111,7 +111,7 @@ class Interval:
                 if not interval.empty:
                     self._intervals.extend(interval._intervals)
             else:
-                raise TypeError('Parameters must be Interval instances')
+                raise TypeError("Parameters must be Interval instances")
 
         if len(self._intervals) == 0:
             # So we have at least one (empty) interval
@@ -181,10 +181,7 @@ class Interval:
         """
         True if interval is empty, False otherwise.
         """
-        return (
-            self.lower > self.upper or
-            (self.lower == self.upper and (self.left == Bound.OPEN or self.right == Bound.OPEN))
-        )
+        return self.lower > self.upper or (self.lower == self.upper and (self.left == Bound.OPEN or self.right == Bound.OPEN))
 
     @property
     def atomic(self):
@@ -307,7 +304,7 @@ class Interval:
             elif isinstance(value, tuple):
                 intervals.append(Interval.from_atomic(*value))
             else:
-                raise TypeError('Unsupported return type {} for {}'.format(type(value), value))
+                raise TypeError("Unsupported return type {} for {}".format(type(value), value))
 
         return Interval(*intervals)
 
@@ -350,7 +347,7 @@ class Interval:
                     return True
             return False
         else:
-            raise TypeError('Unsupported type {} for {}'.format(type(other), other))
+            raise TypeError("Unsupported type {} for {}".format(type(other), other))
 
     def intersection(self, other):
         """
@@ -468,14 +465,8 @@ class Interval:
             if item.empty:
                 return True
             elif self.atomic:
-                left = item.lower > self.lower or (
-                    item.lower == self.lower and
-                    (item.left == self.left or self.left == Bound.CLOSED)
-                )
-                right = item.upper < self.upper or (
-                    item.upper == self.upper and
-                    (item.right == self.right or self.right == Bound.CLOSED)
-                )
+                left = item.lower > self.lower or (item.lower == self.lower and (item.left == self.left or self.left == Bound.CLOSED))
+                right = item.upper < self.upper or (item.upper == self.upper and (item.right == self.right or self.right == Bound.CLOSED))
                 return left and right
             else:
                 selfiter = iter(self)
@@ -504,13 +495,11 @@ class Interval:
     def __invert__(self):
         complements = [
             Interval.from_atomic(Bound.OPEN, -inf, self.lower, ~self.left),
-            Interval.from_atomic(~self.right, self.upper, inf, Bound.OPEN)
+            Interval.from_atomic(~self.right, self.upper, inf, Bound.OPEN),
         ]
 
         for i, j in zip(self._intervals[:-1], self._intervals[1:]):
-            complements.append(
-                Interval.from_atomic(~i.right, i.upper, j.lower, ~j.left)
-            )
+            complements.append(Interval.from_atomic(~i.right, i.upper, j.lower, ~j.left))
 
         return Interval(*complements)
 
@@ -526,12 +515,7 @@ class Interval:
                 return False
 
             for a, b in zip(self._intervals, other._intervals):
-                eq = (
-                    a.left == b.left and
-                    a.lower == b.lower and
-                    a.upper == b.upper and
-                    a.right == b.right
-                )
+                eq = a.left == b.left and a.lower == b.lower and a.upper == b.upper and a.right == b.right
                 if not eq:
                     return False
             return True
@@ -543,8 +527,7 @@ class Interval:
             if self.right == Bound.OPEN:
                 return self.upper <= other.lower
             else:
-                return self.upper < other.lower or \
-                    (self.upper == other.lower and other.left == Bound.OPEN)
+                return self.upper < other.lower or (self.upper == other.lower and other.left == Bound.OPEN)
         else:
             return self.upper < other or (self.right == Bound.OPEN and self.upper == other)
 
@@ -553,8 +536,7 @@ class Interval:
             if self.left == Bound.OPEN:
                 return self.lower >= other.upper
             else:
-                return self.lower > other.upper or \
-                    (self.lower == other.upper and other.right == Bound.OPEN)
+                return self.lower > other.upper or (self.lower == other.upper and other.right == Bound.OPEN)
         else:
             return self.lower > other or (self.left == Bound.OPEN and self.lower == other)
 
@@ -563,8 +545,7 @@ class Interval:
             if self.right == Bound.OPEN:
                 return self.upper <= other.upper
             else:
-                return self.upper < other.upper or \
-                    (self.upper == other.upper and other.right == Bound.CLOSED)
+                return self.upper < other.upper or (self.upper == other.upper and other.right == Bound.CLOSED)
         else:
             return self.lower < other or (self.left == Bound.CLOSED and self.lower == other)
 
@@ -573,8 +554,7 @@ class Interval:
             if self.left == Bound.OPEN:
                 return self.lower >= other.lower
             else:
-                return self.lower > other.lower or \
-                    (self.lower == other.lower and other.left == Bound.CLOSED)
+                return self.lower > other.lower or (self.lower == other.lower and other.left == Bound.CLOSED)
         else:
             return self.upper > other or (self.right == Bound.CLOSED and self.upper == other)
 
@@ -586,16 +566,16 @@ class Interval:
 
         for interval in self:
             if interval.empty:
-                intervals.append('()')
+                intervals.append("()")
             elif interval.lower == interval.upper:
-                intervals.append('[{}]'.format(repr(interval.lower)))
+                intervals.append("[{}]".format(repr(interval.lower)))
             else:
                 intervals.append(
-                    '{}{},{}{}'.format(
-                        '[' if interval.left == Bound.CLOSED else '(',
+                    "{}{},{}{}".format(
+                        "[" if interval.left == Bound.CLOSED else "(",
                         repr(interval.lower),
                         repr(interval.upper),
-                        ']' if interval.right == Bound.CLOSED else ')',
+                        "]" if interval.right == Bound.CLOSED else ")",
                     )
                 )
-        return ' | '.join(intervals)
+        return " | ".join(intervals)

boris/portion/io.py

@@ -4,9 +4,20 @@ from .const import Bound, inf
 from .interval import Interval
 
 
-def from_string(string, conv, *, bound=r'.+?', disj=r' ?\| ?', sep=r', ?',
-                left_open=r'\(', left_closed=r'\[', right_open=r'\)', right_closed=r'\]',
-                pinf=r'\+inf', ninf=r'-inf'):
+def from_string(
+    string,
+    conv,
+    *,
+    bound=r".+?",
+    disj=r" ?\| ?",
+    sep=r", ?",
+    left_open=r"\(",
+    left_closed=r"\[",
+    right_open=r"\)",
+    right_closed=r"\]",
+    pinf=r"\+inf",
+    ninf=r"-inf",
+):
     """
     Parse given string and create an Interval instance.
     A converter function has to be provided to convert a bound (as string) to a value.
@@ -25,11 +36,11 @@ def from_string(string, conv, *, bound=r'.+?', disj=r' ?\| ?', sep=r', ?',
     :return: an Interval instance.
     """
 
-    re_left_boundary = r'(?P<left>{}|{})'.format(left_open, left_closed)
-    re_right_boundary = r'(?P<right>{}|{})'.format(right_open, right_closed)
-    re_bounds = r'(?P<lower>{bound})({sep}(?P<upper>{bound}))?'.format(bound=bound, sep=sep)
-    re_interval = r'{}(|{}){}'.format(re_left_boundary, re_bounds, re_right_boundary)
-    re_intervals = r'{}(?P<disj>{})?'.format(re_interval, disj)
+    re_left_boundary = r"(?P<left>{}|{})".format(left_open, left_closed)
+    re_right_boundary = r"(?P<right>{}|{})".format(right_open, right_closed)
+    re_bounds = r"(?P<lower>{bound})({sep}(?P<upper>{bound}))?".format(bound=bound, sep=sep)
+    re_interval = r"{}(|{}){}".format(re_left_boundary, re_bounds, re_right_boundary)
+    re_intervals = r"{}(?P<disj>{})?".format(re_interval, disj)
 
     intervals = []
     has_more = True
@@ -49,22 +60,23 @@ def from_string(string, conv, *, bound=r'.+?', disj=r' ?\| ?', sep=r', ?',
         else:
             group = match.groupdict()
 
-            left = Bound.CLOSED if re.match(left_closed + '$', group['left']) else Bound.OPEN
-            right = Bound.CLOSED if re.match(right_closed + '$', group['right']) else Bound.OPEN
+            left = Bound.CLOSED if re.match(left_closed + "$", group["left"]) else Bound.OPEN
+            right = Bound.CLOSED if re.match(right_closed + "$", group["right"]) else Bound.OPEN
 
-            lower = group.get('lower', None)
-            upper = group.get('upper', None)
+            lower = group.get("lower", None)
+            upper = group.get("upper", None)
             lower = _convert(lower) if lower is not None else inf
             upper = _convert(upper) if upper is not None else lower
 
             intervals.append(Interval.from_atomic(left, lower, upper, right))
-            string = string[match.end():]
+            string = string[match.end() :]
 
     return Interval(*intervals)
 
 
-def to_string(interval, conv=repr, *, disj=' | ', sep=',', left_open='(',
-              left_closed='[', right_open=')', right_closed=']', pinf='+inf', ninf='-inf'):
+def to_string(
+    interval, conv=repr, *, disj=" | ", sep=",", left_open="(", left_closed="[", right_open=")", right_closed="]", pinf="+inf", ninf="-inf"
+):
     """
     Export given interval to string.
 
@@ -81,7 +93,7 @@ def to_string(interval, conv=repr, *, disj=' | ', sep=',', left_open='(',
     :return: a string representation for given interval.
     """
     if interval.empty:
-        return '{}{}'.format(left_open, right_open)
+        return "{}{}".format(left_open, right_open)
 
     def _convert(bound):
         if bound == inf:
@@ -100,14 +112,14 @@ def to_string(interval, conv=repr, *, disj=' | ', sep=',', left_open='(',
         upper = _convert(item.upper)
 
         if item.lower == item.upper:
-            exported_intervals.append('{}{}{}'.format(left, lower, right))
+            exported_intervals.append("{}{}{}".format(left, lower, right))
         else:
-            exported_intervals.append('{}{}{}{}{}'.format(left, lower, sep, upper, right))
+            exported_intervals.append("{}{}{}{}{}".format(left, lower, sep, upper, right))
 
     return disj.join(exported_intervals)
 
 
-def from_data(data, conv=None, *, pinf=float('inf'), ninf=float('-inf')):
+def from_data(data, conv=None, *, pinf=float("inf"), ninf=float("-inf")):
     """
     Import an interval from a piece of data.
 
@@ -130,16 +142,18 @@ def from_data(data, conv=None, *, pinf=float('inf'), ninf=float('-inf')):
 
     for item in data:
         left, lower, upper, right = item
-        intervals.append(Interval.from_atomic(
-            Bound(left),
-            _convert(lower),
-            _convert(upper),
-            Bound(right),
-        ))
+        intervals.append(
+            Interval.from_atomic(
+                Bound(left),
+                _convert(lower),
+                _convert(upper),
+                Bound(right),
+            )
+        )
     return Interval(*intervals)
 
 
-def to_data(interval, conv=None, *, pinf=float('inf'), ninf=float('-inf')):
+def to_data(interval, conv=None, *, pinf=float("inf"), ninf=float("-inf")):
     """
     Export given interval to a list of 4-uples (left, lower,
     upper, right).
@@ -163,10 +177,5 @@ def to_data(interval, conv=None, *, pinf=float('inf'), ninf=float('-inf')):
             return conv(bound)
 
     for item in interval:
-        data.append((
-            item.left.value,
-            _convert(item.lower),
-            _convert(item.upper),
-            item.right.value
-        ))
+        data.append((item.left.value, _convert(item.lower), _convert(item.upper), item.right.value))
     return data

boris/project_functions.py

@@ -1539,7 +1539,8 @@ def open_project_json(project_file_name: str) -> tuple:
     # sort events by time asc
     for obs_id in pj[cfg.OBSERVATIONS]:
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] in (cfg.LIVE, cfg.MEDIA):
-            pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS].sort()
+            # sort events list using the first 3 items (time, subject, behavior)
+            pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS].sort(key=lambda x: x[:3])
 
     return project_file_name, projectChanged, pj, msg
 

boris/state_events.py

@@ -136,7 +136,7 @@ def fix_unpaired_events(self, silent_mode: bool = False):
 
             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)
 
             index = self.tv_events.model().index(

boris/transitions.py

@@ -354,7 +354,7 @@ def transitions_flow_diagram():
             with open(tempfile.gettempdir() + os.sep + os.path.basename(file_name) + ".tmp.gv", "w") as f:
                 f.write(gv)
             result = subprocess.getoutput(
-                (f'dot -Tpng -o "{file_name}.png" ' f'"{tempfile.gettempdir() + os.sep + os.path.basename(file_name)}.tmp.gv"')
+                (f'dot -Tpng -o "{file_name}.png" "{tempfile.gettempdir() + os.sep + os.path.basename(file_name)}.tmp.gv"')
             )
             if not result:
                 out += f"<b>{file_name}.png</b> created<br>"

boris/version.py

@@ -20,5 +20,5 @@ This file is part of BORIS.
 
 """
 
-__version__ = "9.6.1"
-__version_date__ = "2025-07-17"
+__version__ = "9.6.2"
+__version_date__ = "2025-08-05"

boris/write_event.py

@@ -472,8 +472,8 @@ def write_event(self, event: dict, mem_time: dec) -> int:
                 comment,
                 frame_idx,
             ]
-            # order by image index ASC
-            self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].sort()
+            # order events list using time, subject, behavior
+            self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].sort(key=lambda x: x[:3])
 
         elif self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.LIVE:
             self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][event["row"]] = [
@@ -483,8 +483,8 @@ def write_event(self, event: dict, mem_time: dec) -> int:
                 modifier_str,
                 comment,
             ]
-            # order by image index ASC
-            self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].sort()
+            # order events list using time, subject, behavior
+            self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS].sort(key=lambda x: x[:3])
 
         elif self.pj[cfg.OBSERVATIONS][self.observationId][cfg.TYPE] == cfg.IMAGES:
             self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][event["row"]] = [

{boris_behav_obs-9.6.1.dist-info → boris_behav_obs-9.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boris-behav-obs
-Version: 9.6.1
+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.1.dist-info → boris_behav_obs-9.6.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
 boris/__init__.py,sha256=iAtmVMy22TJpMmxVTMSK_6-wXnCbx1ogvWgfYEcbHzU,773
 boris/__main__.py,sha256=ANjTbXgXDoz2nB1tCtOIllfIVotCa602iebACX7rXaE,764
 boris/about.py,sha256=VPa8zeu0bMb1LRXDq8uUSG_7mSbkb2HTk1AtWbzWQwE,5366
-boris/add_modifier.py,sha256=DWqxkKDBm21QH_kPvhpnltwLtFvPxne0VmZ1SY26hj8,26340
+boris/add_modifier.py,sha256=l9LSa_9FAV9CnBgm26tJqhMAdnFoBQafZLyt9pTKmac,26240
 boris/add_modifier_ui.py,sha256=Y7TLO5uS6zW7zpjXmjA4V_VIp_bFDNtjOTbJ9Q6m-mQ,11601
 boris/advanced_event_filtering.py,sha256=VlvU12mL6xYacZOvJAi5uLpHMcmAw5Pvuvmka-PN29c,15469
 boris/behav_coding_map_creator.py,sha256=_WmfWTYkKh_a7pZa49h2GtORCi6h8joZTWihud6YDBE,38826
 boris/behavior_binary_table.py,sha256=bpmRDpEjq0rw3YOCoN_He3kfUe8A_R6E48kQR7KnkH8,12453
 boris/behaviors_coding_map.py,sha256=xIGJxp2eghrpiGDmYH73eJPERuyc4A_54uT-Got3zTs,7302
-boris/boris_cli.py,sha256=n0OiVvZM1gM6E7yKaff9wlgmpAGK4TK052VRi8AabJo,13196
+boris/boris_cli.py,sha256=Bc51DEMcD79ZZfM9pCzpaWU6iT6b8gNwR3n8fr42_4E,13193
 boris/cmd_arguments.py,sha256=oWb-FvhKLbKJhATlTHy9muWu8XnnUfOZ-3Fmz2M8Yzc,1848
 boris/coding_pad.py,sha256=fBKdp7DDyupySJosIYtqNd8s2E-GruzCgVhDFsoVWKE,10986
 boris/config.py,sha256=IbW8PkAFcZIL-8NoSscXSeI82dneLzpywaGXWDcnrWw,17845
@@ -16,8 +16,8 @@ boris/connections.py,sha256=kqc6jaYNzoJe8crPtfwE-fXTW4nTfB8-PojRzbbLEus,19629
 boris/converters.py,sha256=n6gDM9x2hS-ZOoHLruiifuXxnC7ERsUukiFokhHZPoQ,11678
 boris/converters_ui.py,sha256=uu7LOBV_fKv2DBdOqsqPwjGsjgONr5ODBoscAA-EP48,9900
 boris/cooccurence.py,sha256=tVERC-V8MWjWHlGEfDuu08iS94qjt4do-38jwI62QaY,10367
-boris/core.py,sha256=nq-GnTz6mdGFSv1GDAp0XJNyC0FW0DEdvqhMrlY_dCg,231016
-boris/core_qrc.py,sha256=J0kom27nrmi4-TCDLJZCZbtUAitiXQ4WEDfErawuxt8,639879
+boris/core.py,sha256=xDurFeAulOx1TjcaZbuoymvnP07fjIAUfhElLw4och8,231004
+boris/core_qrc.py,sha256=Hz51Xw70ZIlDbYB281nfGtCm43_ItYhamMu2T5X8Tu8,639882
 boris/core_ui.py,sha256=--VDOzUfjsA4TJRw3aFk2CeSL29193vPGLgYJRhQfUY,77143
 boris/db_functions.py,sha256=Uw9wWH_Pe-qNzpV1k21YG_jKsoOmfY_iiK_7ARZHGDc,13352
 boris/dev.py,sha256=9pUElbjl9g17rFUJXX5aVSu55_iIKIuDxNdrB0DI_d0,3671
@@ -28,7 +28,7 @@ boris/edit_event_ui.py,sha256=qFgt00cejGB6UGC1mFkyZcsIAdvMeYMK0WYjZtJl1T0,9207
 boris/event_operations.py,sha256=bqUZjgJaJ1Z8oTiidG9wfCp2LLUH1Zf4kBDeg_yjC-o,38514
 boris/events_cursor.py,sha256=VPY_ygD0fxE5lp25mcd2l00XQXurCR6hprffF4tKRbU,2078
 boris/events_snapshots.py,sha256=PjWzQvUGQtIcEc_7FDsRphf7fAhhTccQgYc2eQSA65g,27621
-boris/exclusion_matrix.py,sha256=ff88xD6aqc8bpIuj9ZCz9ju_HeqqgibQwoaJrIOJ6RI,5272
+boris/exclusion_matrix.py,sha256=K_o8pEMYRQ3curgRQYkn5hPRksLDitICuwjB7mpVRPA,5269
 boris/export_events.py,sha256=3B336WEA0g_8oW3VDo_kfq5D0ISu-e7z2f-_ROUvU9c,39756
 boris/export_observation.py,sha256=B8ASj6H70xfcTSUHrbcJa6YOYjih2WD4DSiUtXj5eAk,50764
 boris/external_processes.py,sha256=PogE2eEiQLVZ2useMamQMOAeDmMUX_TlIpqPKLMm6Ak,13607
@@ -36,11 +36,11 @@ boris/geometric_measurement.py,sha256=4pI-AYpBSFlJBqS-f8dnkgLtj_Z2E5kwwAdh6WwZ4k
 boris/gui_utilities.py,sha256=2HdWFxo2y0oxC29VJAA3R-TOMxVbOy3FuVwspjrTD6A,5519
 boris/image_overlay.py,sha256=zZAL8MTt2i2s58CuX81Nym3rJ5pKiTeP4AO8WbIUonM,2527
 boris/import_observations.py,sha256=zKrkpk1ADxTj2BECactPPOhU6wtrh3TjtOWue2HCT5w,9074
-boris/irr.py,sha256=o5QN3B2b-02AUkrklMJCitFGsfiUDtmI0MxUbPv2cBg,22472
+boris/irr.py,sha256=n6Y_Y9iEKOf9_7EE_lDRNei7tq2wkFKk_JVflm9UQdk,22335
 boris/latency.py,sha256=48z9L_A582-wKCfD0M3h0uyYkeL2ezjlQAS_GzeoOe0,9739
 boris/measurement_widget.py,sha256=lZV62KtK6TjdoNbKxj3uyNAuL5dfnQnn7mYwzMo-dOM,4480
 boris/media_file.py,sha256=Wnw-PCyAz6CA00zhjrx0UTgXZ0wmHuNlnElV_TzJ_2M,4818
-boris/menu_options.py,sha256=UEB3GxRh6YKNCg67qbhOVhJW1ZOznuPe15bADc_CNTI,7062
+boris/menu_options.py,sha256=uznHFMtpGRWL6Eig10gJ5tOiypgOr9XVyxRiuCbgN9U,7146
 boris/modifier_coding_map_creator.py,sha256=NQHy_txgxKZnGByXiro_Oy_cq4DrFaFiAYwVp1CWrTs,33281
 boris/modifiers_coding_map.py,sha256=oT56ZY_PXhEJsMoblEsyNMAPbDpv7ZMOCnvmt7Ibx_Y,4554
 boris/mpv-1.0.3.py,sha256=EXRtzQqFjOn4wMC6482Ilq3fNQ9N1GRP1VxwLzdeaBY,88077
@@ -63,7 +63,7 @@ boris/plugins.py,sha256=lYR_sLqRMdyGEoSPwaLyVuF50B92k6vR8TlDAE5B4l0,14252
 boris/preferences.py,sha256=gWkqKvKuAAzjNbL3_NdBeaHfNC5xKQVxVZW4J1OwYRg,20763
 boris/preferences_ui.py,sha256=wbo51aBNdcQTJni1DmUM5ZQPOwAtKSkEQam7rRzRS5g,34166
 boris/project.py,sha256=nyXfCDY_rLP3jC1QGv-280jUKgbABqESjOm7I19rJ1U,86432
-boris/project_functions.py,sha256=vCs_colyOYtWQFOy5z4aS8mD8f2lZzKU98XIjmGa0BY,80769
+boris/project_functions.py,sha256=o0IOvhGs1cqEjpdeNUeY-qvFfWAQl_7tsUEKxogKRuU,80869
 boris/project_import_export.py,sha256=oBG1CSXfKISsb3TLNT-8BH8kZPAzxIYSNemlLVH1Lh8,38560
 boris/project_ui.py,sha256=yB-ewhHt8S8DTTRIk-dNK2tPMNU24lNji9fDW_Xazu8,38805
 boris/qrc_boris.py,sha256=aH-qUirYY1CGxmTK1SFCPvuZfazIHX4DdUKF1gxZeYM,675008
@@ -71,35 +71,39 @@ boris/qrc_boris5.py,sha256=prnOw7VGXWXRuVCYp_yIrmWhrlG1F9rx-3BQvkPenjY,161608
 boris/select_modifiers.py,sha256=42uG9F75pfPoPJ-blp-vFgmpBpVJtL42FlIxpNpq9z4,13319
 boris/select_observations.py,sha256=k7c3FNVQW74YGH9oFmtHXRVCRnpKGhjCVk3cQtyLML8,8027
 boris/select_subj_behav.py,sha256=ulXbsRY-AIyQRSwXhVlvkNRS_eqWaCvkDKTTyOLqvoE,11742
-boris/state_events.py,sha256=Vrxn3CxC3yf8aeFE76l24n03qgaQ1QXpMtprYT0pq64,7771
+boris/state_events.py,sha256=iUrC5ypwIKOnmoq0moDQwtH9-DrgiJ81zL2pMxESucU,7790
 boris/subjects_pad.py,sha256=lSRRGfLfD10_YpGua8RGVdKhoXlsXawGhNibPkRhuzM,3541
 boris/synthetic_time_budget.py,sha256=3Eb9onMLmgqCLd50CuxV9L8RV2ESzfaMWvPK_bXUMMk,10489
 boris/time_budget_functions.py,sha256=y5He8crz0xsTxVfz0jATwFFQVnPAIrNHja_0sF6NtRE,52551
 boris/time_budget_widget.py,sha256=z-tyITBtIz-KH1H2OdMB5a8x9QQLK7Wu96-zkC6NVDA,43213
-boris/transitions.py,sha256=_aZJfJWv3EBrtmQ7qsdTCayQo6uWU7BXqtQQgflEhr4,12250
+boris/transitions.py,sha256=okyDCO-Vn4p_Fixd8cGiSIaUhUxG5ePIOqGSuP52g_c,12246
 boris/utilities.py,sha256=dD5HpojqlAGLVkr3YnOsaqfbCMHFYroe040ZchB5WnM,56662
-boris/version.py,sha256=mDyPxZPO9ciCvBjRw2xZTdaF3TgIW_KL2omBeJ1TGTo,787
+boris/version.py,sha256=fv-Q0KkA5fOHNIN-jnwFQaHABpI1tEKUf19G8ytKUzo,787
 boris/video_equalizer.py,sha256=FartoGghFK-T53zklP70rPKYqTuzL8qdvfGlsOF2wwc,5854
 boris/video_equalizer_ui.py,sha256=1CG3s79eM4JAbaCx3i1ILZXLceb41_gGXlOLNfpBgnw,10142
 boris/video_operations.py,sha256=rXKWndaALaF-yLEPIY_-Z99XRAncZRzRd1sLzwSpbjs,10768
 boris/view_df.py,sha256=AKScLASX2Uatw7rqPbsnio83eVT4GZYCFhL091eMvlY,3370
 boris/view_df_ui.py,sha256=CaMeRH_vQ00CTDDFQn73ZZaS-r8BSTWpL-dMCFqzJ_Q,2775
-boris/write_event.py,sha256=RN_cFQZNE2jWbM_BiodL4tsyKT0JPREvUy7xgZnrfaM,24041
+boris/write_event.py,sha256=iczoNOHNBZVAy6ZM2bw6dUC1EqoT9kW9umkdU-qo31U,24125
 boris/analysis_plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 boris/analysis_plugins/_latency.py,sha256=9kCdFDtb5Zdao1xFpioi_exm_IxyGm6RlY3Opn6GUFo,2030
+boris/analysis_plugins/irr_cohen_kappa.py,sha256=UtIZ_y5Wm9UbZpGI67a-AszYnH_5DV1LNcff76ChQYg,2253
+boris/analysis_plugins/irr_cohen_kappa_with_modifiers.py,sha256=olYp-L5DZ71vs9B-k9PyErLY5-O2d-R69TUYx6mAzj4,2563
+boris/analysis_plugins/irr_weighted_cohen_kappa.py,sha256=ZEV9PHq0IfPmGBP3gxgnDlnUyM_NXmEIhqqltUHMGwU,4561
+boris/analysis_plugins/irr_weighted_cohen_kappa_with_modifiers.py,sha256=of4EVdUPCpre-HH5l9d1yD-19vj0Judn60OM0Km40EQ,4880
 boris/analysis_plugins/list_of_dataframe_columns.py,sha256=VEiVhxADtyaIKN4JrfFV02TuTAfWhQ60bf1mHVQp27I,437
 boris/analysis_plugins/number_of_occurences.py,sha256=IDyDrdezqvSKT3BlD8QWpSYk8X9nnBBLI80OUnFJ3bY,509
 boris/analysis_plugins/number_of_occurences_by_independent_variable.py,sha256=_7HTKXsyxNfyO69tP8zkQEHzT0C7qHdL1sqBjnUfRQY,1459
 boris/analysis_plugins/time_budget.py,sha256=C1wNYwd5Jugr8h5z2aXRUBY8dF8pD4n953dPwNHY5VY,2244
-boris/portion/__init__.py,sha256=ZBUG4I7YWhRkeWdP-JEpxhxldJlUYQkeaJseTjdhtJE,602
-boris/portion/const.py,sha256=hEp26BKcEg1Js4DfZsBHmDtJJts83Tl1HWQ0CNJNwEc,1588
-boris/portion/dict.py,sha256=SyHxc7PfDw2ufNLFQycwJtzmRfL48rDp4UrM2KN7IWc,11282
-boris/portion/func.py,sha256=3TkQtFKLfsqntwd27HSGHceFhnXHmT-EbNMqktElC5Q,2174
-boris/portion/interval.py,sha256=bAdUiJjGeUAPgsBAImwNeviiwfQq5odfhFZccAWzOTA,20299
-boris/portion/io.py,sha256=ppNeRpiLNrocF1yzGeuEUIhYMf2LfsR-cji3d0nmvUs,6371
-boris_behav_obs-9.6.1.dist-info/licenses/LICENSE.TXT,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
-boris_behav_obs-9.6.1.dist-info/METADATA,sha256=rOegvZFaLcobCRMuUmpNavzzhWQyX7wdWPrEs7ahGpY,4602
-boris_behav_obs-9.6.1.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
-boris_behav_obs-9.6.1.dist-info/entry_points.txt,sha256=k__8XvFi4vaA4QFvQehCZjYkKmZH34HSAJI2iYCWrMs,52
-boris_behav_obs-9.6.1.dist-info/top_level.txt,sha256=fJSgm62S7WesiwTorGbOO4nNN0yzgZ3klgfGi3Px4qI,6
-boris_behav_obs-9.6.1.dist-info/RECORD,,
+boris/portion/__init__.py,sha256=KmMu4q-iIFO5nrVRIP340mEzxzOlZQqaRupiDmS70es,642
+boris/portion/const.py,sha256=JSYZUktIPCekB6qSom1FPfASn-X7w0G5-aNNHKhIZnw,1715
+boris/portion/dict.py,sha256=uNM-LEY52CZ2VNMMW_C9QukoyTvPlQf8vcbGa1lQBHI,11281
+boris/portion/func.py,sha256=mSQr20YS1ug7R1fRqBg8LifjtXDRvJ6Kjc3WOeL9P34,2172
+boris/portion/interval.py,sha256=sOlj3MAGGaB-JxCkigS-n3qw0fY7TANAsXv1pavr8J4,19931
+boris/portion/io.py,sha256=kpq44pw3xnIyAlPwaR5qRHKRdZ72f8HS9YVIWs5k2pk,6367
+boris_behav_obs-9.6.2.dist-info/licenses/LICENSE.TXT,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
+boris_behav_obs-9.6.2.dist-info/METADATA,sha256=Y4dUMgXciZdoXdacbzA0NULwV7c0Cn9kEgveFCXVss4,4637
+boris_behav_obs-9.6.2.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+boris_behav_obs-9.6.2.dist-info/entry_points.txt,sha256=k__8XvFi4vaA4QFvQehCZjYkKmZH34HSAJI2iYCWrMs,52
+boris_behav_obs-9.6.2.dist-info/top_level.txt,sha256=fJSgm62S7WesiwTorGbOO4nNN0yzgZ3klgfGi3Px4qI,6
+boris_behav_obs-9.6.2.dist-info/RECORD,,