boris-behav-obs 8.27.10__py2.py3-none-any.whl → 9.0.1__py2.py3-none-any.whl

boris/project.py

@@ -24,11 +24,13 @@ import json
 import logging
 import re
 
-from PyQt5.QtCore import Qt, QDateTime
-from PyQt5.QtGui import QColor
-from PyQt5.QtWidgets import (
+from PySide6.QtCore import Qt, QDateTime
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import (
+    QAbstractItemView,
     QApplication,
     QCheckBox,
+    QColorDialog,
     QDialog,
     QFileDialog,
     QHBoxLayout,
@@ -41,11 +43,9 @@ from PyQt5.QtWidgets import (
     QPushButton,
     QSizePolicy,
     QSpacerItem,
+    QTableWidget,
     QTableWidgetItem,
     QVBoxLayout,
-    QColorDialog,
-    QTableWidget,
-    QAbstractItemView,
 )
 
 from . import add_modifier
@@ -60,11 +60,10 @@ class BehavioralCategories(QDialog):
     Class for managing the behavioral categories
     """
 
-    def __init__(self, pj, dark_mode):
+    def __init__(self, pj):
         super().__init__()
 
         self.pj = pj
-        self.dark_mode = dark_mode
         self.setWindowTitle("Behavioral categories")
 
         self.renamed = None
@@ -153,10 +152,12 @@ class BehavioralCategories(QDialog):
         """
         return a color for the not editable column
         """
-        if self.dark_mode:
-            return QColor(55, 65, 79)
-        else:
-            return QColor(230, 230, 230)
+        window_color = QApplication.instance().palette().window().color()
+        return QColor(
+            window_color.red() - cfg.DARKER_DIFFERENCE,
+            window_color.green() - cfg.DARKER_DIFFERENCE,
+            window_color.blue() - cfg.DARKER_DIFFERENCE,
+        )
 
     def lw_double_clicked(self, row: int, column: int):
         """
@@ -302,10 +303,10 @@ class projectDialog(QDialog, Ui_dlgProject):
             "remove all|Remove all behaviors",
             "lower|Convert keys to lower case",
         ]
-        menu = QMenu()
-        menu.triggered.connect(lambda x: self.behavior(action=x.statusTip()))
-        self.add_button_menu(behavior_button_items, menu)
-        self.pb_behavior.setMenu(menu)
+        self.behavior_menu = QMenu()
+        self.behavior_menu.triggered.connect(lambda x: self.behavior(action=x.statusTip()))
+        self.add_button_menu(behavior_button_items, self.behavior_menu)
+        self.pb_behavior.setMenu(self.behavior_menu)
 
         import_button_items = [
             "boris|from a BORIS project",
@@ -315,10 +316,10 @@ class projectDialog(QDialog, Ui_dlgProject):
             "clipboard|from the clipboard",
             "repository|from the BORIS repository",
         ]
-        menu = QMenu()
-        menu.triggered.connect(lambda x: self.import_ethogram(action=x.statusTip()))
-        self.add_button_menu(import_button_items, menu)
-        self.pb_import.setMenu(menu)
+        self.import_behaviors_menu = QMenu()
+        self.import_behaviors_menu.triggered.connect(lambda x: self.import_ethogram(action=x.statusTip()))
+        self.add_button_menu(import_button_items, self.import_behaviors_menu)
+        self.pb_import.setMenu(self.import_behaviors_menu)
 
         self.pbBehaviorsCategories.clicked.connect(self.pbBehaviorsCategories_clicked)
 
@@ -342,10 +343,10 @@ class projectDialog(QDialog, Ui_dlgProject):
             "lower|Convert keys to lower case",
         ]
 
-        menu = QMenu()
-        menu.triggered.connect(lambda x: self.subjects(action=x.statusTip()))
-        self.add_button_menu(subjects_button_items, menu)
-        self.pb_subjects.setMenu(menu)
+        self.subject_menu = QMenu()
+        self.subject_menu.triggered.connect(lambda x: self.subjects(action=x.statusTip()))
+        self.add_button_menu(subjects_button_items, self.subject_menu)
+        self.pb_subjects.setMenu(self.subject_menu)
 
         subjects_import_button_items = [
             "boris|from a BORIS project",
@@ -353,10 +354,10 @@ class projectDialog(QDialog, Ui_dlgProject):
             "text|from a text file (CSV or TSV)",
             "clipboard|from the clipboard",
         ]
