boris-behav-obs 8.16.6__py3-none-any.whl → 9.7.1__py3-none-any.whl

boris/ipc_mpv.py

@@ -0,0 +1,304 @@
+import socket
+import json
+import subprocess
+
+# from PySide6.QtCore import QTimer
+import logging
+import config as cfg
+
+logger = logging.getLogger(__name__)
+
+
+class IPC_MPV:
+    """
+    class for managing mpv through Inter Process Communication (IPC)
+    """
+
+    media_durations: list = []
+    cumul_media_durations: list = []
+    fps: list = []
+    _pause: bool = False
+
+    def __init__(self, socket_path: str = cfg.MPV_SOCKET, parent=None):
+        # print(f"{parent=}")
+        self.socket_path = socket_path
+        self.process = None
+        # self.sock = None
+        self.init_mpv()
+        # self.init_socket()
+
+    def init_mpv(self):
+        """
+        Start mpv process and embed it in the PySide6 application.
+        """
+        logger.info("Start mpv ipc process")
+        # print(f"{self.winId()=}")
+        self.process = subprocess.Popen(
+            [
+                "mpv",
+                "--no-border",
+                "--osc=no",  # no on screen commands
+                "--input-ipc-server=" + self.socket_path,
+                # "--wid=" + str(int(self.winId())),  # Embed in the widget
+                "--idle",  # Keeps mpv running with no video
+                "--input-default-bindings=no",
+                "--input-vo-keyboard=no",
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+    '''
+    def init_socket(self):
+        """
+        Initialize the JSON IPC socket.
+        """
+        print("init socket")
+        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        QTimer.singleShot(5000, self.connect_socket)  # Allow time for mpv to initialize
+    '''
+
+    '''
+    def connect_socket(self):
+        """
+        Connect to the mpv IPC socket.
+        """
+        print("connect socket")
+        try:
+            self.sock.connect(self.socket_path)
+            print("Connected to mpv IPC server.")
+        except socket.error as e:
+            print(f"Failed to connect to mpv IPC server: {e}")
+        print("end of connect_socket fucntion")
+    '''
+
+    def send_command(self, command):
+        """
+        Send a JSON command to the mpv IPC server.
+        """
+        # print(f"send command: {command}")
+        try:
+            # Create a Unix socket
+            with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client:
+                # Connect to the MPV IPC server
+                client.connect(self.socket_path)
+                # Send the JSON command
+                # print(f"{json.dumps(command).encode('utf-8')=}")
+                client.sendall(json.dumps(command).encode("utf-8") + b"\n")
+                # Receive the response
+                response = client.recv(2000)
+
+                # print(f"{response=}")
+                # Parse the response as JSON
+                response_data = json.loads(response.decode("utf-8"))
+                if response_data["error"] != "success":
+                    print(f"send command: {command}")
+                    print(f"{response_data=}")
+                    print()
+                # Return the 'data' field which contains the playback position
+                return response_data.get("data")
+        except FileNotFoundError:
+            logger.critical("Error: Socket file not found.")
+        except Exception as e:
+            logger.critical(f"An error occurred: {e}")
+        return None
+
+    @property
+    def time_pos(self):
+        time_pos = self.send_command({"command": ["get_property", "time-pos"]})
+        return time_pos
+
+    @property
+    def duration(self):
+        duration_ = self.send_command({"command": ["get_property", "duration"]})
+        return duration_
+
+    @property
+    def video_zoom(self):
+        return self.send_command({"command": ["get_property", "video-zoom"]})
+
+    @video_zoom.setter
+    def video_zoom(self, value):
+        self.send_command({"command": ["set_property", "video-zoom", value]})
+        return
+
+    @property
+    def pause(self):
+        return self.send_command({"command": ["get_property", "pause"]})
+
+    @pause.setter
+    def pause(self, value):
+        print(f"set pause to {value}")
+        return self.send_command({"command": ["set_property", "pause", value]})
+
+    @property
+    def estimated_frame_number(self):
+        return self.send_command({"command": ["get_property", "estimated-frame-number"]})
+
+    def stop(self):
+        self.send_command({"command": ["stop"]})
+        return
+
+    @property
+    def playlist(self):
+        return self.send_command({"command": ["get_property", "playlist"]})
+
+    @property
+    def playlist_pos(self):
+        return self.send_command({"command": ["get_property", "playlist-pos"]})
+
+    @playlist_pos.setter
+    def playlist_pos(self, value):
+        return self.send_command({"command": ["set_property", "playlist-pos", value]})
+
+    @property
+    def playlist_count(self):
+        return self.send_command({"command": ["get_property", "playlist-count"]})
+
+    def playlist_append(self, media):
+        return self.send_command({"command": ["loadfile", media, "append"]})
+
+    def wait_until_playing(self):
+        return
+
+    def seek(self, value, mode: str):
+        self.send_command({"command": ["seek", value, mode]})
+        return
+
+    @property
+    def playback_time(self):
+        playback_time_ = self.send_command({"command": ["get_property", "playback-time"]})
+        print(f"playback_time: {playback_time_}")
+        return playback_time_
+
+    def frame_step(self):
+        self.send_command({"command": ["frame-step"]})
+        return
+
+    def frame_back_step(self):
+        self.send_command({"command": ["frame-back-step"]})
+        return
+
+    def screenshot_to_file(self, value):
+        self.send_command({"command": ["screenshot-to-file", value, "video"]})
+        return
+
+    @property
+    def speed(self):
+        return self.send_command({"command": ["get_property", "speed"]})
+
+    @speed.setter
+    def speed(self, value):
+        self.send_command({"command": ["set_property", "speed", value]})
+        return
+
+    @property
+    def video_rotate(self):
+        return self.send_command({"command": ["get_property", "video-rotate"]})
+
+    @video_rotate.setter
+    def video_rotate(self, value):
+        self.send_command({"command": ["set_property", "video-rotate", value]})
+        return
+
+    @property
+    def sub_visibility(self):
+        return self.send_command({"command": ["get_property", "sub-visibility"]})
+
+    @sub_visibility.setter
+    def sub_visibility(self, value):
+        self.send_command({"command": ["set_property", "sub-visibility", value]})
+        return
+
+    @property
+    def brightness(self):
+        return self.send_command({"command": ["get_property", "brightness"]})
+
+    @brightness.setter
+    def brightness(self, value):
+        self.send_command({"command": ["set_property", "brightness", value]})
+        return
+
+    @property
+    def contrast(self):
+        return self.send_command({"command": ["get_property", "contrast"]})
+
+    @contrast.setter
+    def contrast(self, value):
+        self.send_command({"command": ["set_property", "contrast", value]})
+        return
+
+    @property
+    def saturation(self):
+        return self.send_command({"command": ["get_property", "saturation"]})
+
+    @saturation.setter
+    def saturation(self, value):
+        self.send_command({"command": ["set_property", "saturation", value]})
+        return
+
+    @property
+    def gamma(self):
+        return self.send_command({"command": ["get_property", "gamma"]})
+
+    @gamma.setter
+    def gamma(self, value):
+        self.send_command({"command": ["set_property", "gamma", value]})
+        return
+
+    @property
+    def hue(self):
+        return self.send_command({"command": ["get_property", "hue"]})
+
+    @hue.setter
+    def hue(self, value):
+        self.send_command({"command": ["set_property", "hue", value]})
+        return
+
+    @property
+    def container_fps(self):
+        return self.send_command({"command": ["get_property", "container-fps"]})
+
+    @property
+    def width(self):
+        return self.send_command({"command": ["get_property", "width"]})
+
+    @property
+    def height(self):
+        return self.send_command({"command": ["get_property", "height"]})
+
+    @property
+    def video_format(self):
+        return self.send_command({"command": ["get_property", "video-format"]})
+
+    @property
+    def deinterlace(self):
+        return self.send_command({"command": ["get_property", "deinterlace"]})
+
+    @deinterlace.setter
+    def deinterlace(self, value):
+        self.send_command({"command": ["set_property", "deinterlace", value]})
+        return
+
+    @property
+    def audio_bitrate(self):
+        return self.send_command({"command": ["get_property", "audio-bitrate"]})
+
+    @property
+    def eof_reached(self):
+        return self.send_command({"command": ["get_property", "eof-reached"]})
+
+    @property
+    def core_idle(self):
+        return self.send_command({"command": ["get_property", "core-idle"]})
+
+    """
+    @property
+    def xxx(self):
+        return self.send_command({"command": ["get_property", "xxx"]})
+
+    @xxx.setter
+    def xxx(self, value):
+        self.send_command({"command": ["set_property", "xxx", value]})
+        return
+    """

boris/irr.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 
   This program is free software; you can redistribute it and/or modify
@@ -25,7 +25,7 @@ import logging
 from decimal import Decimal as dec
 
 import numpy as np
-from PyQt5.QtWidgets import QInputDialog, QMessageBox
+from PySide6.QtWidgets import QInputDialog, QMessageBox
 
 from . import config as cfg
 from . import db_functions, dialog, project_functions, select_subj_behav
@@ -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,27 +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]
 
@@ -162,10 +153,8 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
 
     currentTime = dec(str(first_event))
     while currentTime <= last_event:
-
         for obsid in [obsid1, obsid2]:
             for subject in selected_subjects:
-
                 s = subj_behav_modif(cursor, obsid, subject, currentTime, interval, include_modifiers)
 
                 if s not in total_states:
@@ -185,11 +174,9 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     seq2 = {}
     currentTime = dec(str(first_event))
     while currentTime <= last_event:
-
         seq1[currentTime] = []
         seq2[currentTime] = []
         for subject in selected_subjects:
-
             s1 = subj_behav_modif(cursor, obsid1, subject, currentTime, interval, include_modifiers)
             s2 = subj_behav_modif(cursor, obsid2, subject, currentTime, interval, include_modifiers)
 
@@ -211,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))
@@ -298,8 +281,8 @@ def irr_cohen_kappa(self):
         selected_observations,
         start_coding=dec("NaN"),
         end_coding=dec("NaN"),
