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

boris/export_observation.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
@@ -29,7 +29,7 @@ import math
 import pathlib
 from io import StringIO
 import pandas as pd
-from typing import List, Tuple, Dict
+from typing import Tuple
 
 try:
     import pyreadr
@@ -44,6 +44,7 @@ from . import utilities as util
 from . import project_functions
 from . import observation_operations
 from . import db_functions
+from . import event_operations
 
 
 def export_events_jwatcher(
@@ -65,7 +66,6 @@ def export_events_jwatcher(
         str: error message
     """
     for subject in parameters[cfg.SELECTED_SUBJECTS]:
-
         # select events for current subject
         events = []
         for event in observation[cfg.EVENTS]:
@@ -79,9 +79,7 @@ def export_events_jwatcher(
 
         total_length = 0  # in seconds
         if observation[cfg.EVENTS]:
-            total_length = (
-                observation[cfg.EVENTS][-1][0] - observation[cfg.EVENTS][0][0]
-            )  # last event time - first event time
+            total_length = observation[cfg.EVENTS][-1][0] - observation[cfg.EVENTS][0][0]  # last event time - first event time
 
         file_name_subject = str(pathlib.Path(file_name).parent / pathlib.Path(file_name).stem) + "_" + subject + ".dat"
 
@@ -119,14 +117,13 @@ def export_events_jwatcher(
             behav_code = event[cfg.EVENT_BEHAVIOR_FIELD_IDX]
 
             try:
-                behavior_key = [
-                    ethogram[k][cfg.BEHAVIOR_KEY] for k in ethogram if ethogram[k][cfg.BEHAVIOR_CODE] == behav_code
-                ][0]
+                behavior_key = [ethogram[k][cfg.BEHAVIOR_KEY] for k in ethogram if ethogram[k][cfg.BEHAVIOR_CODE] == behav_code][0]
             except Exception:
                 # coded behavior not defined in ethogram
                 continue
-            if [ethogram[k][cfg.TYPE] for k in ethogram if ethogram[k][cfg.BEHAVIOR_CODE] == behav_code] == [
-                cfg.STATE_EVENT
+            if [ethogram[k][cfg.TYPE] for k in ethogram if ethogram[k][cfg.BEHAVIOR_CODE] == behav_code] in [
+                [cfg.STATE_EVENT],
+                [cfg.STATE_EVENT_WITH_CODING_MAP],
             ]:
                 if behav_code in mem_number_of_state_events:
                     mem_number_of_state_events[behav_code] += 1
@@ -154,7 +151,7 @@ def export_events_jwatcher(
         if fmf_file_path.exists():
             fmf_creation_answer = dialog.MessageDialog(
                 cfg.programName,
-                (f"The {fmf_file_path} file already exists.<br>" "What do you want to do?"),
+                (f"The {fmf_file_path} file already exists.<br>What do you want to do?"),
                 [cfg.OVERWRITE, "Skip file creation", cfg.CANCEL],
             )
 
@@ -167,11 +164,9 @@ def export_events_jwatcher(
         rows.append("# Format: Focal Master File 1.0")
         rows.append(f"# Updated: {dt.datetime.now().isoformat()}")
         rows.append("#-----------------------------------------------------------")
-        for (behav, key) in all_observed_behaviors:
+        for behav, key in all_observed_behaviors:
             rows.append(f"Behaviour.name.{key}={behav}")
-            behav_description = [
-                ethogram[k][cfg.DESCRIPTION] for k in ethogram if ethogram[k][cfg.BEHAVIOR_CODE] == behav
-            ][0]
+            behav_description = [ethogram[k][cfg.DESCRIPTION] for k in ethogram if ethogram[k][cfg.BEHAVIOR_CODE] == behav][0]
             rows.append(f"Behaviour.description.{key}={behav_description}")
 
         rows.append(f"DurationMilliseconds={int(float(total_length) * 1000)}")
@@ -198,7 +193,7 @@ def export_events_jwatcher(
         if faf_file_path.exists():
             faf_creation_answer = dialog.MessageDialog(
                 cfg.programName,
-                (f"The {faf_file_path} file already exists.<br>" "What do you want to do?"),
+                (f"The {faf_file_path} file already exists.<br>What do you want to do?"),
                 [cfg.OVERWRITE, "Skip file creation", cfg.CANCEL],
             )
             if faf_creation_answer == cfg.CANCEL:
@@ -275,7 +270,7 @@ def export_events_jwatcher(
         rows.append("AllCodesMutuallyExclusive=true")
         rows.append("")
 
-        for (behav, key) in all_observed_behaviors:
+        for behav, key in all_observed_behaviors:
             rows.append(f"Behavior.isModified.{key}=false")
             rows.append(f"Behavior.isSubtracted.{key}=false")
             rows.append(f"Behavior.isIgnored.{key}=false")
@@ -294,14 +289,14 @@ def export_events_jwatcher(
 
 
 def export_tabular_events(
-    pj: dict, parameters: dict, obsId: str, observation: dict, ethogram: dict, file_name: str, output_format: str
+    pj: dict, parameters: dict, obs_id: str, observation: dict, ethogram: dict, file_name: str, output_format: str
 ) -> Tuple[bool, str]:
     """
-    export events for one observation (obsId)
+    export events for one observation (obs_id)
 
     Args:
         parameters (dict): subjects, behaviors
-        obsId (str): observation id
+        obs_id (str): observation id
         observation (dict): observation
         ethogram (dict): ethogram of project
         file_name (str): file name for exporting events
@@ -312,25 +307,21 @@ def export_tabular_events(
         str: error message
     """
 
-    logging.debug(f"function: export tabular events for {obsId}")
+    logging.debug(f"function: export tabular events for {obs_id}")
     logging.debug(f"parameters: {parameters}")
 
     interval = parameters["time"]
 
-    start_coding, end_coding, coding_duration = observation_operations.coding_time(pj[cfg.OBSERVATIONS], [obsId])
-    """
-    if start_coding is None and end_coding is None:  # no events
-        return data, 0
-    """
+    start_coding, end_coding, coding_duration = observation_operations.coding_time(pj[cfg.OBSERVATIONS], [obs_id])
+    start_interval, end_interval = observation_operations.time_intervals_range(pj[cfg.OBSERVATIONS], [obs_id])
 
     if interval == cfg.TIME_EVENTS:
         min_time = start_coding
         max_time = end_coding
 
     if interval == cfg.TIME_FULL_OBS:
-
         if observation[cfg.TYPE] == cfg.MEDIA:
-            max_media_duration, _ = observation_operations.media_duration(pj[cfg.OBSERVATIONS], [obsId])
+            max_media_duration, _ = observation_operations.media_duration(pj[cfg.OBSERVATIONS], [obs_id])
             min_time = dec("0")
             max_time = max_media_duration
             coding_duration = max_media_duration
@@ -343,13 +334,19 @@ def export_tabular_events(
         min_time = parameters[cfg.START_TIME]
         max_time = parameters[cfg.END_TIME]
 
+    if interval == cfg.TIME_OBS_INTERVAL:
+        max_media_duration, _ = observation_operations.media_duration(pj[cfg.OBSERVATIONS], [obs_id])
+        min_time = start_interval
+        # Use max media duration for max time if no interval is defined (=0)
+        max_time = end_interval if end_interval != 0 else max_media_duration
+
     logging.debug(f"min_time: {min_time}  max_time: {max_time}")
 
-    eventsWithStatus = project_functions.events_start_stop(ethogram, observation[cfg.EVENTS])
+    events_with_status = project_functions.events_start_stop(ethogram, observation[cfg.EVENTS], observation[cfg.TYPE])
 
     # check max number of modifiers
     max_modifiers = 0
-    for event in eventsWithStatus:
+    for event in events_with_status:
         if not math.isnan(min_time) and not math.isnan(max_time):  # obs not from pictures
             if min_time <= event[cfg.EVENT_TIME_FIELD_IDX] <= max_time:
                 if event[cfg.EVENT_MODIFIER_FIELD_IDX]:
@@ -359,10 +356,7 @@ def export_tabular_events(
                 max_modifiers = max(max_modifiers, len(event[cfg.EVENT_MODIFIER_FIELD_IDX].split("|")))
 
     # media file number
-    mediaNb = 0
-    if observation[cfg.TYPE] == cfg.MEDIA:
-        for player in observation[cfg.FILE]:
-            mediaNb += len(observation[cfg.FILE][player])
+    media_nb = util.count_media_file(observation[cfg.FILE])
 
     rows: list = []
 
@@ -374,9 +368,14 @@ def export_tabular_events(
         "Observation duration": float,
         "Observation type": str,
         "Source": str,
-        "Media duration (s)": str,
-        "FPS": float,
+        "Time offset (s)": str,
     }
+    if media_nb == 1:
+        fields_type["Media duration (s)"] = float
+        fields_type["FPS"] = float
+    else:
+        fields_type["Media duration (s)"] = str
+        fields_type["FPS"] = str
 
     # independent variables
     if cfg.INDEPENDENT_VARIABLES in observation:
@@ -414,16 +413,15 @@ def export_tabular_events(
         except KeyError:
             pass
 
-    for event in eventsWithStatus:
+    for event in events_with_status:
         if (not math.isnan(min_time)) and not (min_time <= event[cfg.EVENT_TIME_FIELD_IDX] <= max_time):
             continue
         if (
             (event[cfg.EVENT_SUBJECT_FIELD_IDX] in parameters[cfg.SELECTED_SUBJECTS])
             or (event[cfg.EVENT_SUBJECT_FIELD_IDX] == "" and cfg.NO_FOCAL_SUBJECT in parameters[cfg.SELECTED_SUBJECTS])
         ) and (event[cfg.EVENT_BEHAVIOR_FIELD_IDX] in parameters[cfg.SELECTED_BEHAVIORS]):
-
             fields: list = []
-            fields.append(obsId)
+            fields.append(obs_id)
             fields.append(observation.get("date", "").replace("T", " "))
             fields.append(util.eol2space(observation.get(cfg.DESCRIPTION, "")))
             # total length
@@ -439,9 +437,7 @@ def export_tabular_events(
                         for media_file in observation[cfg.FILE][player]:
                             media_file_lst.append(media_file)
                             fps_lst.append(f"{observation[cfg.MEDIA_INFO][cfg.FPS].get(media_file, cfg.NA):.3f}")
-                            media_durations_lst.append(
-                                f"{observation[cfg.MEDIA_INFO][cfg.LENGTH].get(media_file, cfg.NA):.3f}"
-                            )
+                            media_durations_lst.append(f"{observation[cfg.MEDIA_INFO][cfg.LENGTH].get(media_file, cfg.NA):.3f}")
                         if player > "1":
                             media_file_str += "|"
                             fps_str += "|"
@@ -491,6 +487,9 @@ def export_tabular_events(
             else:
                 fields.append("")
 
+            # time offset
+            fields.append(observation[cfg.TIME_OFFSET])
+
             # media duration
             fields.append(media_durations_str)
 
@@ -525,14 +524,11 @@ def export_tabular_events(
             fields.append(event[-1])
 
             # time
-            # if event[cfg.EVENT_TIME_FIELD_IDX]
             fields.append(util.convertTime(time_format=cfg.S, sec=event[cfg.EVENT_TIME_FIELD_IDX]))
 
             # check video file name containing the event
             if observation[cfg.TYPE] == cfg.MEDIA:
-                video_file_name = observation_operations.event2media_file_name(
-                    observation, event[cfg.EVENT_TIME_FIELD_IDX]
-                )
+                video_file_name = observation_operations.event2media_file_name(observation, event[cfg.EVENT_TIME_FIELD_IDX])
                 if video_file_name is None:
                     video_file_name = "Not found"
 
@@ -540,292 +536,17 @@ def export_tabular_events(
                 video_file_name = cfg.NA
             fields.append(video_file_name)
 
-            # image file path
-            if observation[cfg.TYPE] == cfg.IMAGES:
-                fields.append(event[cfg.PJ_OBS_FIELDS[cfg.IMAGES][cfg.IMAGE_PATH]])  # image file path
-            elif observation[cfg.TYPE] in (cfg.LIVE, cfg.MEDIA):
-                fields.append(cfg.NA)
-            else:
-                fields.append("")
-
             # image file index
             if observation[cfg.TYPE] == cfg.IMAGES:
                 fields.append(event[cfg.PJ_OBS_FIELDS[cfg.IMAGES][cfg.IMAGE_INDEX]])  # image file index
-            elif observation[cfg.TYPE] in (cfg.LIVE, cfg.MEDIA):
-                fields.append(cfg.NA)
-            else:
-                fields.append("")
-
-            # comment
-            fields.append(event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.COMMENT]].replace(os.linesep, " "))
-
-            rows.append(fields)
-
-    max_len = max([len(r) for r in rows])
-    data = tablib.Dataset()
-
-    data.title = util.safe_xl_worksheet_title(obsId, output_format)
-
-    for row in rows:
-        data.append(util.complete(row, max_len))
-
-    r, msg = dataset_write(data, file_name, output_format, dtype=fields_type)
-
-    return r, msg
-
-
-'''
-def export_tabular_events_old(
-    parameters: dict, obsId: str, observation: dict, ethogram: dict, file_name: str, output_format: str
-) -> Tuple[bool, str]:
-    """
-    export events for one observation (obsId)
-
-    Args:
-        parameters (dict): subjects, behaviors
-        obsId (str): observation id
-        observation (dict): observation
-        ethogram (dict): ethogram of project
-        file_name (str): file name for exporting events
-        output_format (str): output for exporting events
-
-    Returns:
-        bool: result: True if OK else False
-        str: error message
-    """
-
-    logging.debug(f"function: export tabular events for {obsId} parameters: {parameters} ")
-
-    interval = parameters["time"]
-    start_time = parameters[cfg.START_TIME]
-    end_time = parameters[cfg.END_TIME]
-
-    total_length = observation_operations.observation_total_length(observation)
-
-    logging.debug(f"total_length: {total_length}")
-
-    if total_length == dec(-1):  # media length not available
-        interval = cfg.TIME_EVENTS
-
-    if total_length == dec(-2):  # obs without timestamp
-        interval = cfg.TIME_EVENTS
-
-    if interval == cfg.TIME_FULL_OBS:
-        min_time = float(0)
-        max_time = float(total_length)
-        total_length_str = f"{max_time - min_time:.3f}"
-
-    if interval == cfg.TIME_EVENTS:
-        start_coding, end_coding, _ = observation_operations.coding_time({obsId: observation}, [obsId])
-        if start_coding.is_nan():
-            total_length_str = cfg.NA
-        else:
-            min_time = float(start_coding)
-            max_time = float(end_coding)
-            total_length_str = f"{max_time - min_time:.3f}"
-        """
-        try:
-            min_time = float(observation[cfg.EVENTS][0][0])
-        except Exception:
-            min_time = float(0)
-        try:
-            max_time = float(observation[cfg.EVENTS][-1][0])
-        except Exception:
-            max_time = float(total_length)
-        """
-
-    if interval == cfg.TIME_ARBITRARY_INTERVAL:
-        min_time = float(start_time)
-        max_time = float(end_time)
-        total_length_str = f"{max_time - min_time:.3f}"
-
-    """
-    if total_length == -2:  # obs from pictures
-        total_length_str = cfg.NA
-    else:
-        total_length_str = f"{parameters[cfg.END_TIME] - parameters[cfg.START_TIME]:.3f}"
-    """
-
-    eventsWithStatus = project_functions.events_start_stop(ethogram, observation[cfg.EVENTS])
-
-    # check max number of modifiers
-    max_modifiers = 0
-    for event in eventsWithStatus:
-        if total_length != dec(-2):  # obs not from pictures
-            if min_time <= event[cfg.EVENT_TIME_FIELD_IDX] <= max_time:
-                if event[cfg.EVENT_MODIFIER_FIELD_IDX]:
-                    max_modifiers = max(max_modifiers, len(event[cfg.EVENT_MODIFIER_FIELD_IDX].split("|")))
-        else:
-            if event[cfg.EVENT_MODIFIER_FIELD_IDX]:
-                max_modifiers = max(max_modifiers, len(event[cfg.EVENT_MODIFIER_FIELD_IDX].split("|")))
-
-    # media file number
-    mediaNb = 0
-    if observation[cfg.TYPE] == cfg.MEDIA:
-        for player in observation[cfg.FILE]:
-            mediaNb += len(observation[cfg.FILE][player])
-
-    rows: list = []
-
-    # fields and type
-    fields_type: dict = {
-        "Observation id": str,
-        "Observation date": dt.datetime,
-        "Description": str,
-        "Observation duration": float,
-        "Observation type": str,
-        "Source": str,
-        "FPS": float,
-    }
-
-    # independent variables
-    if cfg.INDEPENDENT_VARIABLES in observation:
-        for variable in observation[cfg.INDEPENDENT_VARIABLES]:
-            # TODO check variable type
-            fields_type[variable] = str
-
-    fields_type.update({"Subject": str, "Behavior": str, "Behavioral category": str})
-
-    # modifiers
-    for idx in range(max_modifiers):
-        fields_type[f"Modifier #{idx + 1}"] = str
-
-    fields_type.update(
-        {
-            "Behavior type": str,
-            "Time": float,
-            "Media file name": str,
-            "Image index": float,  # add image index and image file path to header
-            "Image file path": str,
-            "Comment": str,
-        }
-    )
-
-    # add header
-    rows.append(list(fields_type.keys()))
-
-    behavioral_category = project_functions.behavior_category(ethogram)
-
-    duration1 = []  # in seconds
-    if observation[cfg.TYPE] == cfg.MEDIA:
-        try:
-            for mediaFile in observation[cfg.FILE][cfg.PLAYER1]:
-                duration1.append(observation[cfg.MEDIA_INFO][cfg.LENGTH][mediaFile])
-        except KeyError:
-            pass
-
-    for event in eventsWithStatus:
-        if (total_length != dec(-2)) and not (min_time <= event[cfg.EVENT_TIME_FIELD_IDX] <= max_time):
-            continue
-        if (
-            (event[cfg.EVENT_SUBJECT_FIELD_IDX] in parameters[cfg.SELECTED_SUBJECTS])
-            or (event[cfg.EVENT_SUBJECT_FIELD_IDX] == "" and cfg.NO_FOCAL_SUBJECT in parameters[cfg.SELECTED_SUBJECTS])
-        ) and (event[cfg.EVENT_BEHAVIOR_FIELD_IDX] in parameters[cfg.SELECTED_BEHAVIORS]):
-
-            fields: list = []
-            fields.append(obsId)
-            fields.append(observation.get("date", "").replace("T", " "))
-            fields.append(util.eol2space(observation.get("description", "")))
-            # total length
-            fields.append(total_length_str)
-
-            if observation[cfg.TYPE] == cfg.MEDIA:
-                fields.append("Media file(s)")
-
-                media_file_str, fps_str = "", ""
-                # number of players
-                n_players = len([x for x in observation[cfg.FILE] if observation[cfg.FILE][x]])
-                for player in observation[cfg.FILE]:
-                    if observation[cfg.FILE][player]:
-                        if media_file_str:
-                            media_file_str += " "
-                        if fps_str:
-                            fps_str += " "
-                        if n_players > 1:
-                            media_file_str += f"player #{player}: "
-                            fps_str += f"player #{player}: "
-                        media_list, fps_list = [], []
-                        for media_file in observation[cfg.FILE][player]:
-                            media_list.append(media_file)
-                            fps_list.append(f"{observation[cfg.MEDIA_INFO][cfg.FPS].get(media_file, cfg.NA):.3f}")
-                        media_file_str += ";".join(media_list)
-                        fps_str += ";".join(fps_list)
-
-                fields.append(media_file_str)
-
+            elif observation[cfg.TYPE] == cfg.MEDIA:
+                frame_idx = event_operations.read_event_field(event, cfg.MEDIA, cfg.FRAME_INDEX)
+                fields.append(frame_idx)  # frame index
             elif observation[cfg.TYPE] == cfg.LIVE:
-                fields.append("Live observation")
                 fields.append(cfg.NA)
-                fps_str = cfg.NA
-
-            elif observation[cfg.TYPE] == cfg.IMAGES:
-                fields.append("From directories of images")
-                dir_list = []
-                for dir in observation[cfg.DIRECTORIES_LIST]:
-                    dir_list.append(dir)
-                fields.append(";".join(dir_list))
-                fps_str = cfg.NA
-
             else:
                 fields.append("")
 
-            # FPS
-            fields.append(fps_str)
-
-            # indep var
-            if cfg.INDEPENDENT_VARIABLES in observation:
-                for variable in observation[cfg.INDEPENDENT_VARIABLES]:
-                    fields.append(observation[cfg.INDEPENDENT_VARIABLES][variable])
-
-            fields.append(event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.SUBJECT]])
-            fields.append(event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.BEHAVIOR_CODE]])
-
-            # behavioral category
-            try:
-                behav_category = behavioral_category[event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.BEHAVIOR_CODE]]]
-            except Exception:
-                behav_category = ""
-            fields.append(behav_category)
-
-            # modifiers
-            if max_modifiers:
-                modifiers = event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.MODIFIER]].split("|")
-                while len(modifiers) < max_modifiers:
-                    modifiers.append("")
-
-                for m in modifiers:
-                    fields.append(m)
-
-            # status (START/STOP)
-            fields.append(event[-1])
-
-            # time
-            # if event[cfg.EVENT_TIME_FIELD_IDX]
-            fields.append(util.convertTime(time_format=cfg.S, sec=event[cfg.EVENT_TIME_FIELD_IDX]))
-
-            # check video file name containing the event
-            if observation[cfg.TYPE] == cfg.MEDIA:
-                cumul_media_durations = [0]
-                for media_file in observation[cfg.FILE]["1"]:
-                    media_duration = observation[cfg.MEDIA_INFO][cfg.LENGTH][media_file]
-                    cumul_media_durations.append(cumul_media_durations[-1] + media_duration)
-
-                player_idx_list = [
-                    idx
-                    for idx, x in enumerate(cumul_media_durations)
-                    if cumul_media_durations[idx - 1] < event[cfg.EVENT_TIME_FIELD_IDX] <= x
-                ]
-                if len(player_idx_list):
-                    player_idx = player_idx_list[0] - 1
-                    video_file_name = observation[cfg.FILE]["1"][player_idx]
-                else:
-                    player_idx = -1
-                    video_file_name = "Not found"
-
-            elif observation[cfg.TYPE] in (cfg.LIVE, cfg.IMAGES):
-                video_file_name = cfg.NA
-            fields.append(video_file_name)
-
             # image file path
             if observation[cfg.TYPE] == cfg.IMAGES:
                 fields.append(event[cfg.PJ_OBS_FIELDS[cfg.IMAGES][cfg.IMAGE_PATH]])  # image file path
@@ -834,14 +555,6 @@ def export_tabular_events_old(
             else:
                 fields.append("")
 
-            # image file index
-            if observation[cfg.TYPE] == cfg.IMAGES:
-                fields.append(event[cfg.PJ_OBS_FIELDS[cfg.IMAGES][cfg.IMAGE_INDEX]])  # image file index
-            elif observation[cfg.TYPE] in (cfg.LIVE, cfg.MEDIA):
-                fields.append(cfg.NA)
-            else:
-                fields.append("")
-
             # comment
             fields.append(event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.COMMENT]].replace(os.linesep, " "))
 
@@ -850,7 +563,7 @@ def export_tabular_events_old(
     max_len = max([len(r) for r in rows])
     data = tablib.Dataset()
 
-    data.title = util.safe_xl_worksheet_title(obsId, output_format)
+    data.title = util.safe_xl_worksheet_title(obs_id, output_format)
 
     for row in rows:
         data.append(util.complete(row, max_len))
@@ -858,213 +571,9 @@ def export_tabular_events_old(
     r, msg = dataset_write(data, file_name, output_format, dtype=fields_type)
 
     return r, msg
-'''
-
-'''
-def export_tabular_events_long_format(
-    parameters, obsId: str, observation: dict, ethogram: dict, file_name: str, output_format: str
-) -> tuple:  # -> tuple[bool, str]:
-    """
-    export events
-
-    Args:
-        parameters (dict): subjects, behaviors
-        obsId (str): observation id
-        observation (dict): observation
-        ethogram (dict): ethogram of project
-        file_name (str): file name for exporting events
-        output_format (str): output for exporting events
-
-    Returns:
-        bool: result: True if OK else False
-        str: error message
-    """
-
-    total_length = f"{observation_operations.observation_total_length(observation):.3f}"
-
-    eventsWithStatus = project_functions.events_start_stop(ethogram, observation[cfg.EVENTS])
-
-    # check max number of modifiers
-    max_modifiers = 0
-    for event in eventsWithStatus:
-        if event[cfg.EVENT_MODIFIER_FIELD_IDX]:
-            max_modifiers = max(max_modifiers, len(event[cfg.EVENT_MODIFIER_FIELD_IDX].split("|")))
-
-    # media file number
-    mediaNb = 0
-    if observation[cfg.TYPE] == cfg.MEDIA:
-        for player in observation[cfg.FILE]:
-            mediaNb += len(observation[cfg.FILE][player])
-
-    rows = []
-
-    # observation id
-    rows.append(["Observation id", obsId])
-    rows.append([""])
-
-    # media file name
-    if observation[cfg.TYPE] == cfg.MEDIA:
-        rows.append(["Media file(s)"])
-    elif observation[cfg.TYPE] == cfg.LIVE:
-        rows.append(["Live observation"])
-    elif observation[cfg.TYPE] == cfg.IMAGES:
-        rows.append(["From directories of images"])
-    else:
-        rows.append([""])
-    rows.append([""])
-
-    if observation[cfg.TYPE] == cfg.MEDIA:
-        for player in sorted(list(observation[cfg.FILE].keys())):
-            for media in observation[cfg.FILE][player]:
-                rows.append([f"Player #{player}", media])
-
-    if observation[cfg.TYPE] == cfg.IMAGES:
-        for dir in observation[cfg.DIRECTORIES_LIST]:
-            rows.append([f"Directory", dir])
-
-    rows.append([""])
-
-    # date
-    rows.append(["Observation date", observation.get("date", "").replace("T", " ")])
-    rows.append([""])
-
-    # description
-    rows.append(["Description", util.eol2space(observation.get("description", ""))])
-    rows.append([""])
-
-    # time offset
-    rows.append(["Time offset (s)", observation.get(cfg.TIME_OFFSET, 0)])
-    rows.append([""])
-
-    # independent variables
-    if cfg.INDEPENDENT_VARIABLES in observation:
-        rows.extend([["independent variables"], ["variable", "value"]])
-
-        for variable in observation[cfg.INDEPENDENT_VARIABLES]:
-            rows.append([variable, observation[cfg.INDEPENDENT_VARIABLES][variable]])
-
-    rows.append([""])
-
-    # write table header
-    col = 0
-
-    header = ["Time"]
-    if observation[cfg.TYPE] == cfg.MEDIA:
-        header.extend(["Media file path", "Total length", "FPS"])
-    if observation[cfg.TYPE] == cfg.IMAGES:
-        header.extend(
-            [
-                "Image file path",
-                "Image index",
-            ]
-        )
-    if observation[cfg.TYPE] == cfg.LIVE:
-        header.extend(
-            [
-                "Total length",
-            ]
-        )
-
-    header.extend(["Subject", "Behavior", "Behavioral category"])
-
-    behavioral_category = project_functions.behavior_category(ethogram)
-
-    for x in range(1, max_modifiers + 1):
-        header.append(f"Modifier {x}")
-    header.extend(["Comment", "Status"])
-
-    rows.append(header)
-
-    duration1 = []  # in seconds
-    if observation[cfg.TYPE] == cfg.MEDIA:
-        try:
-            for mediaFile in observation[cfg.FILE][cfg.PLAYER1]:
-                duration1.append(observation[cfg.MEDIA_INFO][cfg.LENGTH][mediaFile])
-        except KeyError:
-            pass
-
-    for event in eventsWithStatus:
-        if (
-            (event[cfg.EVENT_SUBJECT_FIELD_IDX] in parameters[cfg.SELECTED_SUBJECTS])
-            or (event[cfg.EVENT_SUBJECT_FIELD_IDX] == "" and cfg.NO_FOCAL_SUBJECT in parameters[cfg.SELECTED_SUBJECTS])
-        ) and (event[cfg.EVENT_BEHAVIOR_FIELD_IDX] in parameters[cfg.SELECTED_BEHAVIORS]):
-
-            fields = []
-            fields.append(util.intfloatstr(str(event[cfg.EVENT_TIME_FIELD_IDX])))
-
-            if observation[cfg.TYPE] == cfg.MEDIA:
-
-                time_ = event[cfg.EVENT_TIME_FIELD_IDX] - observation[cfg.TIME_OFFSET]
-                if time_ < 0:
-                    time_ = 0
-
-                if duration1:
-                    mediaFileIdx = [idx1 for idx1, x in enumerate(duration1) if time_ >= sum(duration1[0:idx1])][-1]
-                    fields.append(observation[cfg.FILE][cfg.PLAYER1][mediaFileIdx])
-                    fields.append(total_length)
-                    # FPS
-                    try:
-                        fields.append(
-                            observation[cfg.MEDIA_INFO][cfg.FPS][observation[cfg.FILE][cfg.PLAYER1][mediaFileIdx]]
-                        )  # fps
-                    except KeyError:
-                        fields.append(cfg.NA)
-                else:
-                    fields.append(cfg.NA)  # media file
-                    fields.append(cfg.NA)  # FPS
-
-            if observation[cfg.TYPE] == cfg.LIVE:
-                fields.append(total_length)  # total length
-
-            if observation[cfg.TYPE] == cfg.IMAGES:
-                fields.append(event[cfg.PJ_OBS_FIELDS[cfg.IMAGES][cfg.IMAGE_PATH]])  # image file path
-                fields.append(event[cfg.PJ_OBS_FIELDS[cfg.IMAGES][cfg.IMAGE_INDEX]])  # image file index
-
-            fields.append(event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.SUBJECT]])
-            fields.append(event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.BEHAVIOR_CODE]])
-
-            # behavioral category
-
-            try:
-                behav_category = behavioral_category[event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.BEHAVIOR_CODE]]]
-            except Exception:
-                behav_category = ""
-            fields.append(behav_category)
-
-            # modifiers
-            if max_modifiers:
-                modifiers = event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.MODIFIER]].split("|")
-                while len(modifiers) < max_modifiers:
-                    modifiers.append("")
-
-                for m in modifiers:
-                    fields.append(m)
-
-            # comment
-            fields.append(event[cfg.PJ_OBS_FIELDS[observation[cfg.TYPE]][cfg.COMMENT]].replace(os.linesep, " "))
-            # status
-            fields.append(event[-1])
-
-            rows.append(fields)
-
-    maxLen = max([len(r) for r in rows])
-    data = tablib.Dataset()
-
-    data.title = util.safe_xl_worksheet_title(obsId, output_format)
-
-    for row in rows:
-        data.append(util.complete(row, maxLen))
-
-    r, msg = dataset_write(data, file_name, output_format)
-
-    return r, msg
-
-'''
 
 
-def dataset_write(
-    dataset: tablib.Dataset, file_name: str, output_format: str, dtype: dict = {}
-) -> tuple:  # -> tuple[bool, str]:
+def dataset_write(dataset: tablib.Dataset, file_name: str, output_format: str, dtype: dict = {}) -> tuple:  # -> tuple[bool, str]:
     """
     write a tablib dataset with aggregated events or tabular events to file in specified format (output_format)
 
@@ -1072,6 +581,7 @@ def dataset_write(
         dataset (tablib.dataset): dataset to write
         file_name (str): file name
         output_format (str): format of output
+        dtype (dict): type of field
 
     Returns:
         bool: result. True if OK else False
@@ -1081,11 +591,9 @@ def dataset_write(
     logging.debug("function: dataset_write")
 
     try:
-
-        if output_format in ("pkl", "rds"):
-
+        if output_format in (cfg.PANDAS_DF_EXT, cfg.RDS_EXT):
             # build pandas dataframe from the tsv export of tablib dataset
-            date_type = []
+            date_type: list = []
             for field_name in dtype:
                 if dtype[field_name] == dt.datetime:
                     date_type.append(field_name)
@@ -1094,27 +602,26 @@ def dataset_write(
                 del dtype[field_name]
 
             df = pd.read_csv(
-                StringIO(dataset.export("tsv")),
+                StringIO(dataset.export(cfg.TSV_EXT)),
                 sep="\t",
                 dtype=dtype,
                 parse_dates=date_type,
             )
 
-            if output_format == "pkl":
+            if output_format == cfg.PANDAS_DF_EXT:
                 df.to_pickle(file_name)
 
-            if flag_pyreadr_loaded and output_format == "rds":
+            if output_format == cfg.RDS_EXT and flag_pyreadr_loaded:
                 pyreadr.write_rds(file_name, df)
 
             return True, ""
 
-        if output_format in ("csv", "tsv", "html"):
+        if output_format in (cfg.CSV_EXT, cfg.TSV_EXT, cfg.HTML_EXT):
             with open(file_name, "wb") as f:
                 f.write(str.encode(dataset.export(output_format)))
             return True, ""
 
-        if output_format in ("ods", "xls", "xlsx"):
-
+        if output_format in (cfg.ODS_EXT, cfg.XLS_EXT, cfg.XLSX_EXT):
             dataset.title = util.safe_xl_worksheet_title(dataset.title, output_format)
 
             with open(file_name, "wb") as f:
@@ -1127,7 +634,7 @@ def dataset_write(
         return False, str(sys.exc_info()[1])
 
 
-def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[tablib.Dataset, int]:
+def export_aggregated_events(pj: dict, parameters: dict, obsId: str, force_number_modifiers: int = 0) -> Tuple[tablib.Dataset, int]:
     """
     export aggregated events of one observation
 
@@ -1135,6 +642,7 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
         pj (dict): BORIS project
         parameters (dict): subjects, behaviors
         obsId (str): observation id
+        force_number_modifiers (int): force the number of modifiers to return
 
     Returns:
         tablib.Dataset:
@@ -1149,6 +657,8 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
     data = tablib.Dataset()
 
     start_coding, end_coding, coding_duration = observation_operations.coding_time(pj[cfg.OBSERVATIONS], [obsId])
+    start_interval, end_interval = observation_operations.time_intervals_range(pj[cfg.OBSERVATIONS], [obsId])
+
     if start_coding is None and end_coding is None:  # no events
         return data, 0
 
@@ -1170,21 +680,22 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
         min_time = float(parameters[cfg.START_TIME])
         max_time = float(parameters[cfg.END_TIME])
 
+    if interval == cfg.TIME_OBS_INTERVAL:
+        max_media_duration, _ = observation_operations.media_duration(pj[cfg.OBSERVATIONS], [obsId])
+        min_time = float(start_interval)
+        # Use max media duration for max time if no interval is defined (=0)
+        max_time = float(end_interval) if end_interval != 0 else float(max_media_duration)
+
     logging.debug(f"min_time: {min_time}  max_time: {max_time}")
 
     # obs description
     obs_description = util.eol2space(observation[cfg.DESCRIPTION])
 
-    """
-    obs_length = observation_operations.observation_total_length(pj[cfg.OBSERVATIONS][obsId])
-    logging.debug(f"obs_length: {obs_length}")
-    """
-
     _, _, connector = db_functions.load_aggregated_events_in_db(
         pj, parameters[cfg.SELECTED_SUBJECTS], [obsId], parameters[cfg.SELECTED_BEHAVIORS]
     )
     if connector is None:
-        logging.critical(f"error when loading aggregated events in DB")
+        logging.critical("error when loading aggregated events in DB")
         return data, 0
 
     cursor = connector.cursor()
@@ -1238,13 +749,16 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
     behavioral_category = project_functions.behavior_category(pj[cfg.ETHOGRAM])
 
     cursor.execute("SELECT DISTINCT modifiers FROM aggregated_events")
-    max_modifiers = 0
-    for row in cursor.fetchall():
-        if row["modifiers"]:
-            max_modifiers = max(max_modifiers, row["modifiers"].count("|") + 1)
 
-    for subject in parameters[cfg.SELECTED_SUBJECTS]:
+    if not force_number_modifiers:
+        max_modifiers: int = 0
+        for row in cursor.fetchall():
+            if row["modifiers"]:
+                max_modifiers = max(max_modifiers, row["modifiers"].count("|") + 1)
+    else:
+        max_modifiers = force_number_modifiers
 
+    for subject in parameters[cfg.SELECTED_SUBJECTS]:
         # calculate observation duration by subject (by obs)
         cursor.execute(("SELECT SUM(stop - start) AS duration FROM aggregated_events WHERE subject = ? "), (subject,))
         duration_by_subject_by_obs = cursor.fetchone()["duration"]
@@ -1252,7 +766,6 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
             duration_by_subject_by_obs = round(duration_by_subject_by_obs, 3)
 
         for behavior in parameters[cfg.SELECTED_BEHAVIORS]:
-
             cursor.execute(
                 "SELECT DISTINCT modifiers FROM aggregated_events WHERE subject=? AND behavior=? ORDER BY modifiers",
                 (
@@ -1264,7 +777,6 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
             rows_distinct_modifiers = list(x[0] for x in cursor.fetchall())
 
             for distinct_modifiers in rows_distinct_modifiers:
-
                 cursor.execute(
                     (
                         "SELECT start, stop, type, modifiers, comment, comment_stop, "
@@ -1276,12 +788,12 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
                 )
 
                 for row in cursor.fetchall():
-
                     media_file_name = cfg.NA
 
                     if observation[cfg.TYPE] == cfg.MEDIA:
                         observation_type = "Media file"
 
+                        # get the media file name of the start of event
                         media_file_name = observation_operations.event2media_file_name(observation, row["start"])
                         if media_file_name is None:
                             media_file_name = "Not found"
@@ -1293,12 +805,8 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
                             if observation[cfg.FILE][player]:
                                 for media_file in observation[cfg.FILE][player]:
                                     media_file_lst.append(media_file)
-                                    fps_lst.append(
-                                        f"{observation[cfg.MEDIA_INFO][cfg.FPS].get(media_file, cfg.NA):.3f}"
-                                    )
-                                    media_durations_lst.append(
-                                        f"{observation[cfg.MEDIA_INFO][cfg.LENGTH].get(media_file, cfg.NA):.3f}"
-                                    )
+                                    fps_lst.append(f"{observation[cfg.MEDIA_INFO][cfg.FPS].get(media_file, cfg.NA):.3f}")
+                                    media_durations_lst.append(f"{observation[cfg.MEDIA_INFO][cfg.LENGTH].get(media_file, cfg.NA):.3f}")
                                 if player > "1":
                                     media_file_str += "|"
                                     fps_str += "|"
@@ -1330,7 +838,8 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
                             observation["date"].replace("T", " "),
                             obs_description,
                             observation_type,
-                            media_file_str,
+                            media_file_str,  # list of media used in observation
+                            pj[cfg.OBSERVATIONS][obsId][cfg.TIME_OFFSET],
                             f"{coding_duration:.3f}" if not coding_duration.is_nan() else cfg.NA,
                             media_durations_str,
                             fps_str,
@@ -1340,13 +849,8 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
                     # independent variables
                     if cfg.INDEPENDENT_VARIABLES in pj:
                         for idx_var in util.sorted_keys(pj[cfg.INDEPENDENT_VARIABLES]):
-                            if (
-                                pj[cfg.INDEPENDENT_VARIABLES][idx_var]["label"]
-                                in observation[cfg.INDEPENDENT_VARIABLES]
-                            ):
-                                var_value = observation[cfg.INDEPENDENT_VARIABLES][
-                                    pj[cfg.INDEPENDENT_VARIABLES][idx_var]["label"]
-                                ]
+                            if pj[cfg.INDEPENDENT_VARIABLES][idx_var]["label"] in observation[cfg.INDEPENDENT_VARIABLES]:
+                                var_value = observation[cfg.INDEPENDENT_VARIABLES][pj[cfg.INDEPENDENT_VARIABLES][idx_var]["label"]]
                                 if pj[cfg.INDEPENDENT_VARIABLES][idx_var]["type"] == "timestamp":
                                     var_value = var_value.replace("T", " ")
 
@@ -1389,9 +893,7 @@ def export_aggregated_events(pj: dict, parameters: dict, obsId: str) -> Tuple[ta
                                 f"{row['start']:.3f}" if row["start"] is not None else cfg.NA,
                                 f"{row['stop']:.3f}" if row["stop"] is not None else cfg.NA,
                                 # duration
-                                f"{row['stop'] - row['start']:.3f}"
-                                if (row["stop"] is not None) and (row["start"] is not None)
-                                else cfg.NA,
+                                f"{row['stop'] - row['start']:.3f}" if (row["stop"] is not None) and (row["start"] is not None) else cfg.NA,
                                 media_file_name,  # Media file name
                             ]
                         )
@@ -1427,10 +929,12 @@ def events_to_behavioral_sequences(pj, obs_id: str, subj: str, parameters: dict,
         str: behavioral string for selected subject in selected observation
     """
 
-    out = ""
-    current_states = []
+    out: str = ""
+    current_states: list = []
     # add status (POINT, START, STOP) to event
-    events_with_status = project_functions.events_start_stop(pj[cfg.ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS])
+    events_with_status = project_functions.events_start_stop(
+        pj[cfg.ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS], pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE]
+    )
 
     for event in events_with_status:
         # check if event in selected behaviors
@@ -1438,10 +942,7 @@ def events_to_behavioral_sequences(pj, obs_id: str, subj: str, parameters: dict,
         if event[cfg.EVENT_BEHAVIOR_FIELD_IDX] not in parameters[cfg.SELECTED_BEHAVIORS]:
             continue
 
-        if event[cfg.EVENT_SUBJECT_FIELD_IDX] == subj or (
-            subj == cfg.NO_FOCAL_SUBJECT and event[cfg.EVENT_SUBJECT_FIELD_IDX] == ""
-        ):
-
+        if event[cfg.EVENT_SUBJECT_FIELD_IDX] == subj or (subj == cfg.NO_FOCAL_SUBJECT and event[cfg.EVENT_SUBJECT_FIELD_IDX] == ""):
             # if event[cfg.EVENT_STATUS_FIELD_IDX] == cfg.POINT:
             if event[-1] == cfg.POINT:  # status is last element
                 if current_states:
@@ -1473,7 +974,6 @@ def events_to_behavioral_sequences(pj, obs_id: str, subj: str, parameters: dict,
 
             # if event[cfg.EVENT_STATUS_FIELD_IDX] == cfg.STOP:
             if event[-1] == cfg.STOP:
-
                 if parameters[cfg.INCLUDE_MODIFIERS]:
                     behav_modif = (
                         f"{event[cfg.EVENT_BEHAVIOR_FIELD_IDX]}"
@@ -1497,9 +997,7 @@ def events_to_behavioral_sequences(pj, obs_id: str, subj: str, parameters: dict,
     return out
 
 
-def events_to_behavioral_sequences_all_subj(
-    pj, obs_id: str, subjects_list: list, parameters: dict, behav_seq_separator: str
-) -> str:
+def events_to_behavioral_sequences_all_subj(pj, obs_id: str, subjects_list: list, parameters: dict, behav_seq_separator: str) -> str:
     """
     return the behavioral sequences for all selected subjects in obs_id
 
@@ -1516,7 +1014,9 @@ def events_to_behavioral_sequences_all_subj(
 
     out = ""
     current_states = {i: [] for i in subjects_list}
-    events_with_status = project_functions.events_start_stop(pj[cfg.ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS])
+    events_with_status = project_functions.events_start_stop(
+        pj[cfg.ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS], pj[cfg.OBSERVATIONS][obs_id][cfg.TYPE]
+    )
 
     for event in events_with_status:
         # check if event in selected behaviors
@@ -1526,14 +1026,11 @@ def events_to_behavioral_sequences_all_subj(
         if (event[cfg.EVENT_SUBJECT_FIELD_IDX] in subjects_list) or (
             event[cfg.EVENT_SUBJECT_FIELD_IDX] == "" and cfg.NO_FOCAL_SUBJECT in subjects_list
         ):
-
             subject = event[cfg.EVENT_SUBJECT_FIELD_IDX] if event[cfg.EVENT_SUBJECT_FIELD_IDX] else cfg.NO_FOCAL_SUBJECT
 
             if event[-1] == cfg.POINT:
                 if current_states[subject]:
-                    out += (
-                        f"[{subject}]" + "+".join(current_states[subject]) + "+" + event[cfg.EVENT_BEHAVIOR_FIELD_IDX]
-                    )
+                    out += f"[{subject}]" + "+".join(current_states[subject]) + "+" + event[cfg.EVENT_BEHAVIOR_FIELD_IDX]
                 else:
                     out += f"[{subject}]" + event[cfg.EVENT_BEHAVIOR_FIELD_IDX]
 
@@ -1559,7 +1056,6 @@ def events_to_behavioral_sequences_all_subj(
                 out += behav_seq_separator
 
             if event[-1] == cfg.STOP:
-
                 if parameters[cfg.INCLUDE_MODIFIERS]:
                     behav_modif = (
                         f"{event[cfg.EVENT_BEHAVIOR_FIELD_IDX]}"
@@ -1601,9 +1097,7 @@ def events_to_timed_behavioral_sequences(
         str: behavioral string for selected subject in selected observation
     """
 
-    out = ""
-    current_states = []
-    # events_with_status = project_functions.events_start_stop(pj[ETHOGRAM], pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS])
+    out: str = ""
 
     state_behaviors_codes = util.state_behavior_codes(pj[cfg.ETHOGRAM])
     delta = dec(str(round(precision, 3)))
@@ -1638,10 +1132,7 @@ def events_to_timed_behavioral_sequences(
     return out
 
 
-def observation_to_behavioral_sequences(
-    pj, selected_observations, parameters, behaviors_separator, separated_subjects, timed, file_name
-):
-
+def observation_to_behavioral_sequences(pj, selected_observations, parameters, behaviors_separator, separated_subjects, timed, file_name):
     try:
         with open(file_name, "w", encoding="utf-8") as out_file:
             for obs_id in selected_observations:
@@ -1679,9 +1170,7 @@ def observation_to_behavioral_sequences(
                     out_file.write("# Independent variables\n")
 
                     for variable in pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES]:
-                        out_file.write(
-                            f"# {variable}: {pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES][variable]}\n"
-                        )
+                        out_file.write(f"# {variable}: {pj[cfg.OBSERVATIONS][obs_id][cfg.INDEPENDENT_VARIABLES][variable]}\n")
                 out_file.write("\n")
 
                 # one sequence for all subjects
@@ -1702,9 +1191,7 @@ def observation_to_behavioral_sequences(
                             out = events_to_behavioral_sequences(pj, obs_id, subject, parameters, behaviors_separator)
 
                         if timed:
-                            out = events_to_timed_behavioral_sequences(
-                                pj, obs_id, subject, parameters, 0.001, behaviors_separator
-                            )
+                            out = events_to_timed_behavioral_sequences(pj, obs_id, subject, parameters, 0.001, behaviors_separator)
 
                         if out:
                             out_file.write(out + "\n")