boris-behav-obs 8.16.5__py3-none-any.whl → 9.7.12__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:
@@ -69,61 +73,36 @@ def check_observation_exhaustivity(
             events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]] = {}
             mem_events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]] = {}
 
-        if (
-            event[cfg.EVENT_BEHAVIOR_FIELD_IDX]
-            not in events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]]
-        ):
-            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]
-            ] = []
+        if event[cfg.EVENT_BEHAVIOR_FIELD_IDX] not in events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]]:
+            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(
-                    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]].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(
+                    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]
-                ] = []
+                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])
+            events_interval[event[cfg.EVENT_SUBJECT_FIELD_IDX]][event[cfg.EVENT_BEHAVIOR_FIELD_IDX]] |= I.singleton(
+                event[cfg.EVENT_TIME_FIELD_IDX]
+            )
 
     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]
@@ -136,9 +115,7 @@ def check_observation_exhaustivity(
         total_duration += obs_real_dur
 
     if len(events_interval) and obs_theo_dur:
-        exhausivity_percent = (
-            total_duration / (len(events_interval) * obs_theo_dur) * 100
-        )
+        exhausivity_percent = total_duration / (len(events_interval) * obs_theo_dur) * 100
     else:
         exhausivity_percent = 0
 
@@ -161,9 +138,7 @@ def check_observation_exhaustivity_pictures(obs) -> float:
         return "No pictures found"
 
     # list of paths of coded images
-    coded_images_number = len(
-        set([x[cfg.PJ_OBS_FIELDS[cfg.IMAGES][cfg.IMAGE_PATH]] for x in obs[cfg.EVENTS]])
-    )
+    coded_images_number = len(set([x[cfg.PJ_OBS_FIELDS[cfg.IMAGES][cfg.IMAGE_PATH]] for x in obs[cfg.EVENTS]]))
 
     return round(coded_images_number / tot_images_number * 100, 1)
 
@@ -182,17 +157,13 @@ def behavior_category(ethogram: dict) -> Dict[str, str]:
     behavioral_category = {}
     for idx in ethogram:
         if cfg.BEHAVIOR_CATEGORY in ethogram[idx]:
-            behavioral_category[ethogram[idx][cfg.BEHAVIOR_CODE]] = ethogram[idx][
-                cfg.BEHAVIOR_CATEGORY
-            ]
+            behavioral_category[ethogram[idx][cfg.BEHAVIOR_CODE]] = ethogram[idx][cfg.BEHAVIOR_CATEGORY]
         else:
             behavioral_category[ethogram[idx][cfg.BEHAVIOR_CODE]] = ""
     return behavioral_category
 
 
-def check_if_media_available(
-    observation: dict, project_file_name: str
-) -> Tuple[bool, str]:
+def check_if_media_available(observation: dict, project_file_name: str) -> Tuple[bool, str]:
     """
     check if media files available for media and images observations
 
@@ -227,9 +198,7 @@ def check_if_media_available(
     return (False, "Observation type not found")
 
 
-def check_directories_availability(
-    observation: dict, project_file_name: str
-) -> Tuple[bool, str]:
+def check_directories_availability(observation: dict, project_file_name: str) -> Tuple[bool, str]:
     """
     check if directories are available
 
@@ -256,9 +225,7 @@ def check_coded_behaviors_in_obs_list(pj: dict, observations_list: list) -> bool
     check if coded behaviors in a list of observations are defined in the ethogram
     """
     out = ""
-    ethogram_behavior_codes = {
-        pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] for idx in pj[cfg.ETHOGRAM]
-    }
+    ethogram_behavior_codes = {pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] for idx in pj[cfg.ETHOGRAM]}
     behaviors_not_defined = []
     out = ""  # will contain the output
     for obs_id in observations_list:
@@ -278,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
@@ -286,13 +265,11 @@ 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
-    ethogram_behavior_codes = {
-        pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] for idx in pj[cfg.ETHOGRAM]
-    }
+    ethogram_behavior_codes = {pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] for idx in pj[cfg.ETHOGRAM]}
     behaviors_not_defined = []
 
     for obs_id in pj[cfg.OBSERVATIONS]:
@@ -302,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
@@ -320,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}
@@ -330,13 +305,11 @@ def check_state_events_obs(
 
     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)):
@@ -344,35 +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():
-                    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 behavior not in state_behaviors:
+                    continue
 
-                        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>"
-                        )
+                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")
 
@@ -383,12 +356,12 @@ 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:
-        r, msg = check_state_events_obs(
-            obs_id, pj[cfg.ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id]
-        )
+        r, msg = check_state_events_obs(obs_id, pj[cfg.ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id])
 
         if not r:
             out += f"Observation: <strong>{obs_id}</strong><br>{msg}<br>"
@@ -406,12 +379,12 @@ def check_state_events(pj: dict, observations_list: list) -> Tuple[bool, tuple]:
             return True, []
 
     # remove observations with unpaired state events
-    new_observations_list = [
-        x for x in observations_list if x not in not_paired_obs_list
-    ]
+    new_observations_list = [x for x in observations_list if x not in not_paired_obs_list]
     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
 
 
@@ -422,14 +395,16 @@ def check_project_integrity(
     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
@@ -439,19 +414,24 @@ 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)
     if r:
         out += f"The following behaviors are not defined in the ethogram: <b>{', '.join(r)}</b><br>"
+        flag_all_behaviors_defined = False
+    else:
+        flag_all_behaviors_defined = True
 
     # check for unpaired state events
     for obs_id in pj[cfg.OBSERVATIONS]:
-        ok, msg = check_state_events_obs(
-            obs_id, pj[cfg.ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id], time_format
-        )
+        ok, msg = check_state_events_obs(obs_id, pj[cfg.ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id], time_format)
         if not ok:
             out += "<br><br>" if out else ""
             out += f"Observation: <b>{obs_id}</b><br>{msg}"
@@ -460,10 +440,7 @@ def check_project_integrity(
     for idx in pj[cfg.ETHOGRAM]:
         if cfg.BEHAVIOR_CATEGORY in pj[cfg.ETHOGRAM][idx]:
             if pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CATEGORY]:
-                if (
-                    pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CATEGORY]
-                    not in pj[cfg.BEHAVIORAL_CATEGORIES]
-                ):
+                if pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CATEGORY] not in pj[cfg.BEHAVIORAL_CATEGORIES]:
                     out += "<br><br>" if out else ""
                     out += (
                         f"The behavior <b>{pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE]}</b> belongs "
@@ -481,37 +458,40 @@ 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
     if media_file_available:
         for obs_id in pj[cfg.OBSERVATIONS]:
-            ok, msg = check_if_media_available(
-                pj[cfg.OBSERVATIONS][obs_id], project_file_name
-            )
+            ok, msg = check_if_media_available(pj[cfg.OBSERVATIONS][obs_id], project_file_name)
             if not ok:
                 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]:
                     for media_file in pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][nplayer]:
                         try:
-                            pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][cfg.LENGTH][
-                                media_file
-                            ]
+                            pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][cfg.LENGTH][media_file]
                         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]:
@@ -524,10 +504,7 @@ def check_project_integrity(
             )
 
     # check independent variables present in observations are defined
-    defined_var_label = [
-        pj[cfg.INDEPENDENT_VARIABLES][idx]["label"]
-        for idx in pj.get(cfg.INDEPENDENT_VARIABLES, {})
-    ]
+    defined_var_label = [pj[cfg.INDEPENDENT_VARIABLES][idx]["label"] for idx in pj.get(cfg.INDEPENDENT_VARIABLES, {})]
     not_defined: dict = {}
     for obs_id in pj[cfg.OBSERVATIONS]:
         if cfg.INDEPENDENT_VARIABLES not in pj[cfg.OBSERVATIONS][obs_id]:
@@ -558,27 +535,87 @@ def check_project_integrity(
         ]
     )
 
-    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(","):
-
-                    out += (
+                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
+
+    # 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]):
+            for idx in pj[cfg.ETHOGRAM]:
+                if pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE] == event[cfg.EVENT_BEHAVIOR_FIELD_IDX]:
+                    break
+            else:
+                # behavior not defined in ethogram
+                continue
+
+            if (not event[cfg.EVENT_MODIFIER_FIELD_IDX]) and not pj[cfg.ETHOGRAM][idx][cfg.MODIFIERS]:  # no modifiers
+                continue
+
+            if len(event[cfg.EVENT_MODIFIER_FIELD_IDX].split("|")) != len(pj[cfg.ETHOGRAM][idx][cfg.MODIFIERS]):
+                # print("behavior", event[cfg.EVENT_BEHAVIOR_FIELD_IDX])
+                # print(f"modifier(s) #{event[cfg.EVENT_MODIFIER_FIELD_IDX]}#", len(event[cfg.EVENT_MODIFIER_FIELD_IDX].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[cfg.EVENT_BEHAVIOR_FIELD_IDX]} are {len(event[cfg.EVENT_MODIFIER_FIELD_IDX].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
 
 
-def create_subtitles(
-    pj: dict, selected_observations: list, parameters: dict, export_dir: str
-) -> Tuple[bool, str]:
+def create_subtitles(pj: dict, selected_observations: list, parameters: dict, export_dir: str) -> Tuple[bool, str]:
     """
     create subtitles for selected observations, subjects and behaviors
 
@@ -608,9 +645,9 @@ def create_subtitles(
             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>",
             )
 
@@ -677,20 +714,12 @@ def create_subtitles(
                     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"],
@@ -698,14 +727,9 @@ def create_subtitles(
                     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()
-            ):
+            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.",
@@ -730,19 +754,13 @@ def create_subtitles(
                 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
                 init = 0
                 for media_file in pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][nplayer]:
                     try:
-                        end = (
-                            init
-                            + pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][cfg.LENGTH][
-                                media_file
-                            ]
-                        )
+                        end = init + pj[cfg.OBSERVATIONS][obs_id][cfg.MEDIA_INFO][cfg.LENGTH][media_file]
                     except KeyError:
                         return (
                             False,
@@ -760,12 +778,8 @@ def create_subtitles(
                                 "AND behavior in ({}) "
                                 "ORDER BY start"
                             ).format(
-                                ",".join(
-                                    ["?"] * len(parameters[cfg.SELECTED_SUBJECTS])
-                                ),
-                                ",".join(
-                                    ["?"] * len(parameters[cfg.SELECTED_BEHAVIORS])
-                                ),
+                                ",".join(["?"] * len(parameters[cfg.SELECTED_SUBJECTS])),
+                                ",".join(["?"] * len(parameters[cfg.SELECTED_BEHAVIORS])),
                             ),
                             [
                                 obs_id,
@@ -777,7 +791,6 @@ def create_subtitles(
                         )
 
                     else:  # arbitrary 'time interval'
-
                         cursor.execute(
                             (
                                 "SELECT subject, behavior, type, start, stop, modifiers FROM aggregated_events "
@@ -788,12 +801,8 @@ def create_subtitles(
                                 "AND behavior in ({}) "
                                 "ORDER BY start"
                             ).format(
-                                ",".join(
-                                    ["?"] * len(parameters[cfg.SELECTED_SUBJECTS])
-                                ),
-                                ",".join(
-                                    ["?"] * len(parameters[cfg.SELECTED_BEHAVIORS])
-                                ),
+                                ",".join(["?"] * len(parameters[cfg.SELECTED_SUBJECTS])),
+                                ",".join(["?"] * len(parameters[cfg.SELECTED_BEHAVIORS])),
                             ),
                             [
                                 obs_id,
@@ -813,24 +822,11 @@ def create_subtitles(
                         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(
-                                ".", ","
-                            ),
+                            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,
@@ -838,14 +834,9 @@ def create_subtitles(
                             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()
-                    ):
+                    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.",
@@ -873,9 +864,7 @@ def create_subtitles(
     return flag_ok, msg
 
 
-def export_observations_list(
-    pj: dict, selected_observations: list, file_name: str, output_format: str
-) -> bool:
+def export_observations_list(pj: dict, selected_observations: list, file_name: str, output_format: str) -> bool:
     """
     create file with a list of selected observations
 
@@ -905,17 +894,7 @@ def export_observations_list(
     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("")
@@ -935,11 +914,7 @@ def export_observations_list(
         if cfg.INDEPENDENT_VARIABLES in pj[cfg.OBSERVATIONS][obs_id]:
             for var_label in indep_var_header:
                 if var_label in pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES]:
-                    indep_var.append(
-                        pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES][
-                            var_label
-                        ]
-                    )
+                    indep_var.append(pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES][var_label])
                 else:
                     indep_var.append("")
 
@@ -954,13 +929,13 @@ def export_observations_list(
             + 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))
@@ -987,15 +962,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,
@@ -1006,23 +975,11 @@ def set_media_paths_relative_to_project_dir(pj: dict, project_file_name: str) ->
         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]
-                    ):
+                    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,
@@ -1036,25 +993,13 @@ def set_media_paths_relative_to_project_dir(pj: dict, project_file_name: str) ->
     # 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:
@@ -1064,23 +1009,11 @@ def set_media_paths_relative_to_project_dir(pj: dict, project_file_name: str) ->
         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]
-                    ):
+                    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
@@ -1093,27 +1026,15 @@ def set_media_paths_relative_to_project_dir(pj: dict, project_file_name: str) ->
                                     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
-                                        ]
+                                        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
-                                        ]
-                                        # remove old path
-                                        del pj[cfg.OBSERVATIONS][obs_id][
+                                        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
 
 
@@ -1133,18 +1054,10 @@ 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,
@@ -1158,26 +1071,15 @@ def set_data_paths_relative_to_project_dir(pj: dict, project_file_name: str) ->
 
     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]:
@@ -1199,26 +1101,14 @@ 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
-                    )
-                    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
+                    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
 
 
 def remove_media_files_path(pj: dict, project_file_name: str) -> bool:
@@ -1236,19 +1126,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) == "":
+                    for idx, media_file in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][n_player]):
+                        if full_path(Path(media_file).name, project_file_name) == "":
                             file_not_found.append(media_file)
 
     file_not_found = set(file_not_found)
@@ -1269,22 +1156,19 @@ 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
+                    for idx, media_file in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][n_player]):
+                        p = Path(media_file).name
                         if p != media_file:
                             flag_changed = True
                             pj[cfg.OBSERVATIONS][obs_id][cfg.FILE][n_player][idx] = p
@@ -1296,27 +1180,15 @@ def remove_media_files_path(pj: dict, project_file_name: str) -> bool:
                                     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
-                                        ]
+                                        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
-                                        ]
-                                        # remove old path
-                                        del pj[cfg.OBSERVATIONS][obs_id][
+                                        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
 
@@ -1324,7 +1196,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
@@ -1334,12 +1206,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:
@@ -1358,22 +1230,22 @@ 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)))
+        events = [x[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.IMAGE_INDEX]] for x in observation[cfg.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, obs_type: str) -> List[tuple]:
@@ -1391,7 +1263,6 @@ def events_start_stop(ethogram: dict, events: list, obs_type: str) -> List[tuple
 
     events_flagged: list = []
     for idx, event in enumerate(events):
-
         _, subject, code, modifier = event[: cfg.EVENT_MODIFIER_FIELD_IDX + 1]
 
         # check if code is state
@@ -1441,11 +1312,7 @@ def extract_observed_subjects(pj: dict, selected_observations: list) -> list:
     observed_subjects = []
 
     # extract events from selected observations
-    for events in [
-        pj[cfg.OBSERVATIONS][x][cfg.EVENTS]
-        for x in pj[cfg.OBSERVATIONS]
-        if x in selected_observations
-    ]:
+    for events in [pj[cfg.OBSERVATIONS][x][cfg.EVENTS] for x in pj[cfg.OBSERVATIONS] if x in selected_observations]:
         for event in events:
             observed_subjects.append(event[cfg.EVENT_SUBJECT_FIELD_IDX])
 
@@ -1453,7 +1320,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
 
@@ -1467,37 +1334,37 @@ 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):
+    if not Path(project_file_name).is_file():
         return (
-            projectFileName,
+            project_file_name,
             projectChanged,
-            {"error": f"File {projectFileName} not found"},
+            {"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,
+            project_file_name,
             projectChanged,
-            {"error": f"File {projectFileName}: Permission denied"},
+            {"error": f"File {project_file_name}: Permission denied"},
             msg,
         )
     except Exception:
         return (
-            projectFileName,
+            project_file_name,
             projectChanged,
-            {"error": f"Error on file {projectFileName}: {sys.exc_info()[1]}"},
+            {"error": f"Error on file {project_file_name}: {sys.exc_info()[1]}"},
             msg,
         )
 
@@ -1505,16 +1372,16 @@ def open_project_json(projectFileName: str) -> tuple:
         pj = json.loads(file_content)
     except json.decoder.JSONDecodeError:
         return (
-            projectFileName,
+            project_file_name,
             projectChanged,
             {"error": "This project file seems corrupted"},
             msg,
         )
     except Exception:
         return (
-            projectFileName,
+            project_file_name,
             projectChanged,
-            {"error": f"Error on file {projectFileName}: {sys.exc_info()[1]}"},
+            {"error": f"Error on file {project_file_name}: {sys.exc_info()[1]}"},
             msg,
         )
 
@@ -1534,11 +1401,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": (
@@ -1551,13 +1416,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"]
@@ -1566,6 +1429,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]]}
 
@@ -1583,15 +1447,13 @@ 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
 
     # check if project format version < 4 (modifiers were str)
     project_lowerthan4 = False
-    if cfg.PROJECT_VERSION in pj and util.versiontuple(
-        pj[cfg.PROJECT_VERSION]
-    ) < util.versiontuple("4.0"):
+    if cfg.PROJECT_VERSION in pj and util.versiontuple(pj[cfg.PROJECT_VERSION]) < util.versiontuple("4.0"):
         for idx in pj[cfg.ETHOGRAM]:
             if pj[cfg.ETHOGRAM][idx]["modifiers"]:
                 if isinstance(pj[cfg.ETHOGRAM][idx]["modifiers"], str):
@@ -1609,40 +1471,46 @@ 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]:
-        if (
-            pj[cfg.OBSERVATIONS][obs][cfg.TYPE] in [cfg.MEDIA]
-            and cfg.MEDIA_INFO not in pj[cfg.OBSERVATIONS][obs]
-        ):
+        if pj[cfg.OBSERVATIONS][obs][cfg.TYPE] in [cfg.MEDIA] and cfg.MEDIA_INFO not in pj[cfg.OBSERVATIONS][obs]:
             pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO] = {
                 cfg.LENGTH: {},
                 cfg.FPS: {},
                 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,
+                            project_file_name,
                             projectChanged,
                             {"error": "FFmpeg path not found"},
                             "",
@@ -1653,64 +1521,35 @@ def open_project_json(projectFileName: str) -> tuple:
                     r = util.accurate_media_analysis(ffmpeg_bin, media_file_path)
 
                     if "duration" in r and r["duration"]:
-                        pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.LENGTH][
-                            media_file_path
-                        ] = float(r["duration"])
-                        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"]
+                        pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.LENGTH][media_file_path] = float(r["duration"])
+                        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"]
                         projectChanged = True
                     else:  # file path not found
                         if (
                             cfg.MEDIA_FILE_INFO in pj[cfg.OBSERVATIONS][obs]
                             and len(pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO]) == 1
-                            and len(pj[cfg.OBSERVATIONS][obs][cfg.FILE][cfg.PLAYER1])
-                            == 1
-                            and len(pj[cfg.OBSERVATIONS][obs][cfg.FILE][cfg.PLAYER2])
-                            == 0
+                            and len(pj[cfg.OBSERVATIONS][obs][cfg.FILE][cfg.PLAYER1]) == 1
+                            and len(pj[cfg.OBSERVATIONS][obs][cfg.FILE][cfg.PLAYER2]) == 0
                         ):
-                            media_md5_key = list(
-                                pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO].keys()
-                            )[0]
+                            media_md5_key = list(pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO].keys())[0]
                             # 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
 
                             # FPS
-                            if (
-                                "nframe"
-                                in pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_FILE_INFO][
-                                    media_md5_key
-                                ]
-                            ):
+                            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
-                                }
+                                pj[cfg.OBSERVATIONS][obs][cfg.MEDIA_INFO][cfg.FPS] = {media_file_path: 0}
 
     # update project to v.7 for time offset second player
     project_lowerthan7 = False
@@ -1723,9 +1562,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
@@ -1739,49 +1576,49 @@ 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
 
 
-def fix_unpaired_state_events(
-    ethogram: dict, observation: dict, fix_at_time: dec
-) -> list:
+def fix_unpaired_state_events(ethogram: dict, observation: dict, fix_at_time: dec) -> list:
     """
     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
@@ -1790,31 +1627,23 @@ def fix_unpaired_state_events(
         list: list of events with state events fixed
     """
 
-    closing_events_to_add = []
-    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
+                    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],
@@ -1828,19 +1657,78 @@ def fix_unpaired_state_events(
                         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])
 
-                    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"),
+                            # last_event_time + dec("0.001"),
+                            last_event_time,
                             subject,
                             behavior,
-                            event[1],
-                            "",
-                        ]  # modifiers  # comment
+                            event[1],  # modifiers
+                            "Event automatically added by the fix unpaired state events function",
+                            cfg.NA,  # frame index
+                        ]
                     )
 
     return closing_events_to_add
@@ -1867,8 +1755,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 = []
@@ -1891,9 +1782,7 @@ def explore_project(self) -> None:
         nb_fields += explore_dlg.elements[element].text() != ""
 
     for obs_id in sorted(self.pj[cfg.OBSERVATIONS]):
-        for event_idx, event in enumerate(
-            self.pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]
-        ):
+        for event_idx, event in enumerate(self.pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]):
             nb_results = 0
             for text, idx in (
                 (explore_dlg.elements["Subject"].text(), cfg.EVENT_SUBJECT_FIELD_IDX),
@@ -1904,14 +1793,8 @@ def explore_project(self) -> None:
                 if text:
                     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()
-                            ),
+                            (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()),
                         )
                     ):
                         nb_results += 1
@@ -1928,26 +1811,232 @@ def explore_project(self) -> None:
         txt2 = ""
         for element in elements_list:
             if explore_dlg.elements[element].text():
-                txt2 += (
-                    f"<b>{explore_dlg.elements[element].text()}</b> in {element}<br>"
-                )
+                txt2 += f"<b>{explore_dlg.elements[element].text()}</b> in {element}<br>"
         if txt2:
             txt += " for<br>"
         self.results_dialog.lb.setText(txt + txt2)
         self.results_dialog.tw.setColumnCount(2)
         self.results_dialog.tw.setRowCount(len(results))
-        self.results_dialog.tw.setHorizontalHeaderLabels(
-            ["Observation id", "row index"]
-        )
+        self.results_dialog.tw.setHorizontalHeaderLabels(["Observation id", "row index"])
 
         for row, result in enumerate(results):
             for i in range(0, 2):
                 self.results_dialog.tw.setItem(row, i, QTableWidgetItem(str(result[i])))
-                self.results_dialog.tw.item(row, i).setFlags(
-                    Qt.ItemIsSelectable | Qt.ItemIsEnabled
-                )
+                self.results_dialog.tw.item(row, i).setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
 
         self.results_dialog.show()
 
     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)