-        flagShowIncludeModifiers=True,
-        flagShowExcludeBehaviorsWoEvents=False,
+        show_include_modifiers=True,
+        show_exclude_non_coded_behaviors=False,
         n_observations=len(selected_observations),
     )
     if parameters == {}:
@@ -309,9 +292,7 @@ def irr_cohen_kappa(self):
         return
 
     # ask for time slice
-    i, ok = QInputDialog.getDouble(
-        self, "IRR - Cohen's Kappa (time-unit)", "Time unit (in seconds):", 1.0, 0.001, 86400, 3
-    )
+    i, ok = QInputDialog.getDouble(self, "IRR - Cohen's Kappa (time-unit)", "Time unit (in seconds):", 1.0, 0.001, 86400, 3)
     if not ok:
         return
     interval = util.float2decimal(i)
@@ -354,7 +335,7 @@ def irr_cohen_kappa(self):
         out2 += "\t".join(["%8.6f" % x for x in irr_results[r, :]]) + "\n"
 
     self.results = dialog.Results_dialog()
-    self.results.setWindowTitle(f"BORIS - IRR - Cohen's Kappa (time-unit) analysis results")
+    self.results.setWindowTitle("BORIS - IRR - Cohen's Kappa (time-unit) analysis results")
     self.results.ptText.setReadOnly(True)
     if len(selected_observations) == 2:
         self.results.ptText.appendPlainText(out)