-        menu = QMenu()
-        menu.triggered.connect(lambda x: self.import_subjects(action=x.statusTip()))
-        self.add_button_menu(subjects_import_button_items, menu)
-        self.pbImportSubjectsFromProject.setMenu(menu)
+        self.import_subjects_menu = QMenu()
+        self.import_subjects_menu.triggered.connect(lambda x: self.import_subjects(action=x.statusTip()))
+        self.add_button_menu(subjects_import_button_items, self.import_subjects_menu)
+        self.pbImportSubjectsFromProject.setMenu(self.import_subjects_menu)
 
         self.pb_export_subjects.clicked.connect(lambda: project_import_export.export_subjects(self))
 
@@ -430,10 +431,12 @@ class projectDialog(QDialog, Ui_dlgProject):
         """
         return a color for the not editable column
         """
-        if self.config_param.get(cfg.DARK_MODE, cfg.DEFAULT_FRAME_MODE):
-            return QColor(55, 65, 79)
-        else:
-            return QColor(230, 230, 230)
+        window_color = QApplication.instance().palette().window().color()
+        return QColor(
+            window_color.red() - cfg.DARKER_DIFFERENCE,
+            window_color.green() - cfg.DARKER_DIFFERENCE,
+            window_color.blue() - cfg.DARKER_DIFFERENCE,
+        )
 
     def add_button_menu(self, data, menu_obj):
         """
@@ -633,45 +636,45 @@ class projectDialog(QDialog, Ui_dlgProject):
         Add a behaviors coding map from file
         """
 
