boris-behav-obs 8.9.16__py3-none-any.whl → 9.7.6__py3-none-any.whl

boris/project_functions.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
@@ -22,24 +22,25 @@ Copyright 2012-2023 Olivier Friard
 import gzip
 import json
 import logging
-import os
-import pathlib as pl
+import pandas as pd
+import numpy as np
+from pathlib import Path
 import sys
 from decimal import Decimal as dec
 from shutil import copyfile
 from typing import List, Tuple, Dict
 
 import tablib
-from PyQt5.QtWidgets import QMessageBox, QTableWidgetItem
-from PyQt5.QtCore import Qt
+from PySide6.QtWidgets import QMessageBox, QTableWidgetItem, QAbstractItemView
+from PySide6.QtCore import Qt
 
 from . import config as cfg
 from . import db_functions
 from . import dialog
+from . import observation_operations
 from . import portion as I
 from . import utilities as util
 from . import version
-from . import observation_operations
 
 
 def check_observation_exhaustivity(
@@ -56,6 +57,9 @@ def check_observation_exhaustivity(
     """
 
     def interval_len(interval: I) -> dec:
+        """ "
+        returns duration of an interval or a set of intervals
+        """
         if interval.empty:
             return dec(0)
         else:
@@ -73,18 +77,18 @@ def check_observation_exhaustivity(
             events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]] = I.empty()
             mem_events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]] = []
 
+        # state event
         if event[cfg.EVENT_BEHAVIOR_FIELD_IDX] in state_events_list:
             mem_events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]].append(
                 event[cfg.EVENT_TIME_FIELD_IDX]
             )
             if len(mem_events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]]) == 2:
-                events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][
-                    event[cfg.EVENT_BEHAVIOR_FIELD_IDX]
-                ] |= I.closedopen(
+                events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]] |= I.closedopen(
                     mem_events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]][0],
                     mem_events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]][1],
                 )
                 mem_events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]] = []
+        # point event
         else:
             events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]] |= I.singleton(
                 event[cfg.EVENT_TIME_FIELD_IDX]
@@ -92,13 +96,13 @@ def check_observation_exhaustivity(
 
     if events:
         # coding duration
-        obs_theo_dur = max(events)[cfg.EVENT_TIME_FIELD_IDX] - min(events)[cfg.EVENT_TIME_FIELD_IDX]
+        event_timestamps = [event[cfg.EVENT_TIME_FIELD_IDX] for event in events]
+        obs_theo_dur = max(event_timestamps) - min(event_timestamps)
     else:
         obs_theo_dur = dec("0")
 
     total_duration = 0
     for subject in events_interval:
-
         tot_behav_for_subject = I.empty()
         for behav in events_interval[subject]:
             tot_behav_for_subject |= events_interval[subject][behav]
@@ -241,6 +245,18 @@ def check_coded_behaviors_in_obs_list(pj: dict, observations_list: list) -> bool
     return False
 
 
+def get_modifiers_of_behavior(ethogram, behavior: str) -> list:
+    """
+    get all modifiers for a behavior (if any)
+    """
+
+    return [
+        [ethogram[x][cfg.MODIFIERS][y]["values"] for y in ethogram[x][cfg.MODIFIERS]]
+        for x in ethogram
+        if ethogram[x][cfg.BEHAVIOR_CODE] == behavior
+    ]
+
+
 def check_coded_behaviors(pj: dict) -> set:
     """
     check if behaviors coded in events are defined in ethogram for all observations
@@ -249,7 +265,7 @@ def check_coded_behaviors(pj: dict) -> set:
         pj (dict): project dictionary
 
     Returns:
-        set: behaviors present in observations that are not define in ethogram
+        set: behaviors present in observations that are not defined in ethogram
     """
 
     # set of behaviors defined in ethogram
@@ -263,9 +279,7 @@ def check_coded_behaviors(pj: dict) -> set:
     return set(sorted(behaviors_not_defined))
 
 
-def check_state_events_obs(
-    obsId: str, ethogram: dict, observation: dict, time_format: str = cfg.HHMMSS
-) -> Tuple[bool, str]:
+def check_state_events_obs(obsId: str, ethogram: dict, observation: dict, time_format: str = cfg.HHMMSS) -> Tuple[bool, str]:
     """
     check state events for the observation obsId
     check if behaviors in observation are defined in ethogram
@@ -281,7 +295,7 @@ def check_state_events_obs(
         tuple (bool, str): if OK True else False , message
     """
 
-    out = ""
+    out: str = ""
 
     # check if behaviors are defined as "state event"
     event_types = {ethogram[idx]["type"] for idx in ethogram}
@@ -289,16 +303,13 @@ def check_state_events_obs(
     if not event_types or event_types == {"Point event"}:
         return (True, "No behavior is defined as `State event`")
 
-    flagStateEvent = False
     subjects = [event[cfg.EVENT_SUBJECT_FIELD_IDX] for event in observation[cfg.EVENTS]]
     ethogram_behaviors = {ethogram[idx][cfg.BEHAVIOR_CODE] for idx in ethogram}
+    state_behaviors = set(util.state_behavior_codes(ethogram))
 
     for subject in sorted(set(subjects)):
-
         behaviors = [
-            event[cfg.EVENT_BEHAVIOR_FIELD_IDX]
-            for event in observation[cfg.EVENTS]
-            if event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject
+            event[cfg.EVENT_BEHAVIOR_FIELD_IDX] for event in observation[cfg.EVENTS] if event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject
         ]
 
         for behavior in sorted(set(behaviors)):
@@ -306,32 +317,35 @@ def check_state_events_obs(
                 # return (False, "The behaviour <b>{}</b> is not defined in the ethogram.<br>".format(behavior))
                 continue
             else:
-                if cfg.STATE in event_type(behavior, ethogram).upper():
-                    flagStateEvent = True
-                    lst, memTime = [], {}
-                    for event in [
-                        event
-                        for event in observation[cfg.EVENTS]
-                        if event[cfg.EVENT_BEHAVIOR_FIELD_IDX] == behavior
-                        and event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject
-                    ]:
-
-                        behav_modif = [event[cfg.EVENT_BEHAVIOR_FIELD_IDX], event[cfg.EVENT_MODIFIER_FIELD_IDX]]
-
-                        if behav_modif in lst:
-                            lst.remove(behav_modif)
-                            del memTime[str(behav_modif)]
-                        else:
-                            lst.append(behav_modif)
-                            memTime[str(behav_modif)] = event[cfg.EVENT_TIME_FIELD_IDX]
-
-                    for event in lst:
-                        out += (
-                            f"The behavior <b>{behavior}</b> "
-                            f"{('(modifier ' + event[1] + ') ') if event[1] else ''} is not PAIRED "
-                            f'for subject "<b>{subject if subject else cfg.NO_FOCAL_SUBJECT}</b>" at '
-                            f"<b>{memTime[str(event)] if time_format == cfg.S else util.seconds2time(memTime[str(event)])}</b><br>"
-                        )
+                if behavior not in state_behaviors:
+                    continue
+
+                lst: list = []
+                memTime: dict = {}
+                for event in [
+                    event
+                    for event in observation[cfg.EVENTS]
+                    if event[cfg.EVENT_BEHAVIOR_FIELD_IDX] == behavior and event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject
+                ]:
+                    behav_modif = [
+                        event[cfg.EVENT_BEHAVIOR_FIELD_IDX],
+                        event[cfg.EVENT_MODIFIER_FIELD_IDX],
+                    ]
+
+                    if behav_modif in lst:
+                        lst.remove(behav_modif)
+                        del memTime[str(behav_modif)]
+                    else:
+                        lst.append(behav_modif)
+                        memTime[str(behav_modif)] = event[cfg.EVENT_TIME_FIELD_IDX]
+
+                for event in lst:
+                    out += (
+                        f"The behavior <b>{behavior}</b> "
+                        f"{('(modifier ' + event[1] + ') ') if event[1] else ''} is not PAIRED "
+                        f'for subject "<b>{subject if subject else cfg.NO_FOCAL_SUBJECT}</b>" at '
+                        f"<b>{memTime[str(event)] if time_format == cfg.S else util.seconds2time(memTime[str(event)])}</b><br>"
+                    )
 
     return (False, out) if out else (True, "No problem detected")
 
@@ -342,6 +356,8 @@ def check_state_events(pj: dict, observations_list: list) -> Tuple[bool, tuple]:
     use check_state_events_obs function
     """
 
+    logging.info("Check state events function")
+
     out = ""
     not_paired_obs_list = []
     for obs_id in observations_list:
@@ -367,21 +383,28 @@ def check_state_events(pj: dict, observations_list: list) -> Tuple[bool, tuple]:
     if not new_observations_list:
         QMessageBox.warning(None, cfg.programName, "The observation list is empty")
 
+    logging.info("Check state events done")
+
     return False, new_observations_list  # no state events are unpaired
 
 
 def check_project_integrity(
-    pj: dict, time_format: str, project_file_name: str, media_file_available: bool = True
+    pj: dict,
+    time_format: str,
+    project_file_name: str,
+    media_file_available: bool = True,
 ) -> str:
     """
-    check project integrity
-    check if behaviors in observations are in ethogram
-    check unpaired state events
-    check if behavior belong to behavioral category that do not more exist
-    check for leading and trailing spaces and special chars in modifiers
-    check if media file are available
-    check if media length available
-    check independent variables
+    check project integrity:
+    * check if coded behaviors are defined in ethogram
+    * check unpaired state events
+    * check if timestamp between -2147483647 and 2147483647 (2**31 - 1)
+    * check if behavior belong to behavioral category that do not more exist
+    * check for leading and trailing spaces and special chars in modifiers
+    * check if media file are available (optional)
+    * check if media length available
+    * check independent variables
+    * check if coded subjects are defined
 
     Args:
         pj (dict): BORIS project
@@ -391,8 +414,12 @@ def check_project_integrity(
 
     Returns:
         str: message
+
+
+    TODO: implement check on order of events (for live and media)
+
     """
-    out = ""
+    out: str = ""
 
     # check if coded behaviors are defined in ethogram
     r = check_coded_behaviors(pj)
@@ -428,7 +455,7 @@ def check_project_integrity(
                     out += (
                         "The following <b>modifier</b> defined in ethogram "
                         "has leading/trailing spaces or special chars: "
-                        f"<b>{util.replace_leading_trailing_chars(modifier_code.replace, ' ', '&#9608;')}</b>"
+                        f"<b>{util.replace_leading_trailing_chars(modifier_code, old_char=' ', new_char='&#9608;')}</b>"
                     )
 
     # check if all media are available
@@ -439,13 +466,16 @@ def check_project_integrity(
                 out += "<br><br>" if out else ""
                 out += f"Observation: <b>{obs_id}</b><br>{msg}"
 
-    # check if media length available
+    out_events: str = ""
     for obs_id in pj[cfg.OBSERVATIONS]:
+        # check if timestamp between -2147483647 and 2147483647
+        for event in pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]:
+            timestamp = event[cfg.PJ_OBS_FIELDS[pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE]][cfg.TIME]]
+            if not timestamp.is_nan() and not (-2147483647 <= timestamp <= 2147483647):
+                out_events += f"Observation: <b>{obs_id}</b><br>The timestamp {timestamp} is not between -2147483647 and 2147483647.<br>"
 
-        # TODO: add images observations
-        if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] in [cfg.LIVE]:
-            continue
-
+        """
+        # check if media length available
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] == cfg.MEDIA:
             for nplayer in cfg.ALL_PLAYERS:
                 if nplayer in pj[cfg.OBSERVATIONS][obs_id][cfg.FILE]:
@@ -455,6 +485,10 @@ def check_project_integrity(
                         except KeyError:
                             out += "<br><br>" if out else ""
                             out += f"Observation: <b>{obs_id}</b><br>Length not available for media file <b>{media_file}</b>"
+        """
+
+    out += "<br><br>" if out else ""
+    out += out_events
 
     # check for leading/trailing spaces/special chars in observation id
     for obs_id in pj[cfg.OBSERVATIONS]:
@@ -481,28 +515,98 @@ def check_project_integrity(
     if not_defined:
         out += "<br><br>" if out else ""
         for var_label in not_defined:
-            out += f"The independent variable <b>{util.replace_leading_trailing_chars(var_label, ' ', '&#9608;')}</b> present in {len(not_defined[var_label])} observation(s) is not defined.<br>"
+            out += (
+                f"The independent variable <b>{util.replace_leading_trailing_chars(var_label, ' ', '&#9608;')}</b> "
+                f"present in {len(not_defined[var_label])} observation(s) is not defined.<br>"
+            )
 
     # check values of independent variables
     defined_set_var_label: dict = dict(
         [
-            (pj[cfg.INDEPENDENT_VARIABLES][idx]["label"], pj[cfg.INDEPENDENT_VARIABLES][idx]["possible values"])
+            (
+                pj[cfg.INDEPENDENT_VARIABLES][idx]["label"],
+                pj[cfg.INDEPENDENT_VARIABLES][idx]["possible values"],
+            )
             for idx in pj.get(cfg.INDEPENDENT_VARIABLES, {})
             if pj[cfg.INDEPENDENT_VARIABLES][idx]["type"] == "value from set"
         ]
     )
 
-    out += "<br><br>" if out else ""
+    tmp_out: str = ""
     for obs_id in pj[cfg.OBSERVATIONS]:
         if cfg.INDEPENDENT_VARIABLES not in pj[cfg.OBSERVATIONS][obs_id]:
             continue
         for var_label in pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES]:
             if var_label in defined_set_var_label:
-                if pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES][var_label] not in defined_set_var_label[
-                    var_label
-                ].split(","):
+                if pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES][var_label] not in defined_set_var_label[var_label].split(","):
+                    tmp_out += (
+                        f"{obs_id}: the <b>{pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES][var_label]}</b> value "
+                        f" is not allowed for {var_label} (choose between {defined_set_var_label[var_label]})<br>"
+                    )
+    if tmp_out:
+        out += "<br><br>" if out else ""
+        out += tmp_out
 