@@ -363,9 +344,7 @@ def irr_cohen_kappa(self):
     self.results.show()
 
 
-def needleman_wunsch_identity(
-    cursor, obsid1: str, obsid2: str, interval, selected_subjects: list, include_modifiers: bool
-):
+def needleman_wunsch_identity(cursor, obsid1: str, obsid2: str, interval, selected_subjects: list, include_modifiers: bool):
     """
     Needleman - Wunsch identity between 2 observations
 
@@ -484,13 +463,12 @@ def needleman_wunsch_identity(
     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]
 
     if first_event is None:
-
         logging.debug(f"An observation has no recorded events: {obsid1} or {obsid2}")
 
         return -100, f"An observation has no recorded events: {obsid1} {obsid2}"
@@ -498,28 +476,19 @@ def needleman_wunsch_identity(
     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]
 
@@ -528,11 +497,9 @@ def needleman_wunsch_identity(
 
     currentTime = dec(str(first_event))
     while currentTime <= last_event:
-
         seq1[currentTime], seq2[currentTime] = [], []
 
         for subject in selected_subjects:
-
             s1 = subj_behav_modif(cursor, obsid1, subject, currentTime, interval, include_modifiers)
             s2 = subj_behav_modif(cursor, obsid2, subject, currentTime, interval, include_modifiers)
 
@@ -574,9 +541,7 @@ def needleman_wunch(self):
     if not selected_observations:
         return
     if len(selected_observations) < 2:
-        QMessageBox.information(
-            self, cfg.programName, "You have to select at least 2 observations for Needleman-Wunsch similarity"
-        )
+        QMessageBox.information(self, cfg.programName, "You have to select at least 2 observations for Needleman-Wunsch similarity")
         return
 
     # check if coded behaviors are defined in ethogram
@@ -606,8 +571,8 @@ def needleman_wunch(self):
         selected_observations,
         start_coding=dec("NaN"),
         end_coding=dec("NaN"),
-        flagShowIncludeModifiers=True,
-        flagShowExcludeBehaviorsWoEvents=False,
+        show_include_modifiers=True,
+        show_exclude_non_coded_behaviors=False,
         n_observations=len(selected_observations),
     )
 
@@ -631,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/latency.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -18,9 +18,7 @@ Copyright 2012-2023 Olivier Friard
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
   MA 02110-1301, USA.
 
-"""
 
