boris-behav-obs 9.6.1__py2.py3-none-any.whl → 9.6.3__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/analysis_plugins/time_budget.py

@@ -26,10 +26,6 @@ def run(df: pd.DataFrame):
     - % of total subject observation duration
     """
 
-    print("running time budget plugin")
-
-    print(df)
-
     group_by = ["Subject", "Behavior"]
 
     dfs = [

boris/behav_coding_map_creator.py

@@ -431,7 +431,6 @@ class BehaviorsMapCreatorWindow(QMainWindow):
                 self.selectedPolygon = None
                 self.selectedPolygonMemBrush = None
 
-            print(self.polygonsList2)
             idx = 0
             for areaCode, pg in self.polygonsList2:
                 if pg.contains(test):

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/coding_pad.py

@@ -261,8 +261,6 @@ def show_coding_pad(self):
         self.codingpad.setWindowFlags(Qt.WindowStaysOnTopHint)
         self.codingpad.sendEventSignal.connect(self.signal_from_widget)
 
-        print(f"{self.signal_from_widget=}")
-
         self.codingpad.clickSignal.connect(self.click_signal_from_coding_pad)
         self.codingpad.close_signal.connect(self.close_signal_from_coding_pad)
         self.codingpad.show()

boris/core.py

@@ -205,7 +205,6 @@ class TableModel(QAbstractTableModel):
             if 0 <= row < self.rowCount():
                 column = index.column()
 
-                # print(self._data[:3])
                 if cfg.TW_EVENTS_FIELDS[self.observation_type][column] == "type":
                     return self._data[row][-1]
                 else:
@@ -2137,39 +2136,47 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             set_and_update_pan_and_zoom(new_pan_x, new_pan_y, new_zoom)
 
         if cmd == "MBTN_LEFT_DBL":
-            print("left dbl")
+            logging.debug("MBTN_LEFT_DBL")
             # ZOOM IN x2
             do_zoom_in_clicked_coords(zoom_increment=1)
             return
         if cmd == "MBTN_RIGHT_DBL":
+            logging.debug("MBTN_RIGHT_DBL")
             # ZOOM OUT x2
             do_zoom_in_clicked_coords(zoom_increment=-1)
             return
         if cmd == "Ctrl+WHEEL_UP":
+            logging.debug("Ctrl+WHEEL_UP")
             # ZOOM IN (3 wheel steps to zoom X2)
             do_zoom_in_clicked_coords(zoom_increment=1.0 / 3.0)
             return
         if cmd == "Ctrl+WHEEL_DOWN":
+            logging.debug("Ctrl+WHEEL_DOWN")
             # ZOOM OUT (3 wheel steps to zoom X2)
             do_zoom_in_clicked_coords(zoom_increment=-1.0 / 3.0)
             return
         if cmd == "WHEEL_UP":
+            logging.debug("WHEEL_UP")
             # PAN UP (VIDEO MOVES DOWN)
             do_pan_in_clicked_coords(pan_x_increment=0, pan_y_increment=+0.01)
             return
         if cmd == "WHEEL_DOWN":
+            logging.debug("WHEEL_DOWN")
             # PAN DOWN (VIDEO MOVES UP)
             do_pan_in_clicked_coords(pan_x_increment=0, pan_y_increment=-0.01)
             return
         if cmd == "Shift+WHEEL_UP":
+            logging.debug("Shift+WHEEL_UP")
             # PAN LEFT (VIDEO MOVES TO THE RIGHT)
             do_pan_in_clicked_coords(pan_x_increment=+0.01, pan_y_increment=0)
             return
         if cmd == "Shift+WHEEL_DOWN":
+            logging.debug("Shift+WHEEL_DOWN")
             # PAN RIGHT (VIDEO MOVES TO THE LEFT)
             do_pan_in_clicked_coords(pan_x_increment=-0.01, pan_y_increment=0)
             return
         if cmd == "Shift+MBTN_LEFT":
+            logging.debug("Shift+MBTN_LEFT")
             # RESET PAN AND ZOOM TO DEFAULT
             set_and_update_pan_and_zoom(pan_x=0, pan_y=0, zoom=0)
             return
@@ -3745,21 +3752,10 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
             # calculate time for current media file in case of many queued media files
 
-            print(mediaFileIdx_s)
-            print(type(eventtime_s))
-            print(durations)
-
             eventtime_onmedia_s = round(eventtime_s - util.float2decimal(sum(durations[0:mediaFileIdx_s])), 3)
             eventtime_onmedia_e = round(eventtime_e - util.float2decimal(sum(durations[0:mediaFileIdx_e])), 3)
 
-            print(row_s, media_path_s, eventtime_s, eventtime_onmedia_s)
-            print(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][row_s])
-
-            print(row_e, media_path_e, eventtime_e, eventtime_onmedia_e)
-            print(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.EVENTS][row_e])
-
             if media_path_s != media_path_e:
-                print("events are located on 2 different media files")
                 return
 
             media_path = media_path_s
@@ -3770,7 +3766,6 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             if "BORISEXTERNAL" in os.environ:
                 external_command_template = os.environ["BORISEXTERNAL"]
             else:
-                print("BORISEXTERNAL env var not defined")
                 return
 
             external_command = external_command_template.format(
@@ -3853,11 +3848,6 @@ class MainWindow(QMainWindow, Ui_MainWindow):
 
             time_, cumulative_time = self.get_obs_time()
 
-            """
-            print(time_)
-            print(cumulative_time)
-            """
-
             if self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.MEDIA_CREATION_DATE_AS_OFFSET, False):
                 write_event.write_event(self, event, time_)
             else:
@@ -4263,7 +4253,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 +4351,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)
 
@@ -5224,25 +5212,20 @@ class MainWindow(QMainWindow, Ui_MainWindow):
             if (not self.find_dialog.cbFindInSelectedEvents.isChecked()) or (
                 self.find_dialog.cbFindInSelectedEvents.isChecked() and event_idx in self.find_dialog.rowsToFind
             ):
-                print(f"{event=}")
-
                 # search only on filtered events
                 if event_idx not in self.tv_idx2events_idx:
                     continue
 
                 for idx in fields_list:
-                    print(f"{idx=}")
                     if (self.find_dialog.cb_case_sensitive.isChecked() and self.find_dialog.findText.text() in event[idx]) or (
                         not self.find_dialog.cb_case_sensitive.isChecked()
                         and self.find_dialog.findText.text().upper() in event[idx].upper()
                     ):
                         self.find_dialog.currentIdx = event_idx
 
-                        # self.twEvents.scrollToItem(self.twEvents.item(event_idx, 0))
                         index = self.tv_events.model().index(event_idx, 0)
                         self.tv_events.scrollTo(index, QAbstractItemView.EnsureVisible)
                         self.tv_events.selectRow(event_idx)
-                        # self.twEvents.selectRow(event_idx)
                         return
 
         if msg != "FIND_FROM_BEGINING":

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/db_functions.py

@@ -188,7 +188,7 @@ def load_aggregated_events_in_db(
         selected_behaviors = sorted([pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE] for x in pj[cfg.ETHOGRAM]])
 
     # check if state events are paired
-    out = ""
+    out: str = ""
     for obs_id in selected_observations:
         r, msg = project_functions.check_state_events_obs(obs_id, pj[cfg.ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id], cfg.HHMMSS)
         if not r:
@@ -212,11 +212,11 @@ def load_aggregated_events_in_db(
 
     db = sqlite3.connect(":memory:")
 
-    """
     # only for debugging