-                    out += f"{obs_id}: the <b>{pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES][var_label]}</b> value  is not allowed for {var_label} (choose between {defined_set_var_label[var_label]})<br>"
+    # check if coded subjects are defined in the subjects list
+    tmp_out: str = ""
+    subjects_list: list = [pj[cfg.SUBJECTS][x]["name"] for x in pj[cfg.SUBJECTS]]
+    coded_subjects = set(util.flatten_list([[y[1] for y in pj[cfg.OBSERVATIONS][x].get(cfg.EVENTS, [])] for x in pj[cfg.OBSERVATIONS]]))
+
+    for subject in coded_subjects:
+        if subject and subject not in subjects_list:
+            tmp_out += f"The coded subject <b>{subject}</b> is not defined in the subjects list.<br>You can use the <b>Explore project</b> to fix it.<br><br>"
+    if tmp_out:
+        out += "<br><br>" if out else ""
+        out += tmp_out
+
+    # check if media file have info in media_info section of project
+    tmp_out: str = ""
+    for obs_id in pj[cfg.OBSERVATIONS]:
+        for player in pj[cfg.OBSERVATIONS][obs_id][cfg.FILE]:
+            for media_file in pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][player]:
+                for info in (cfg.LENGTH, cfg.FPS, cfg.HAS_AUDIO, cfg.HAS_VIDEO):
+                    if media_file not in pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO].get(info, {}):
+                        tmp_out += f"Observation <b>{obs_id}</b>:<br>"
+                        tmp_out += f"The media file {media_file} has no <b>{info}</b> info.<br>"
+    if tmp_out:
+        tmp_out += "<br>You should repick the media file to fix this issue."
+        out += "<br><br>" if out else ""
+        out += tmp_out
+
+    # check if the number of coded modifiers correspond to the number of sets of modifier
+    obs_results: dict = {}
+    for obs_id in pj[cfg.OBSERVATIONS]:
+        for event_idx, event in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]):
+            # event[2]
+            for idx in pj[cfg.ETHOGRAM]:
+                if pj[cfg.ETHOGRAM][idx]["code"] == event[2]:
+                    break
+            else:
+                raise
+            if (not event[3]) and not pj[cfg.ETHOGRAM][idx][cfg.MODIFIERS]:
+                continue
+
+            if len(event[3].split("|")) != len(pj[cfg.ETHOGRAM][idx][cfg.MODIFIERS]):
+                print("behavior", event[2])
+                print(f"modifier(s) #{event[3]}#", len(event[3].split("|")))
+                print(pj[cfg.ETHOGRAM][idx]["code"], pj[cfg.ETHOGRAM][idx][cfg.MODIFIERS])
+                print()
+                if obs_id not in obs_results:
+                    obs_results[obs_id] = []
+
+                obs_results[obs_id].append(
+                    (
+                        f"Event #{event_idx}: the coded modifiers for {event[2]} are {len(event[3].split('|'))} "
+                        f"but {len(pj[cfg.ETHOGRAM][idx][cfg.MODIFIERS])} sets were defined in ethogram."
+                    )
+                )
+
+    if obs_results:
+        out += "<br><br>" if out else ""
+        for o in obs_results:
+            out += f"<br>Observation <b>{o}</b>:<br>"
+            out += "<br>".join(obs_results[o])
+            out += "<br><br>"
 
     return out
 