-"""
 Module for analyzing the latency of behaviors after another behavior(s) (marker)
 
 """
@@ -31,7 +29,7 @@ from . import dialog
 from . import select_observations
 from . import project_functions, observation_operations
 
-from PyQt5.QtWidgets import QMessageBox
+from PySide6.QtWidgets import QMessageBox
 
 
 def get_latency(self):
@@ -43,10 +41,9 @@ def get_latency(self):
         None,
         cfg.programName,
         (
-            f"This function is experimental. Please test it and report any bug at <br>"
+            "This function is experimental. Please test it and report any bug at <br>"
             '<a href="https://github.com/olivierfriard/BORIS/issues">'
             "https://github.com/olivierfriard/BORIS/issues</a><br>"
-            "or by email (See the About page on the BORIS web site.<br><br>"
             "Thank you for your collaboration!"
         ),
         QMessageBox.Ok | QMessageBox.Default,
@@ -83,10 +80,10 @@ def get_latency(self):
         )
         return
 
-    parameters = select_subj_behav.choose_obs_subj_behav_category(
+    parameters: dict = select_subj_behav.choose_obs_subj_behav_category(
         self,
         selected_observations,
-        flagShowExcludeBehaviorsWoEvents=False,
+        show_exclude_non_coded_behaviors=False,
         window_title="Select the marker behaviors (stimulus)",
         n_observations=len(selected_observations),
     )
@@ -102,10 +99,10 @@ def get_latency(self):
     marker_subjects = parameters[cfg.SELECTED_SUBJECTS]
     include_marker_modifiers = parameters[cfg.INCLUDE_MODIFIERS]
 
-    # print(f"{marker_behaviors=} {marker_subjects=} {include_marker_modifiers=}")
+    print(f"{marker_behaviors=} {marker_subjects=} {include_marker_modifiers=}")
 
-    parameters = select_subj_behav.choose_obs_subj_behav_category(
-        self, selected_observations, flagShowExcludeBehaviorsWoEvents=False, window_title="Select the latency behaviors"
+    parameters: dict = select_subj_behav.choose_obs_subj_behav_category(
+        self, selected_observations, show_exclude_non_coded_behaviors=False, window_title="Select the latency behaviors"
     )
     if not parameters[cfg.SELECTED_SUBJECTS] or not parameters[cfg.SELECTED_BEHAVIORS]:
         return
@@ -113,11 +110,11 @@ def get_latency(self):
     latency_subjects = parameters[cfg.SELECTED_SUBJECTS]
     include_latency_modifiers = parameters[cfg.INCLUDE_MODIFIERS]
 
-    # print(f"{latency_behaviors=} {latency_subjects=} {include_latency_modifiers=}")
+    print(f"{latency_behaviors=} {latency_subjects=} {include_latency_modifiers=}")
 
-    results = {}
+    results: dict = {}
     for obs_id in selected_observations:
-        # print(f"{obs_id=}")
+        print(f"{obs_id=}")
 
         events_with_status = project_functions.events_start_stop(
             self.pj[cfg.ETHOGRAM],
@@ -125,7 +122,17 @@ def get_latency(self):
             self.pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE],
         )
 
+        print(f"{events_with_status=}")
+
         for idx, event in enumerate(events_with_status):
+            print(f"{event=}")
+
+            print(f"{event[cfg.EVENT_STATUS_FIELD_IDX]=}")
+
+            print(f"{event[cfg.EVENT_BEHAVIOR_FIELD_IDX]=}")
+
+            print(f"{event[cfg.EVENT_SUBJECT_FIELD_IDX]=}")
+
             if all(
                 (
                     event[cfg.EVENT_STATUS_FIELD_IDX] in (cfg.START, cfg.POINT),
@@ -138,11 +145,13 @@ def get_latency(self):
                     ),
                 )
             ):