+    """
     import os
-    os.system("rm /tmp/ramdisk/aggreg.sqlite")
-    db = sqlite3.connect("/tmp/ramdisk/aggreg.sqlite", isolation_level=None)
+    os.system("rm /tmp/ramdisk/aggregated_events.sqlite")
+    db = sqlite3.connect("/tmp/ramdisk/aggregated_events.sqlite", isolation_level=None)
     """
 
     db.row_factory = sqlite3.Row

boris/edit_event.py

@@ -128,8 +128,6 @@ class DlgEditEvent(QDialog, Ui_Form):
         set time to current media time
         """
 
-        print(f"{self.current_time=}")
-
         if self.observation_type in (cfg.LIVE, cfg.MEDIA):
             self.time_widget.set_time(dec(float(self.current_time)))
 
@@ -137,13 +135,6 @@ class DlgEditEvent(QDialog, Ui_Form):
             if self.exif_date_time is not None:
                 self.time_widget.set_time(dec(self.exif_date_time))
 
-    # def frame_idx_na(self):
-    #     """
-    #     set/unset frame index NA
-    #     """
-    #     self.lb_frame_idx.setEnabled(not self.cb_set_frame_idx_na.isChecked())
-    #     self.sb_frame_idx.setEnabled(not self.cb_set_frame_idx_na.isChecked())
-
     def time_na(self):
         """
         set/unset time to NA

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)