@@ -537,14 +641,17 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
             return "", ""
         else:
             return (
-                f"""<font color="{cfg.subtitlesColors[
-                        parameters[cfg.SELECTED_SUBJECTS].index(row['subject']) % len(cfg.subtitlesColors)
-                    ]}">""",
+                f"""<font color="{
+                    cfg.subtitlesColors[parameters[cfg.SELECTED_SUBJECTS].index(row["subject"]) % len(cfg.subtitlesColors)]
+                }">""",
                 "</font>",
             )
 
     ok, msg, db_connector = db_functions.load_aggregated_events_in_db(
-        pj, parameters[cfg.SELECTED_SUBJECTS], selected_observations, parameters[cfg.SELECTED_BEHAVIORS]
+        pj,
+        parameters[cfg.SELECTED_SUBJECTS],
+        selected_observations,
+        parameters[cfg.SELECTED_BEHAVIORS],
     )
     if not ok:
         return False, msg
@@ -588,7 +695,11 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                         ",".join(["?"] * len(parameters[cfg.SELECTED_SUBJECTS])),
                         ",".join(["?"] * len(parameters[cfg.SELECTED_BEHAVIORS])),
                     ),
-                    [obs_id, float(parameters[cfg.START_TIME]), float(parameters[cfg.END_TIME])]
+                    [
+                        obs_id,
+                        float(parameters[cfg.START_TIME]),
+                        float(parameters[cfg.END_TIME]),
+                    ]
                     + parameters[cfg.SELECTED_SUBJECTS]
                     + parameters[cfg.SELECTED_BEHAVIORS],
                 )
@@ -599,14 +710,12 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                     modifiers_str = f"\n{row['modifiers'].replace('|', ', ')}"
                 else:
                     modifiers_str = ""
-                out += (
-                    "{idx}\n" "{start} --> {stop}\n" "{col1}{subject}: {behavior}" "{modifiers}" "{col2}\n\n"
-                ).format(
+                out += ("{idx}\n{start} --> {stop}\n{col1}{subject}: {behavior}{modifiers}{col2}\n\n").format(
                     idx=idx + 1,
                     start=util.seconds2time(row["start"]).replace(".", ","),
-                    stop=util.seconds2time(
-                        row["stop"] if row["type"] == cfg.STATE else row["stop"] + cfg.POINT_EVENT_ST_DURATION
-                    ).replace(".", ","),
+                    stop=util.seconds2time(row["stop"] if row["type"] == cfg.STATE else row["stop"] + cfg.POINT_EVENT_ST_DURATION).replace(
+                        ".", ","
+                    ),
                     col1=col1,
                     col2=col2,
                     subject=row["subject"],
@@ -614,13 +723,19 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                     modifiers=modifiers_str,
                 )
 
-            file_name = pl.Path(export_dir) / pl.Path(util.safeFileName(obs_id)).with_suffix(".srt")
+            file_name = Path(export_dir) / Path(util.safeFileName(obs_id)).with_suffix(".srt")
 
             if mem_command not in (cfg.OVERWRITE_ALL, cfg.SKIP_ALL) and file_name.is_file():
                 mem_command = dialog.MessageDialog(
                     cfg.programName,
                     f"The file {file_name} already exists.",
-                    [cfg.OVERWRITE, cfg.OVERWRITE_ALL, cfg.SKIP, cfg.SKIP_ALL, cfg.CANCEL],
+                    [
+                        cfg.OVERWRITE,
+                        cfg.OVERWRITE_ALL,
+                        cfg.SKIP,
+                        cfg.SKIP_ALL,
+                        cfg.CANCEL,
+                    ],
                 )
                 if mem_command == cfg.CANCEL:
                     return False, ""
@@ -635,7 +750,6 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                 msg += f"observation: {obs_id}\ngave the following error:\n{str(sys.exc_info()[1])}\n"
 
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] == cfg.MEDIA:
-
             for nplayer in cfg.ALL_PLAYERS:
                 if not pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][nplayer]:
                     continue
@@ -644,7 +758,10 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                     try:
                         end = init + pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][cfg.LENGTH][media_file]
                     except KeyError:
-                        return False, f"The length for media file {media_file} is not available"
+                        return (
+                            False,
+                            f"The length for media file {media_file} is not available",
+                        )
                     out = ""
 
                     if parameters["time"] in (cfg.TIME_EVENTS, cfg.TIME_FULL_OBS):
@@ -670,7 +787,6 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                         )
 
                     else:  # arbitrary 'time interval'
-
                         cursor.execute(
                             (
                                 "SELECT subject, behavior, type, start, stop, modifiers FROM aggregated_events "
@@ -684,7 +800,13 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                                 ",".join(["?"] * len(parameters[cfg.SELECTED_SUBJECTS])),
                                 ",".join(["?"] * len(parameters[cfg.SELECTED_BEHAVIORS])),
                             ),
-                            [obs_id, init, end, float(parameters[cfg.START_TIME]), float(parameters[cfg.END_TIME])]
+                            [
+                                obs_id,
+                                init,
+                                end,
+                                float(parameters[cfg.START_TIME]),
+                                float(parameters[cfg.END_TIME]),
+                            ]
                             + parameters[cfg.SELECTED_SUBJECTS]
                             + parameters[cfg.SELECTED_BEHAVIORS],
                         )
@@ -696,14 +818,11 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                         else:
                             modifiers_str = ""
 