-
                 if include_marker_modifiers:
                     marker = event[cfg.EVENT_TIME_FIELD_IDX : cfg.EVENT_MODIFIER_FIELD_IDX + 1]
                 else:
                     marker = event[cfg.EVENT_TIME_FIELD_IDX : cfg.EVENT_BEHAVIOR_FIELD_IDX + 1]
+
+                print(f"{marker=}")
+
                 if marker not in results:
                     results[marker] = {}
 
@@ -164,20 +173,19 @@ def get_latency(self):
                             ),
                         )
                     ):
-
-                        # print(event, event2)
+                        print(event, event2)
                         if include_latency_modifiers:
                             latency = event2[cfg.EVENT_SUBJECT_FIELD_IDX : cfg.EVENT_MODIFIER_FIELD_IDX + 1]
                         else:
                             latency = event2[cfg.EVENT_SUBJECT_FIELD_IDX : cfg.EVENT_BEHAVIOR_FIELD_IDX + 1]
 
                         # print(f"{marker=}")
-                        # print(f"{latency=}")
-                        if not latency in results[marker]:
+                        print(f"{latency=}")
+                        if latency not in results[marker]:
                             results[marker][latency] = []
-                        results[marker][latency].append(
-                            event2[cfg.EVENT_TIME_FIELD_IDX] - event[cfg.EVENT_TIME_FIELD_IDX]
-                        )
+                        results[marker][latency].append(event2[cfg.EVENT_TIME_FIELD_IDX] - event[cfg.EVENT_TIME_FIELD_IDX])
+
+                        print(f"{results[marker][latency]=}")
 
                     # check if new marker
                     if all(
@@ -208,7 +216,6 @@ def get_latency(self):
     out = ""
 
     for marker in sorted(results.keys()):
-
         subject = cfg.NO_FOCAL_SUBJECT if marker[cfg.EVENT_SUBJECT_FIELD_IDX] == "" else marker[1]
         if include_marker_modifiers:
             out += f"Marker: <b>{marker[cfg.EVENT_BEHAVIOR_FIELD_IDX]}</b> at {marker[cfg.EVENT_TIME_FIELD_IDX]} s (subject: {subject} - modifiers: {marker[cfg.EVENT_MODIFIER_FIELD_IDX]})<br><br>"
@@ -223,7 +230,7 @@ def get_latency(self):
 
             out += "first occurrence: "
             out += f"{sorted(results[marker][behav])[0]} s<br>"
-            out += f"all occurrences: "
+            out += "all occurrences: "
 
             out += ", ".join([f"{x} s" for x in sorted(results[marker][behav])])
             out += "<br><br>"