-        fn = QFileDialog().getOpenFileName(
+        file_name, _ = QFileDialog().getOpenFileName(
             self, "Open a behaviors coding map", "", "Behaviors coding map (*.behav_coding_map);;All files (*)"
         )
-        file_name = fn[0] if type(fn) is tuple else fn
-        if file_name:
-            try:
-                bcm = json.loads(open(file_name, "r").read())
-            except Exception:
-                QMessageBox.critical(self, cfg.programName, f"The file {file_name} is not a behaviors coding map.")
-                return
+        if not file_name:
+            return
+        try:
+            bcm = json.loads(open(file_name, "r").read())
+        except Exception:
+            QMessageBox.critical(self, cfg.programName, f"The file {file_name} is not a behaviors coding map.")
+            return
 
-            if "coding_map_type" not in bcm or bcm["coding_map_type"] != "BORIS behaviors coding map":
-                QMessageBox.critical(self, cfg.programName, f"The file {file_name} is not a BORIS behaviors coding map.")
+        if "coding_map_type" not in bcm or bcm["coding_map_type"] != "BORIS behaviors coding map":
+            QMessageBox.critical(self, cfg.programName, f"The file {file_name} is not a BORIS behaviors coding map.")
 
-            if cfg.BEHAVIORS_CODING_MAP not in self.pj:
-                self.pj[cfg.BEHAVIORS_CODING_MAP] = []
+        if cfg.BEHAVIORS_CODING_MAP not in self.pj:
+            self.pj[cfg.BEHAVIORS_CODING_MAP] = []
 
-            bcm_code_not_found = []
-            existing_codes = [self.pj[cfg.ETHOGRAM][key][cfg.BEHAVIOR_CODE] for key in self.pj[cfg.ETHOGRAM]]
-            for code in [bcm["areas"][key][cfg.BEHAVIOR_CODE] for key in bcm["areas"]]:
-                if code not in existing_codes:
-                    bcm_code_not_found.append(code)
+        bcm_code_not_found = []
+        existing_codes = [self.pj[cfg.ETHOGRAM][key][cfg.BEHAVIOR_CODE] for key in self.pj[cfg.ETHOGRAM]]
+        for code in [bcm["areas"][key][cfg.BEHAVIOR_CODE] for key in bcm["areas"]]:
+            if code not in existing_codes:
+                bcm_code_not_found.append(code)
 
-            if bcm_code_not_found:
-                QMessageBox.warning(
-                    self,
-                    cfg.programName,
-                    ("The following behavior{} are not defined in the ethogram:<br>" "{}").format(
-                        "s" if len(bcm_code_not_found) > 1 else "", ",".join(bcm_code_not_found)
-                    ),
-                )
+        if bcm_code_not_found:
+            QMessageBox.warning(
+                self,
+                cfg.programName,
+                ("The following behavior{} are not defined in the ethogram:<br>" "{}").format(
+                    "s" if len(bcm_code_not_found) > 1 else "", ",".join(bcm_code_not_found)
+                ),
+            )
 
-            self.pj[cfg.BEHAVIORS_CODING_MAP].append(dict(bcm))
+        self.pj[cfg.BEHAVIORS_CODING_MAP].append(dict(bcm))
 
-            self.twBehavCodingMap.setRowCount(self.twBehavCodingMap.rowCount() + 1)
+        self.twBehavCodingMap.setRowCount(self.twBehavCodingMap.rowCount() + 1)
 
-            self.twBehavCodingMap.setItem(self.twBehavCodingMap.rowCount() - 1, 0, QTableWidgetItem(bcm["name"]))
-            codes = ", ".join([bcm["areas"][idx][cfg.BEHAVIOR_CODE] for idx in bcm["areas"]])
-            self.twBehavCodingMap.setItem(self.twBehavCodingMap.rowCount() - 1, 1, QTableWidgetItem(codes))
+        self.twBehavCodingMap.setItem(self.twBehavCodingMap.rowCount() - 1, 0, QTableWidgetItem(bcm["name"]))
+        codes = ", ".join([bcm["areas"][idx][cfg.BEHAVIOR_CODE] for idx in bcm["areas"]])
+        self.twBehavCodingMap.setItem(self.twBehavCodingMap.rowCount() - 1, 1, QTableWidgetItem(codes))
 
     def remove_behaviors_coding_map(self):
         """
@@ -730,7 +733,7 @@ class projectDialog(QDialog, Ui_dlgProject):
         behavioral categories manager
         """
 
-        bc = BehavioralCategories(self.pj, self.config_param.get(cfg.DARK_MODE, cfg.DEFAULT_FRAME_MODE))
+        bc = BehavioralCategories(self.pj)  # self.config_param.get(cfg.DARK_MODE, cfg.DEFAULT_FRAME_MODE)
 
         if bc.exec_():
             self.pj[cfg.BEHAVIORAL_CATEGORIES] = []
@@ -868,7 +871,6 @@ class projectDialog(QDialog, Ui_dlgProject):
             color = col_diag.currentColor()
             if color.name() == "#000000":  # black -> delete color
                 self.twBehaviors.item(row, cfg.behavioursFields[cfg.COLOR]).setText("")
-                # self.twBehaviors.item(row, cfg.behavioursFields[cfg.COLOR]).setBackground(QColor(230, 230, 230))
                 self.twBehaviors.item(row, cfg.behavioursFields[cfg.COLOR]).setBackground(self.not_editable_column_color())
             elif color.isValid():
                 self.twBehaviors.item(row, cfg.behavioursFields[cfg.COLOR]).setText(color.name())
@@ -1200,7 +1202,6 @@ class projectDialog(QDialog, Ui_dlgProject):
                         if e == self.twBehaviors.item(r, cfg.behavioursFields[cfg.BEHAVIOR_CODE]).text():
                             item = QTableWidgetItem(",".join(new_excl[e]))
                             item.setFlags(Qt.ItemIsEnabled)
-                            # item.setBackground(QColor(230, 230, 230))
                             item.setBackground(self.not_editable_column_color())
                             self.twBehaviors.setItem(r, cfg.behavioursFields["excluded"], item)
 
@@ -1304,14 +1305,12 @@ class projectDialog(QDialog, Ui_dlgProject):
                 self.twBehaviors.setItem(self.twBehaviors.rowCount() - 1, cfg.behavioursFields[field], item)
                 if field in (cfg.TYPE, "category", "excluded", "coding map", "modifiers"):
                     item.setFlags(Qt.ItemIsEnabled)
-                    # item.setBackground(QColor(230, 230, 230))
                     item.setBackground(self.not_editable_column_color())
                 if field == cfg.COLOR:
                     item.setFlags(Qt.ItemIsEnabled)
                     if QColor(self.twBehaviors.item(row, cfg.behavioursFields[field]).text()).isValid():
                         item.setBackground(QColor(self.twBehaviors.item(row, cfg.behavioursFields[field]).text()))
                     else:
-                        # item.setBackground(QColor(230, 230, 230))
                         item.setBackground(self.not_editable_column_color())
 
         self.twBehaviors.scrollToBottom()
@@ -1376,17 +1375,15 @@ class projectDialog(QDialog, Ui_dlgProject):
 
         if cfg.CODING_MAP_sp in self.twBehaviors.item(row, cfg.behavioursFields[cfg.TYPE]).text():
             # let user select a coding maop
-            fn = QFileDialog().getOpenFileName(
+            file_name, _ = QFileDialog().getOpenFileName(
                 self,
                 "Select a modifier coding map for " f"{self.twBehaviors.item(row, cfg.behavioursFields['code']).text()} behavior",
                 "",
                 "BORIS map files (*.boris_map);;All files (*)",
             )
-            fileName = fn[0] if type(fn) is tuple else fn
-
-            if fileName:
+            if file_name:
                 try:
-                    new_map = json.loads(open(fileName, "r").read())
+                    new_map = json.loads(open(file_name, "r").read())
                 except Exception:
                     QMessageBox.critical(self, cfg.programName, "Error reding the coding map")
                     return

boris/project_functions.py

@@ -23,6 +23,8 @@ import gzip
 import json
 import logging
 import os
+import pandas as pd
+import numpy as np
 import pathlib as pl
 import sys
 from decimal import Decimal as dec
@@ -30,8 +32,8 @@ from shutil import copyfile
 from typing import List, Tuple, Dict
 
 import tablib
-from PyQt5.QtWidgets import QMessageBox, QTableWidgetItem, QAbstractItemView
-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
@@ -294,7 +296,7 @@ def check_state_events_obs(obsId: str, ethogram: dict, observation: dict, time_f
         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}
@@ -304,6 +306,7 @@ def check_state_events_obs(obsId: str, ethogram: dict, observation: dict, time_f
 
     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 = [
@@ -315,33 +318,35 @@ def check_state_events_obs(obsId: str, ethogram: dict, observation: dict, time_f
                 # 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")
 
@@ -410,6 +415,10 @@ def check_project_integrity(
 
     Returns:
         str: message
+
+
+    TODO: implement check on order of events (for live and media)
+
     """
     out: str = ""
 
@@ -1276,8 +1285,8 @@ def open_project_json(projectFileName: str) -> tuple:
 
     logging.debug(f"open project: {projectFileName}")
 
-    projectChanged = False
-    msg = ""
+    projectChanged: bool = False
+    msg: str = ""
 
     if not os.path.isfile(projectFileName):
         return (
@@ -1515,6 +1524,11 @@ def open_project_json(projectFileName: str) -> tuple:
 
         pj[cfg.PROJECT_VERSION] = cfg.project_format_version
 
+    # 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):
+            pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS].sort()
+
     return projectFileName, projectChanged, pj, msg
 
 
@@ -1747,3 +1761,191 @@ def explore_project(self) -> None:
 
     else:
         QMessageBox.information(self, cfg.programName, "No events found")
+
+
+def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
+    # print(pj.keys())
+
+    # print(pj["independent_variables"])
+
+    # indep_var = [pj["independent_variables"][idx]["label"] for idx in pj["independent_variables"]]
+
+    indep_variables = dict(
+        [(pj["independent_variables"][idx]["label"], pj["independent_variables"][idx]["type"]) for idx in pj["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["behaviors_conf"][x]["code"], pj["behaviors_conf"][x]["category"]) for x in pj["behaviors_conf"]])
+
+    # print(f"{pj["behaviors_conf"]=}")
+
+    all_modifier_sets: list = []
+    for behavior_id in pj["behaviors_conf"]:
+        modifier_names = []
+        set_count = 0
+        if pj["behaviors_conf"][behavior_id]["modifiers"] == "":
+            continue
+        for modifier in pj["behaviors_conf"][behavior_id]["modifiers"].values():
+            if modifier["name"]:
+                modifier_names.append((pj["behaviors_conf"][behavior_id]["code"], modifier["name"]))
+            else:
+                set_count += 1
+                modifier_names.append((pj["behaviors_conf"][behavior_id]["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": [],
+        # "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",
+        # "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] == "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 = [pj["behaviors_conf"][x]["code"] for x in pj["behaviors_conf"] if pj["behaviors_conf"][x]["type"] == "State event"]
+
+    for obs_id in pj["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["observations"][obs_id]["events"]):
+            if idx_event in stop_event_idx:
+                continue
+            data["Observation id"].append(obs_id)
+            # data["Observation date"].append(pj["observations"][obs_id]["date"])
+            # data["Description"].append(pj["observations"][obs_id]["description"])
+            # data["Observation type"].append(pj["observations"][obs_id]["type"])
+            # 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["observations"][obs_id]["independent_variables"][indep_var])
+
+            data["Subject"].append(event[1])
+            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]:
+                    data[modifier_set].append(event[3].split("|")[count_set])
+                    count_set += 1
+                else:
+                    data[modifier_set].append(np.nan)
+
+            data["Behavior type"].append("State event" if event[2] in state_behaviors else "Point event")
+            data["Start (s)"].append(event[0])
+            if event[2] in state_behaviors:
+                # search stop
+                # print(f"==> {idx_event=} {event[1:4]=}")
+                for idx_event2, event2 in enumerate(pj["observations"][obs_id]["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(event2[0])
+                        data["Duration (s)"].append(event2[0] - event[0])
+                        data["Comment start"].append(event[4])
+                        data["Comment stop"].append(event2[4])
+                        break
+                else:
+                    # print("not paired")
+                    raise ("not paired")
+
+            else:  # point
+                data["Stop (s)"].append(event[0])
+                data["Duration (s)"].append(np.nan)
+                data["Comment start"].append(event[4])
+                data["Comment stop"].append(event[4])
+
+    return pd.DataFrame(data)