-                        out += (
-                            "{idx}\n" "{start} --> {stop}\n" "{col1}{subject}: {behavior}" "{modifiers}" "{col2}\n\n"
-                        ).format(
+                        out += ("{idx}\n{start} --> {stop}\n{col1}{subject}: {behavior}{modifiers}{col2}\n\n").format(
                             idx=idx + 1,
                             start=util.seconds2time(row["start"] - init).replace(".", ","),
                             stop=util.seconds2time(
-                                (row["stop"] if row["type"] == cfg.STATE else row["stop"] + cfg.POINT_EVENT_ST_DURATION)
-                                - init
+                                (row["stop"] if row["type"] == cfg.STATE else row["stop"] + cfg.POINT_EVENT_ST_DURATION) - init
                             ).replace(".", ","),
                             col1=col1,
                             col2=col2,
@@ -711,13 +830,19 @@ def create_subtitles(pj: dict, selected_observations: list, parameters: dict, ex
                             behavior=row["behavior"],
                             modifiers=modifiers_str,
                         )
-                    file_name = pl.Path(export_dir) / pl.Path(pl.Path(media_file).stem).with_suffix(".srt")
+                    file_name = Path(export_dir) / Path(Path(media_file).stem).with_suffix(".srt")
 
                     if mem_command not in (cfg.OVERWRITE_ALL, cfg.SKIP_ALL) and file_name.is_file():
                         mem_command = dialog.MessageDialog(
                             cfg.programName,
                             f"The file {file_name} already exists.",
-                            [cfg.OVERWRITE, cfg.OVERWRITE_ALL, cfg.SKIP, cfg.SKIP_ALL, cfg.CANCEL],
+                            [
+                                cfg.OVERWRITE,
+                                cfg.OVERWRITE_ALL,
+                                cfg.SKIP,
+                                cfg.SKIP_ALL,
+                                cfg.CANCEL,
+                            ],
                         )
                         if mem_command == cfg.CANCEL:
                             return False, ""
@@ -750,7 +875,13 @@ def export_observations_list(pj: dict, selected_observations: list, file_name: s
     """
 
     data = tablib.Dataset()
-    data.headers = ["Observation id", "Date", "Description", "Subjects", "Media files/Live observation"]
+    data.headers = [
+        "Observation id",
+        "Date",
+        "Description",
+        "Subjects",
+        "Media files/Live observation",
+    ]
 
     indep_var_header = []
     if cfg.INDEPENDENT_VARIABLES in pj:
@@ -759,10 +890,7 @@ def export_observations_list(pj: dict, selected_observations: list, file_name: s
     data.headers.extend(indep_var_header)
 
     for obs_id in selected_observations:
-
-        subjects_list = sorted(
-            list(set([x[cfg.EVENT_SUBJECT_FIELD_IDX] for x in pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]]))
-        )
+        subjects_list = sorted(list(set([x[cfg.EVENT_SUBJECT_FIELD_IDX] for x in pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]])))
         if "" in subjects_list:
             subjects_list = [cfg.NO_FOCAL_SUBJECT] + subjects_list
             subjects_list.remove("")
@@ -797,13 +925,13 @@ def export_observations_list(pj: dict, selected_observations: list, file_name: s
             + indep_var
         )
 
-    if output_format in ["tsv", "csv", "html"]:
+    if output_format in (cfg.TSV_EXT, cfg.CSV_EXT, cfg.HTML_EXT):
         try:
             with open(file_name, "wb") as f:
                 f.write(str.encode(data.export(output_format)))
         except Exception:
             return False
-    if output_format in ["ods", "xlsx", "xls"]:
+    if output_format in [cfg.ODS_EXT, cfg.XLS_EXT, cfg.XLSX_EXT]:
         try:
             with open(file_name, "wb") as f:
                 f.write(data.export(output_format))
@@ -830,13 +958,9 @@ def set_media_paths_relative_to_project_dir(pj: dict, project_file_name: str) ->
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] == cfg.IMAGES:
             for img_dir in pj[cfg.OBSERVATIONS][obs_id][cfg.DIRECTORIES_LIST]:
                 try:
-                    pl.Path(img_dir).relative_to(pl.Path(project_file_name).parent)
+                    Path(img_dir).relative_to(Path(project_file_name).parent)
                 except ValueError:
-                    if (
-                        pl.Path(img_dir).is_absolute()
-                        or not (pl.Path(project_file_name).parent / pl.Path(img_dir)).is_dir()
-                    ):
-
+                    if Path(img_dir).is_absolute() or not (Path(project_file_name).parent / Path(img_dir)).is_dir():
                         QMessageBox.critical(
                             None,
                             cfg.programName,
@@ -849,35 +973,29 @@ def set_media_paths_relative_to_project_dir(pj: dict, project_file_name: str) ->
                 if n_player in pj[cfg.OBSERVATIONS][obs_id][cfg.FILE]:
                     for idx, media_file in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][n_player]):
                         try:
-                            pl.Path(media_file).relative_to(pl.Path(project_file_name).parent)
+                            Path(media_file).relative_to(Path(project_file_name).parent)
                         except ValueError:
-
-                            if (
-                                pl.Path(media_file).is_absolute()
-                                or not (pl.Path(project_file_name).parent / pl.Path(media_file)).is_file()
-                            ):
-
+                            if Path(media_file).is_absolute() or not (Path(project_file_name).parent / Path(media_file)).is_file():
                                 QMessageBox.critical(
                                     None,
                                     cfg.programName,
-                                    f"Observation <b>{obs_id}</b>:<br>the path of <b>{media_file}</b> is not relative to <b>{project_file_name}</b>",
+                                    (
+                                        f"Observation <b>{obs_id}</b>:"
+                                        f"<br>the path of <b>{media_file}</b> is not relative to <b>{project_file_name}</b>"
+                                    ),
                                 )
                                 return False
 
     # set media path and image dir relative to project dir
     flag_changed = False
     for obs_id in pj[cfg.OBSERVATIONS]:
-
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] == cfg.IMAGES:
             new_dir_list = []
             for img_dir in pj[cfg.OBSERVATIONS][obs_id][cfg.DIRECTORIES_LIST]:
                 try:
-                    new_dir_list.append(str(pl.Path(img_dir).relative_to(pl.Path(project_file_name).parent)))
+                    new_dir_list.append(str(Path(img_dir).relative_to(Path(project_file_name).parent)))
                 except ValueError:
-                    if (
-                        not pl.Path(img_dir).is_absolute()
-                        and (pl.Path(project_file_name).parent / pl.Path(img_dir)).is_dir()
-                    ):
+                    if not Path(img_dir).is_absolute() and (Path(project_file_name).parent / Path(img_dir)).is_dir():
                         new_dir_list.append(img_dir)
 
             if pj[cfg.OBSERVATIONS][obs_id][cfg.DIRECTORIES_LIST] != new_dir_list:
@@ -889,26 +1007,28 @@ def set_media_paths_relative_to_project_dir(pj: dict, project_file_name: str) ->
                 if n_player in pj[cfg.OBSERVATIONS][obs_id][cfg.FILE]:
                     for idx, media_file in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][n_player]):
                         try:
-                            p = str(pl.Path(media_file).relative_to(pl.Path(project_file_name).parent))
+                            p = str(Path(media_file).relative_to(Path(project_file_name).parent))
                         except ValueError:
-                            if (
-                                not pl.Path(media_file).is_absolute()
-                                and (pl.Path(project_file_name).parent / pl.Path(media_file)).is_file()
-                            ):
+                            if not Path(media_file).is_absolute() and (Path(project_file_name).parent / Path(media_file)).is_file():
                                 p = media_file
                         if p != media_file:
                             flag_changed = True
                             pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][n_player][idx] = p
                             if cfg.MEDIA_INFO in pj[cfg.OBSERVATIONS][obs_id]:
-                                for info in [cfg.LENGTH, cfg.HAS_AUDIO, cfg.HAS_VIDEO, cfg.FPS]:
+                                for info in [
+                                    cfg.LENGTH,
+                                    cfg.HAS_AUDIO,
+                                    cfg.HAS_VIDEO,
+                                    cfg.FPS,
+                                ]:
                                     if (
                                         info in pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO]
                                         and media_file in pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][info]
                                     ):
                                         # add new file path
-                                        pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][info][p] = pj[cfg.OBSERVATIONS][
-                                            obs_id
-                                        ][cfg.MEDIA_INFO][info][media_file]
+                                        pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][info][p] = pj[cfg.OBSERVATIONS][obs_id][
+                                            cfg.MEDIA_INFO
+                                        ][info][media_file]
                                         # remove old path
                                         del pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][info][media_file]
     return flag_changed
@@ -930,35 +1050,32 @@ def set_data_paths_relative_to_project_dir(pj: dict, project_file_name: str) ->
         for _, v in pj[cfg.OBSERVATIONS][obs_id].get(cfg.PLOT_DATA, {}).items():
             if cfg.FILE_PATH in v:
                 try:
-                    pl.Path(v[cfg.FILE_PATH]).relative_to(pl.Path(project_file_name).parent)
+                    Path(v[cfg.FILE_PATH]).relative_to(Path(project_file_name).parent)
                 except ValueError:
                     # check if file is in project dir
-                    if (
-                        pl.Path(v[cfg.FILE_PATH]).is_absolute()
-                        or not (pl.Path(project_file_name).parent / pl.Path(v[cfg.FILE_PATH])).is_file()
-                    ):
+                    if Path(v[cfg.FILE_PATH]).is_absolute() or not (Path(project_file_name).parent / Path(v[cfg.FILE_PATH])).is_file():
                         QMessageBox.critical(
                             None,
                             cfg.programName,
-                            f"Observation <b>{obs_id}</b>:<br>the path of <b>{v[cfg.FILE_PATH]}</b> is not relative to <b>{project_file_name}</b>.",
+                            (
+                                f"Observation <b>{obs_id}</b>:"
+                                f"<br>the path of <b>{v[cfg.FILE_PATH]}</b> "
+                                f"is not relative to <b>{project_file_name}</b>."
+                            ),
                         )
                         return False
 
     flag_changed = False
     for obs_id in pj[cfg.OBSERVATIONS]:
-
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] != cfg.MEDIA:
             continue
         for idx, v in pj[cfg.OBSERVATIONS][obs_id].get(cfg.PLOT_DATA, {}).items():
             if cfg.FILE_PATH in v:
                 try:
-                    p = str(pl.Path(v[cfg.FILE_PATH]).relative_to(pl.Path(project_file_name).parent))
+                    p = str(Path(v[cfg.FILE_PATH]).relative_to(Path(project_file_name).parent))
                 except ValueError:
                     # check if file is in project dir
-                    if (
-                        not pl.Path(v[cfg.FILE_PATH]).is_absolute()
-                        and (pl.Path(project_file_name).parent / pl.Path(v[cfg.FILE_PATH])).is_file()
-                    ):
+                    if not Path(v[cfg.FILE_PATH]).is_absolute() and (Path(project_file_name).parent / Path(v[cfg.FILE_PATH])).is_file():
                         p = v[cfg.FILE_PATH]
 
                 if p != v[cfg.FILE_PATH]:
@@ -980,13 +1097,12 @@ def remove_data_files_path(pj: dict) -> None:
     """
 
     for obs_id in pj[cfg.OBSERVATIONS]:
-
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] != cfg.MEDIA:
             continue
         if cfg.PLOT_DATA in pj[cfg.OBSERVATIONS][obs_id]:
             for idx in pj[cfg.OBSERVATIONS][obs_id][cfg.PLOT_DATA]:
                 if "file_path" in pj[cfg.OBSERVATIONS][obs_id][cfg.PLOT_DATA][idx]:
-                    p = str(pl.Path(pj[cfg.OBSERVATIONS][obs_id][cfg.PLOT_DATA][idx]["file_path"]).name)
+                    p = str(Path(pj[cfg.OBSERVATIONS][obs_id][cfg.PLOT_DATA][idx]["file_path"]).name)
                     if p != pj[cfg.OBSERVATIONS][obs_id][cfg.PLOT_DATA][idx]["file_path"]:
                         pj[cfg.OBSERVATIONS][obs_id][cfg.PLOT_DATA][idx]["file_path"] = p
 
@@ -1006,17 +1122,16 @@ def remove_media_files_path(pj: dict, project_file_name: str) -> bool:
     file_not_found = []
     # check if media and images dir
     for obs_id in pj[cfg.OBSERVATIONS]:
-
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] == cfg.IMAGES:
             for img_dir in pj[cfg.OBSERVATIONS][obs_id][cfg.DIRECTORIES_LIST]:
-                if full_path(pl.Path(img_dir).name, project_file_name) == "":
+                if full_path(Path(img_dir).name, project_file_name) == "":
                     file_not_found.append(img_dir)
 
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] == cfg.MEDIA:
             for n_player in cfg.ALL_PLAYERS:
                 if n_player in pj[cfg.OBSERVATIONS][obs_id][cfg.FILE]:
                     for idx, media_file in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][n_player]):
-                        if full_path(pl.Path(media_file).name, project_file_name) == "":
+                        if full_path(Path(media_file).name, project_file_name) == "":
                             file_not_found.append(media_file)
 
     file_not_found = set(file_not_found)
@@ -1037,33 +1152,37 @@ def remove_media_files_path(pj: dict, project_file_name: str) -> bool:
 
     flag_changed = False
     for obs_id in pj[cfg.OBSERVATIONS]:
-
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] == cfg.IMAGES:
             new_img_dir_list = []
             for img_dir in pj[cfg.OBSERVATIONS][obs_id][cfg.DIRECTORIES_LIST]:
-                if img_dir != pl.Path(img_dir).name:
+                if img_dir != Path(img_dir).name:
                     flag_changed = True
-                new_img_dir_list.append(str(pl.Path(img_dir).name))
+                new_img_dir_list.append(str(Path(img_dir).name))
             pj[cfg.OBSERVATIONS][obs_id][cfg.DIRECTORIES_LIST] = new_img_dir_list
 
         if pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE] == cfg.MEDIA:
             for n_player in cfg.ALL_PLAYERS:
                 if n_player in pj[cfg.OBSERVATIONS][obs_id][cfg.FILE]:
                     for idx, media_file in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][n_player]):
-                        p = pl.Path(media_file).name
+                        p = Path(media_file).name
                         if p != media_file:
                             flag_changed = True
                             pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][n_player][idx] = p
                             if cfg.MEDIA_INFO in pj[cfg.OBSERVATIONS][obs_id]:
-                                for info in [cfg.LENGTH, cfg.HAS_AUDIO, cfg.HAS_VIDEO, cfg.FPS]:
+                                for info in [
+                                    cfg.LENGTH,
+                                    cfg.HAS_AUDIO,
+                                    cfg.HAS_VIDEO,
+                                    cfg.FPS,
+                                ]:
                                     if (
                                         info in pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO]
                                         and media_file in pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][info]
                                     ):
                                         # add new file path
-                                        pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][info][p] = pj[cfg.OBSERVATIONS][
-                                            obs_id
-                                        ][cfg.MEDIA_INFO][info][media_file]
+                                        pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][info][p] = pj[cfg.OBSERVATIONS][obs_id][
+                                            cfg.MEDIA_INFO
+                                        ][info][media_file]
                                         # remove old path
                                         del pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][info][media_file]
 
@@ -1073,7 +1192,7 @@ def remove_media_files_path(pj: dict, project_file_name: str) -> bool:
 def full_path(path: str, project_file_name: str) -> str:
     """
     returns the media/data full path or the images directory full path
-    add path of BORIS project if media/data with relative path
+    add path of BORIS project if media/data/pictures dir with relative path
 
     Args:
         path (str): file path or images directory path
@@ -1083,12 +1202,12 @@ def full_path(path: str, project_file_name: str) -> str:
         str: full path
     """
 
-    source_path = pl.Path(path)
+    source_path = Path(path)
     if source_path.exists():
         return str(source_path)
     else:
         # check relative path (to project path)
-        project_path = pl.Path(project_file_name)
+        project_path = Path(project_file_name)
         if (project_path.parent / source_path).exists():
             return str(project_path.parent / source_path)
         else:
@@ -1107,21 +1226,27 @@ def observed_interval(observation: dict) -> Tuple[dec, dec]:
     """
     if not observation[cfg.EVENTS]:
         return (dec("0.0"), dec("0.0"))
+
     if observation[cfg.TYPE] in (cfg.MEDIA, cfg.LIVE):
+        event_timestamp = [event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.TIME]] for event in observation[cfg.EVENTS]]
+
         return (
-            min(observation[cfg.EVENTS])[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.TIME]],
-            max(observation[cfg.EVENTS])[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.TIME]],
+            min(event_timestamp),
+            max(event_timestamp),
         )
     if observation[cfg.TYPE] == cfg.IMAGES:
         events = [x[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.IMAGE_INDEX]] for x in observation[cfg.EVENTS]]
-
-        return (dec(min(events)), dec(max(events)))
+        # test if indexes contain NA
+        try:
+            dec(min(events))
+            return (dec(min(events)), dec(max(events)))
+        except Exception:
+            return (dec("NaN"), dec("NaN"))
 
 
-def events_start_stop(ethogram: dict, events: list) -> list:
+def events_start_stop(ethogram: dict, events: list, obs_type: str) -> List[tuple]:
     """
     returns events with status (START/STOP or POINT)
-    Take consideration of subject
 
     Args:
         events (list): list of events
@@ -1132,18 +1257,9 @@ def events_start_stop(ethogram: dict, events: list) -> list:
 
     state_events_list = util.state_behavior_codes(ethogram)
 
-    events_flagged = []
+    events_flagged: list = []
     for idx, event in enumerate(events):
-        """
-        time, subject, code, modifier = (
-            event[cfg.EVENT_TIME_FIELD_IDX],
-            event[cfg.EVENT_SUBJECT_FIELD_IDX],
-            event[cfg.EVENT_BEHAVIOR_FIELD_IDX],
-            event[cfg.EVENT_MODIFIER_FIELD_IDX],
-        )
-        """
-
-        time, subject, code, modifier = event[: cfg.EVENT_MODIFIER_FIELD_IDX + 1]
+        _, subject, code, modifier = event[: cfg.EVENT_MODIFIER_FIELD_IDX + 1]
 
         # check if code is state
         if code in state_events_list:
@@ -1153,9 +1269,10 @@ def events_start_stop(ethogram: dict, events: list) -> list:
                     [
                         x[cfg.EVENT_BEHAVIOR_FIELD_IDX]
                         for idx1, x in enumerate(events)
-                        if x[cfg.EVENT_BEHAVIOR_FIELD_IDX] == code and idx1 < idx
-                        # and x[cfg.EVENT_TIME_FIELD_IDX] < time
-                        and x[cfg.EVENT_SUBJECT_FIELD_IDX] == subject and x[cfg.EVENT_MODIFIER_FIELD_IDX] == modifier
+                        if x[cfg.EVENT_BEHAVIOR_FIELD_IDX] == code
+                        and idx1 < idx
+                        and x[cfg.EVENT_SUBJECT_FIELD_IDX] == subject
+                        and x[cfg.EVENT_MODIFIER_FIELD_IDX] == modifier
                     ]
                 )
                 % 2
@@ -1166,7 +1283,17 @@ def events_start_stop(ethogram: dict, events: list) -> list:
         else:
             flag = cfg.POINT
 
-        events_flagged.append(tuple(event) + (flag,))
+        # no frame_index
+        if obs_type == cfg.MEDIA and len(event) == 5:
+            events_flagged.append(
+                tuple(event)
+                + (
+                    cfg.NA,
+                    flag,
+                )
+            )
+        else:
+            events_flagged.append(tuple(event) + (flag,))
 
     return events_flagged
 
@@ -1189,7 +1316,7 @@ def extract_observed_subjects(pj: dict, selected_observations: list) -> list:
     return list(set(observed_subjects))
 
 
-def open_project_json(projectFileName: str) -> tuple:
+def open_project_json(project_file_name: str) -> tuple:
     """
     open BORIS project file in json format or GZ compressed json format
 
@@ -1203,31 +1330,56 @@ def open_project_json(projectFileName: str) -> tuple:
         str: message
     """
 
-    logging.debug(f"open project: {projectFileName}")
+    logging.debug(f"open_project_json function: {project_file_name}")
 
-    projectChanged = False
-    msg = ""
+    projectChanged: bool = False
+    msg: str = ""
 
-    if not os.path.isfile(projectFileName):
-        return projectFileName, projectChanged, {"error": f"File {projectFileName} not found"}, msg
+    if not Path(project_file_name).is_file():
+        return (
+            project_file_name,
+            projectChanged,
+            {"error": f"File {project_file_name} not found"},
+            msg,
+        )
 
     try:
-        if projectFileName.endswith(".boris.gz"):
-            file_in = gzip.open(projectFileName, mode="rt", encoding="utf-8")
+        if project_file_name.endswith(".boris.gz"):
+            file_in = gzip.open(project_file_name, mode="rt", encoding="utf-8")
         else:
-            file_in = open(projectFileName, "r")
+            file_in = open(project_file_name, "r")
         file_content = file_in.read()
     except PermissionError:
-        return projectFileName, projectChanged, {f"error": f"File {projectFileName}: Permission denied"}, msg
+        return (
+            project_file_name,
+            projectChanged,
+            {"error": f"File {project_file_name}: Permission denied"},
+            msg,
+        )
     except Exception:
-        return projectFileName, projectChanged, {f"error": f"Error on file {projectFileName}: {sys.exc_info()[1]}"}, msg
+        return (
+            project_file_name,
+            projectChanged,
+            {"error": f"Error on file {project_file_name}: {sys.exc_info()[1]}"},
+            msg,
+        )
 
     try:
         pj = json.loads(file_content)
     except json.decoder.JSONDecodeError:
-        return projectFileName, projectChanged, {"error": "This project file seems corrupted"}, msg
+        return (
+            project_file_name,
+            projectChanged,
+            {"error": "This project file seems corrupted"},
+            msg,
+        )
     except Exception:
-        return projectFileName, projectChanged, {f"error": f"Error on file {projectFileName}: {sys.exc_info()[1]}"}, msg
+        return (
+            project_file_name,
+            projectChanged,
+            {"error": f"Error on file {project_file_name}: {sys.exc_info()[1]}"},
+            msg,
+        )
 
     # transform time to decimal
     pj = util.convert_time_to_decimal(pj)
@@ -1245,11 +1397,9 @@ def open_project_json(projectFileName: str) -> tuple:
                 projectChanged = True
 
     # check if project file version is newer than current BORIS project file version
-    if cfg.PROJECT_VERSION in pj and util.versiontuple(pj[cfg.PROJECT_VERSION]) > util.versiontuple(
-        version.__version__
-    ):
+    if cfg.PROJECT_VERSION in pj and util.versiontuple(pj[cfg.PROJECT_VERSION]) > util.versiontuple(version.__version__):
         return (
-            projectFileName,
+            project_file_name,
             projectChanged,
             {
                 "error": (
@@ -1262,13 +1412,11 @@ def open_project_json(projectFileName: str) -> tuple:
 
     # check if old version  v. 0 *.obs
     if cfg.PROJECT_VERSION not in pj:
-
         # convert VIDEO, AUDIO -> MEDIA
         pj[cfg.PROJECT_VERSION] = cfg.project_format_version
         projectChanged = True
 
         for obs in [x for x in pj[cfg.OBSERVATIONS]]:
-
             # remove 'replace audio' key
             if "replace audio" in pj[cfg.OBSERVATIONS][obs]:
                 del pj[cfg.OBSERVATIONS][obs]["replace audio"]
@@ -1277,6 +1425,7 @@ def open_project_json(projectFileName: str) -> tuple:
                 pj[cfg.OBSERVATIONS][obs][cfg.TYPE] = cfg.MEDIA
 
             # convert old media list in new one
+            d1: dict = {}
             if len(pj[cfg.OBSERVATIONS][obs][cfg.FILE]):
                 d1 = {cfg.PLAYER1: [pj[cfg.OBSERVATIONS][obs][cfg.FILE][0]]}
 
@@ -1294,7 +1443,7 @@ def open_project_json(projectFileName: str) -> tuple:
             f"The project file was converted to the new format (v. {cfg.project_format_version}) in use with your version of BORIS.<br>"
             "Choose a new file name for saving it."
         )
-        projectFileName = ""
+        project_file_name = ""
 
     # update modifiers to JSON format
 
@@ -1318,16 +1467,26 @@ def open_project_json(projectFileName: str) -> tuple:
                 pj[cfg.ETHOGRAM][idx]["modifiers"] = {}
 
         if not project_lowerthan4:
-            msg = "The project version was updated from {} to {}".format(
-                pj[cfg.PROJECT_VERSION], cfg.project_format_version
-            )
+            msg = "The project version was updated from {} to {}".format(pj[cfg.PROJECT_VERSION], cfg.project_format_version)
             pj[cfg.PROJECT_VERSION] = cfg.project_format_version
             projectChanged = True
 
+    # check if behavioral categories are stored as a list
+    if cfg.BEHAVIORAL_CATEGORIES_CONF in pj:
+        if isinstance(pj[cfg.BEHAVIORAL_CATEGORIES_CONF], list):
+            # convert to dict
+            pj[cfg.BEHAVIORAL_CATEGORIES_CONF] = {str(idx): {"name": bc} for idx, bc in enumerate(pj[cfg.BEHAVIORAL_CATEGORIES_CONF])}
+            logging.info("Behavioral categories was converted from a list to a dictionary")
+            projectChanged = True
+    else:
+        pj[cfg.BEHAVIORAL_CATEGORIES_CONF] = dict()
+        projectChanged = True
+
+
     # add category key if not found
     for idx in pj[cfg.ETHOGRAM]:
-        if "category" not in pj[cfg.ETHOGRAM][idx]:
-            pj[cfg.ETHOGRAM][idx]["category"] = ""
+        if cfg.BEHAVIOR_CATEGORY not in pj[cfg.ETHOGRAM][idx]:
+            pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CATEGORY] = ""
 
     # if one file is present in player #1 -> set "media_info" key with value of media_file_info
     for obs in pj[cfg.OBSERVATIONS]:
@@ -1338,16 +1497,21 @@ def open_project_json(projectFileName: str) -> tuple:
                 cfg.HAS_VIDEO: {},
                 cfg.HAS_AUDIO: {},
             }
-            for player in [cfg.PLAYER1, cfg.PLAYER2]:
+            for player in (cfg.PLAYER1, cfg.PLAYER2):
                 # fix bug Anne Maijer 2017-07-17
                 if pj[cfg.OBSERVATIONS][obs][cfg.FILE] == []:
                     pj[cfg.OBSERVATIONS][obs][cfg.FILE] = {"1": [], "2": []}
 
                 for media_file_path in pj[cfg.OBSERVATIONS][obs]["file"][player]:
                     # FIX: ffmpeg path
-                    ret, msg = util.check_ffmpeg_path()
+                    ret, ffmpeg_bin = util.check_ffmpeg_path()
                     if not ret:
-                        return projectFileName, projectChanged, {"error": "FFmpeg path not found"}, ""
+                        return (
+                            project_file_name,
+                            projectChanged,
+                            {"error": "FFmpeg path not found"},
+                            "",
+                        )
                     else:
                         ffmpeg_bin = msg
 
@@ -1358,7 +1522,7 @@ def open_project_json(projectFileName: str) -> tuple:
                         pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.FPS][media_file_path] = float(r["fps"])
                         pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.HAS_VIDEO][media_file_path] = r["has_video"]
                         pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.HAS_AUDIO][media_file_path] = r["has_audio"]
-                        project_updated, projectChanged = True, True
+                        projectChanged = True
                     else:  # file path not found
                         if (
                             cfg.MEDIA_FILE_INFO in pj[cfg.OBSERVATIONS][obs]
@@ -1370,10 +1534,7 @@ def open_project_json(projectFileName: str) -> tuple:
                             # duration
                             pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO] = {
                                 cfg.LENGTH: {
-                                    media_file_path: pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO][media_md5_key][
-                                        "video_length"
-                                    ]
-                                    / 1000
+                                    media_file_path: pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO][media_md5_key]["video_length"] / 1000
                                 }
                             }
                             projectChanged = True
@@ -1381,13 +1542,8 @@ def open_project_json(projectFileName: str) -> tuple:
                             # FPS
                             if "nframe" in pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO][media_md5_key]:
                                 pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.FPS] = {
-                                    media_file_path: pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO][media_md5_key][
-                                        "nframe"
-                                    ]
-                                    / (
-                                        pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO][media_md5_key]["video_length"]
-                                        / 1000
-                                    )
+                                    media_file_path: pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO][media_md5_key]["nframe"]
+                                    / (pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO][media_md5_key]["video_length"] / 1000)
                                 }
                             else:
                                 pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.FPS] = {media_file_path: 0}
@@ -1403,9 +1559,7 @@ def open_project_json(projectFileName: str) -> tuple:
             for player in pj[cfg.OBSERVATIONS][obs][cfg.FILE]:
                 pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.OFFSET][player] = 0.0
             if pj[cfg.OBSERVATIONS][obs]["time offset second player"]:
-                pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.OFFSET]["2"] = float(
-                    pj[cfg.OBSERVATIONS][obs]["time offset second player"]
-                )
+                pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.OFFSET]["2"] = float(pj[cfg.OBSERVATIONS][obs]["time offset second player"])
 
             del pj[cfg.OBSERVATIONS][obs]["time offset second player"]
             project_lowerthan7 = True
@@ -1419,36 +1573,41 @@ def open_project_json(projectFileName: str) -> tuple:
             projectChanged = True
 
     if project_lowerthan7:
-
         msg = f"The project was updated to the current project version ({cfg.project_format_version})."
 
         try:
-            old_project_file_name = projectFileName.replace(".boris", f".v{pj['project_format_version']}.boris")
-            copyfile(projectFileName, old_project_file_name)
+            old_project_file_name = project_file_name.replace(".boris", f".v{pj['project_format_version']}.boris")
+            copyfile(project_file_name, old_project_file_name)
             msg += f"\n\nThe old file project was saved as {old_project_file_name}"
         except Exception:
-            pass
+            QMessageBox.critical(cfg.programName, f"Error saving old project to {old_project_file_name}")
 
         pj[cfg.PROJECT_VERSION] = cfg.project_format_version
 
-    return projectFileName, projectChanged, pj, msg
+    # 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):
+            # 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
 
 
-def event_type(code: str, ethogram: dict) -> str:
+def event_type(code: str, ethogram: dict) -> str | None:
     """
-    returns type of event for code
+    returns type of event for behavior code
 
     Args:
         ethogram (dict); ethogram of project
         code (str): behavior code
 
     Returns:
-        str: "STATE EVENT", "POINT EVENT" or None if code not found in ethogram
+        str: behavior type
     """
 
     for idx in ethogram:
         if ethogram[idx][cfg.BEHAVIOR_CODE] == code:
-            return ethogram[idx][cfg.TYPE].upper()
+            return ethogram[idx][cfg.TYPE]
     return None
 
 
@@ -1457,7 +1616,6 @@ def fix_unpaired_state_events(ethogram: dict, observation: dict, fix_at_time: de
     fix unpaired state events in observation
 
     Args:
-        obsId (str): observation id
         ethogram (dict): ethogram dictionary
         observation (dict): observation dictionary
         fix_at_time (Decimal): time to fix the unpaired events
@@ -1466,31 +1624,27 @@ def fix_unpaired_state_events(ethogram: dict, observation: dict, fix_at_time: de
         list: list of events with state events fixed
     """
 
-    out = ""
-    closing_events_to_add = []
-    flagStateEvent = False
-    subjects = [event[cfg.EVENT_SUBJECT_FIELD_IDX] for event in observation[cfg.EVENTS]]
-    ethogram_behaviors = {ethogram[idx][cfg.BEHAVIOR_CODE] for idx in ethogram}
+    closing_events_to_add: list = []
+    subjects: list = [event[cfg.EVENT_SUBJECT_FIELD_IDX] for event in observation[cfg.EVENTS]]
+    ethogram_behaviors: dict = {ethogram[idx][cfg.BEHAVIOR_CODE] for idx in ethogram}
 
     for subject in sorted(set(subjects)):
-
-        behaviors = [
-            event[cfg.EVENT_BEHAVIOR_FIELD_IDX]
-            for event in observation[cfg.EVENTS]
-            if event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject
+        behaviors: list = [
+            event[cfg.EVENT_BEHAVIOR_FIELD_IDX] for event in observation[cfg.EVENTS] if event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject
         ]
 
         for behavior in sorted(set(behaviors)):
-            if (behavior in ethogram_behaviors) and (cfg.STATE in event_type(behavior, ethogram).upper()):
-
+            if (behavior in ethogram_behaviors) and (event_type(behavior, ethogram) in cfg.STATE_EVENT_TYPES):
                 lst, memTime = [], {}
                 for event in [
                     event
                     for event in observation[cfg.EVENTS]
                     if event[cfg.EVENT_BEHAVIOR_FIELD_IDX] == behavior and event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject
                 ]:
-
-                    behav_modif = [event[cfg.EVENT_BEHAVIOR_FIELD_IDX], event[cfg.EVENT_MODIFIER_FIELD_IDX]]
+                    behav_modif = [
+                        event[cfg.EVENT_BEHAVIOR_FIELD_IDX],
+                        event[cfg.EVENT_MODIFIER_FIELD_IDX],
+                    ]
 
                     if behav_modif in lst:
                         lst.remove(behav_modif)
@@ -1500,11 +1654,78 @@ def fix_unpaired_state_events(ethogram: dict, observation: dict, fix_at_time: de
                         memTime[str(behav_modif)] = event[cfg.EVENT_TIME_FIELD_IDX]
 
                 for event in lst:
+                    last_event_time = max([fix_at_time] + [x[0] for x in closing_events_to_add])
+
+                    closing_events_to_add.append(
+                        [
+                            last_event_time + dec("0.001"),
+                            subject,
+                            behavior,
+                            event[1],  # modifiers
+                            "Event automatically added by the fix unpaired state events function",
+                            cfg.NA,  # frame index
+                        ]
+                    )
+
+    return closing_events_to_add
+
+
+def fix_unpaired_state_events2(ethogram: dict, events: list, fix_at_time: dec) -> list:
+    """
+    fix unpaired state events in events list
 
+    Args:
+        ethogram (dict): ethogram dictionary
+        events (list): list of events
+        fix_at_time (Decimal): time to fix the unpaired events
+
+    Returns:
+        list: list of events with state events fixed
+    """
+
+    logging.debug("fix_unpaired_state_events2 function")
+
+    closing_events_to_add: list = []
+    subjects: list = [event[cfg.EVENT_SUBJECT_FIELD_IDX] for event in events]
+    ethogram_behaviors: dict = {ethogram[idx][cfg.BEHAVIOR_CODE] for idx in ethogram}
+
+    for subject in sorted(set(subjects)):
+        behaviors: list = [event[cfg.EVENT_BEHAVIOR_FIELD_IDX] for event in events if event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject]
+
+        for behavior in sorted(set(behaviors)):
+            if (behavior in ethogram_behaviors) and (event_type(behavior, ethogram) in cfg.STATE_EVENT_TYPES):
+                lst: list = []
+                memTime: dict = {}
+                for event in [
+                    event
+                    for event in events
+                    if event[cfg.EVENT_BEHAVIOR_FIELD_IDX] == behavior and event[cfg.EVENT_SUBJECT_FIELD_IDX] == subject
+                ]:
+                    behav_modif = [
+                        event[cfg.EVENT_BEHAVIOR_FIELD_IDX],
+                        event[cfg.EVENT_MODIFIER_FIELD_IDX],
+                    ]
+
+                    if behav_modif in lst:
+                        lst.remove(behav_modif)
+                        del memTime[str(behav_modif)]
+                    else:
+                        lst.append(behav_modif)
+                        memTime[str(behav_modif)] = event[cfg.EVENT_TIME_FIELD_IDX]
+
+                for event in lst:
                     last_event_time = max([fix_at_time] + [x[0] for x in closing_events_to_add])
 
                     closing_events_to_add.append(
-                        [last_event_time + dec("0.001"), subject, behavior, event[1], ""]  # modifiers  # comment
+                        [
+                            # last_event_time + dec("0.001"),
+                            last_event_time,
+                            subject,
+                            behavior,
+                            event[1],  # modifiers
+                            "Event automatically added by the fix unpaired state events function",
+                            cfg.NA,  # frame index
+                        ]
                     )
 
     return closing_events_to_add
@@ -1531,8 +1752,11 @@ def explore_project(self) -> None:
         manage double-click on tablewidget of explore project results
         """
         observation_operations.load_observation(self, obs_id, cfg.VIEW)
-        self.twEvents.selectRow(event_idx - 1)
-        self.twEvents.scrollToItem(self.twEvents.item(event_idx - 1, 0))
+
+        self.tv_events.selectRow(event_idx - 1)
+        index = self.tv_events.model().index(event_idx - 1, 0)
+        self.tv_events.scrollTo(index, QAbstractItemView.EnsureVisible)
+        # self.twEvents.scrollToItem(self.twEvents.item(event_idx - 1, 0))
 
     elements_list = ("Subject", "Behavior", "Modifier", "Comment")
     elements = []
@@ -1541,7 +1765,9 @@ def explore_project(self) -> None:
     elements.append(("cb", "Case sensitive", False))
 
     explore_dlg = dialog.Input_dialog(
-        label_caption="Search in all observations", elements_list=elements, title="Explore project"
+        label_caption="Search in all observations",
+        elements_list=elements,
+        title="Explore project",
     )
     explore_dlg.pbOK.setText("Find")
     if not explore_dlg.exec_():
@@ -1565,10 +1791,7 @@ def explore_project(self) -> None:
                     if any(
                         (
                             (explore_dlg.elements["Case sensitive"].isChecked() and text in event[idx]),
-                            (
-                                not explore_dlg.elements["Case sensitive"].isChecked()
-                                and text.upper() in event[idx].upper()
-                            ),
+                            (not explore_dlg.elements["Case sensitive"].isChecked() and text.upper() in event[idx].upper()),
                         )
                     ):
                         nb_results += 1
@@ -1602,3 +1825,215 @@ def explore_project(self) -> None:
 
     else:
         QMessageBox.information(self, cfg.programName, "No events found")
+
+
+def project2dataframe(pj: dict, observations_list: list = []) -> Tuple[str, pd.DataFrame]:
+    """
+    returns a pandas dataframe containing observations data
+    """
+    # print(pj.keys())
+
+    # print(pj["independent_variables"])
+
+    # indep_var = [pj["independent_variables"][idx]["label"] for idx in pj["independent_variables"]]
+
+    indep_variables = dict(
+        [(pj[cfg.INDEPENDENT_VARIABLES][idx]["label"], pj[cfg.INDEPENDENT_VARIABLES][idx]["type"]) for idx in pj[cfg.INDEPENDENT_VARIABLES]]
+    )
+
+    # print()
+    # print(f"{indep_variables=}")
+
+    # n_max_set_modifiers = max([len(pj["behaviors_conf"][behavior_id]["modifiers"]) for behavior_id in pj["behaviors_conf"]])
+
+    # behavioral_categories
+    behavioral_category = dict(
+        [(pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CODE], pj[cfg.ETHOGRAM][x][cfg.BEHAVIOR_CATEGORY]) for x in pj[cfg.ETHOGRAM]]
+    )
+
+    # print(f"{pj["behaviors_conf"]=}")
+
+    # check all modifiers
+    all_modifier_sets: list = []
+    for behavior_id in pj[cfg.ETHOGRAM]:
+        modifier_names: list = []
+        set_count = 0
+        if pj[cfg.ETHOGRAM][behavior_id][cfg.MODIFIERS] == "":
+            continue
+        for modifier in pj[cfg.ETHOGRAM][behavior_id][cfg.MODIFIERS].values():
+            if modifier["name"]:
+                modifier_names.append((pj[cfg.ETHOGRAM][behavior_id][cfg.BEHAVIOR_CODE], modifier["name"]))
+            else:
+                set_count += 1
+                modifier_names.append((pj[cfg.ETHOGRAM][behavior_id][cfg.BEHAVIOR_CODE], f"set #{set_count}"))
+
+        # print(modifier_names)
+        if modifier_names:
+            all_modifier_sets.extend(modifier_names)
+
+    # print()
+    # print(f"{all_modifier_sets=}")
+
+    # create df
+
+    data = {
+        "Observation id": [],
+        "Observation date": [],
+        "Description": [],
+        "Observation type": [],
+        "Observation interval start": [],
+        "Observation interval stop": [],
+        # "Source": [],
+        # "Time offset (s)": [],
+        # "Coding duration": [],
+        # "Media duration (s)": [],
+        # "FPS (frame/s)": [],
+    }
+
+    for indep_var in indep_variables:
+        data[f"independent variable '{indep_var}'"] = []
+
+    data = data | {
+        "Subject": [],
+        "Observation duration by subject by observation": [],
+        "Behavior": [],
+        "Behavioral category": [],
+    }
+
+    for modifier_set in all_modifier_sets:
+        data[modifier_set] = []
+
+    data = data | {
+        "Behavior type": [],
+        "Start (s)": [],
+        "Stop (s)": [],
+        "Duration (s)": [],
+        # "Media file name": [],
+        # "Image index start": [],
+        # "Image index stop": [],
+        # "Image file path start": [],
+        # "Image file path stop": [],
+        "Comment start": [],
+        "Comment stop": [],
+    }
+
+    #
+
+    type_ = {
+        "Observation id": "string",
+        "Observation date": "string",
+        "Description": "string",
+        "Observation type": "string",
+        "Observation interval start": "float64",
+        "Observation interval stop": "float64",
+        # "Source": "string",
+        # "Time offset (s)": "string",
+        # "Coding duration": "float64",
+        # "Media duration (s)": "string",
+        # "FPS (frame/s)": "float64",
+    }
+
+    # TODO: set correct type in base of the var type
+    for indep_var in indep_variables:
+        type_[f"independent variable '{indep_var}'"] = "float64" if indep_variables[indep_var] == cfg.NUMERIC else "string"
+
+    type_ = type_ | {
+        "Subject": "string",
+        "Observation duration by subject by observation": "float64",
+        "Behavior": "string",
+        "Behavioral category": "string",
+    }
+
+    for modifer_set in all_modifier_sets:
+        type_[modifer_set] = "string"
+
+    type_ = type_ | {
+        "Behavior type": "string",
+        "Start (s)": "float64",
+        "Stop (s)": "float64",
+        "Duration (s)": "float64",
+        # "Media file name": "string",
+        # "Image index start": "float64",
+        # "Image index stop": "float64",
+        # "Image file path start": "string",
+        # "Image file path stop": "string",
+        "Comment start": "string",
+        "Comment stop": "string",
+    }
+
+    state_behaviors = util.state_behavior_codes(pj[cfg.ETHOGRAM])
+
+    for obs_id in pj[cfg.OBSERVATIONS]:
+        if observations_list and obs_id not in observations_list:
+            continue
+        # print(obs_id)
+        stop_event_idx = set()
+        for idx_event, event in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]):
+            if idx_event in stop_event_idx:
+                continue
+            data["Observation id"].append(obs_id)
+            data["Observation date"].append(pj[cfg.OBSERVATIONS][obs_id]["date"])
+            data["Description"].append(" ".join(pj[cfg.OBSERVATIONS][obs_id]["description"].splitlines()))
+            data["Observation type"].append(pj[cfg.OBSERVATIONS][obs_id]["type"])
+
+            data["Observation interval start"].append(pj[cfg.OBSERVATIONS][obs_id].get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[0])
+            data["Observation interval stop"].append(pj[cfg.OBSERVATIONS][obs_id].get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[1])
+
+            # data["Source"].append("")
+            # data["Time offset (s)"].append(pj["observations"][obs_id]["time offset"])
+            # data["Coding duration"].append("")
+            # data["Media duration (s)"].append("")
+            # data["FPS (frame/s)"].append("")
+
+            for indep_var in indep_variables:
+                data[f"independent variable '{indep_var}'"].append(
+                    pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES].get(indep_var, None)
+                )
+
+            data["Subject"].append(event[cfg.EVENT_SUBJECT_FIELD_IDX] if event[cfg.EVENT_SUBJECT_FIELD_IDX] != "" else cfg.NO_FOCAL_SUBJECT)
+            data["Observation duration by subject by observation"].append(-1)
+            data["Behavior"].append(event[2])
+            data["Behavioral category"].append(behavioral_category[event[2]])
+
+            count_set = 0
+            for modifier_set in all_modifier_sets:
+                if event[2] == modifier_set[0]:
+                    try:
+                        data[modifier_set].append(event[3].split("|")[count_set])
+                    except Exception:
+                        return f"Modifier error for {event[2]} in observation {obs_id}", pd.DataFrame()
+                    count_set += 1
+                else:
+                    data[modifier_set].append(np.nan)
+
+            data["Behavior type"].append(cfg.STATE_EVENT if event[2] in state_behaviors else cfg.POINT_EVENT)
+            data["Start (s)"].append(float(event[0]))
+            if event[2] in state_behaviors:
+                # search stop
+                # print(f"==> {idx_event=} {event[1:4]=}")
+                for idx_event2, event2 in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS][idx_event + 1 :], start=idx_event + 1):
+                    # print(f"{idx_event2=} {event2[1:4]=}")
+                    if event2[1:4] == event[1:4]:
+                        # print("found")
+                        stop_event_idx.add(idx_event2)
+                        data["Stop (s)"].append(float(event2[0]))
+                        data["Duration (s)"].append(float(event2[0] - event[0]))
+                        data["Comment start"].append(event[4])
+                        data["Comment stop"].append(event2[4])
+                        break
+                else:
+                    return f"Some events are not paired in {obs_id}", pd.DataFrame()
+
+            else:  # point
+                data["Stop (s)"].append(float(event[0]))
+                data["Duration (s)"].append(np.nan)
+                data["Comment start"].append(event[4])
+                data["Comment stop"].append(event[4])
+
+    # Set the display option to show all rows and columns
+    pd.set_option("display.max_rows", None)
+    pd.set_option("display.max_columns", None)
+
+    pd.DataFrame(data).info()
+
+    return "", pd.DataFrame(data)