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

boris/project.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 This file is part of BORIS.
 
@@ -24,10 +24,13 @@ import json
 import logging
 import re
 
-from PyQt5.QtCore import Qt
-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,
@@ -35,13 +38,12 @@ from PyQt5.QtWidgets import (
     QInputDialog,
     QLabel,
     QLineEdit,
-    QListWidget,
-    QListWidgetItem,
     QMenu,
     QMessageBox,
     QPushButton,
     QSizePolicy,
     QSpacerItem,
+    QTableWidget,
     QTableWidgetItem,
     QVBoxLayout,
 )
@@ -73,11 +75,49 @@ class BehavioralCategories(QDialog):
         self.label.setText("Behavioral categories")
         self.vbox.addWidget(self.label)
 
-        self.lw = QListWidget()
+        # self.lw = QListWidget()
+        self.lw = QTableWidget()
+        self.lw.cellDoubleClicked[int, int].connect(self.lw_double_clicked)
 
         # add categories
-        for category in sorted(pj.get(cfg.BEHAVIORAL_CATEGORIES, [])):
-            self.lw.addItem(QListWidgetItem(category))
+        self.lw.setColumnCount(2)
+        self.lw.setHorizontalHeaderLabels(["Category name", "Color"])
+        self.lw.setEditTriggers(QAbstractItemView.NoEditTriggers)
+
+        self.lw.setSelectionMode(QAbstractItemView.SingleSelection)
+
+        behavioral_categories: list = []
+
+        if cfg.BEHAVIORAL_CATEGORIES_CONF in pj:
+            self.lw.setRowCount(len(pj.get(cfg.BEHAVIORAL_CATEGORIES_CONF, {})))
+            behav_cat = pj.get(cfg.BEHAVIORAL_CATEGORIES_CONF, {})
+            for idx, key in enumerate(behav_cat.keys()):
+                # name
+                item = QTableWidgetItem()
+                item.setText(behav_cat[key]["name"])
+                behavioral_categories.append(behav_cat[key]["name"])
+                self.lw.setItem(idx, 0, item)
+                # color
+                item = QTableWidgetItem()
+                item.setText(behav_cat[key].get(cfg.COLOR, ""))
+                if behav_cat[key].get(cfg.COLOR, ""):
+                    item.setBackground(QColor(behav_cat[key].get(cfg.COLOR, "")))
+                else:
+                    item.setBackground(self.not_editable_column_color())
+                self.lw.setItem(idx, 1, item)
+        else:
+            self.lw.setRowCount(len(pj.get(cfg.BEHAVIORAL_CATEGORIES, [])))
+            for idx, category in enumerate(sorted(pj.get(cfg.BEHAVIORAL_CATEGORIES, []))):
+                # name
+                item = QTableWidgetItem()
+                item.setText(category)
+                behavioral_categories.append(category)
+                self.lw.setItem(idx, 0, item)
+                # color
+                item = QTableWidgetItem()
+                item.setText("")
+
+                self.lw.setItem(idx, 1, item)
 
         self.vbox.addWidget(self.lw)
 
@@ -94,8 +134,8 @@ class BehavioralCategories(QDialog):
         self.vbox.addLayout(self.hbox0)
 
         hbox1 = QHBoxLayout()
-        self.pbOK = QPushButton("OK", clicked=self.accept)
-        self.pbCancel = QPushButton("Cancel", clicked=self.accept)
+        self.pbOK = QPushButton(cfg.OK, clicked=self.accept)
+        self.pbCancel = QPushButton(cfg.CANCEL, clicked=self.accept)
 
         spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
         hbox1.addItem(spacerItem)
@@ -105,23 +145,111 @@ class BehavioralCategories(QDialog):
 
         self.setLayout(self.vbox)
 
+        # check if behavioral categories are present in events
+        behavioral_categories_in_ethogram = set(
+            sorted([pj[cfg.ETHOGRAM][idx].get(cfg.BEHAVIOR_CATEGORY, "") for idx in pj.get(cfg.ETHOGRAM, {})])
+        )
+
+        if behavioral_categories_in_ethogram.difference(set(behavioral_categories)) and behavioral_categories_in_ethogram.difference(
+            set(behavioral_categories)
+        ) != {""}:
+            if (
+                dialog.MessageDialog(
+                    cfg.programName,
+                    (
+                        "There are behavioral categories that are present in ethogram but not defined.<br>"
+                        f"{behavioral_categories_in_ethogram.difference(set(behavioral_categories))}<br>"
+                        "<br>"
+                        "Do you want to add them in the behavioral categories list?"
+                    ),
+                    [cfg.YES, cfg.NO],
+                )
+                == cfg.YES
+            ):
+                # add behavioral categories present in ethogram in behavioal categories list
+                rc = self.lw.rowCount()
+                self.lw.setRowCount(rc + len(behavioral_categories_in_ethogram.difference(set(behavioral_categories))))
+                for idx, category in enumerate(sorted(list(behavioral_categories_in_ethogram.difference(set(behavioral_categories))))):
+                    print(category)
+                    # name
+                    item = QTableWidgetItem()
+                    item.setText(category)
+                    # behavioral_categories.append(category)
+                    self.lw.setItem(rc + idx, 0, item)
+                    # color
+                    item = QTableWidgetItem()
+                    item.setText("")
+
+                    self.lw.setItem(rc + idx, 1, item)
+
+    def not_editable_column_color(self):
+        """
+        return a color for the not editable column
+        """
+        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):
+        """
+        change color
+        """
+
+        if column != 1:
+            return
+        col_diag = QColorDialog()
+        col_diag.setOptions(QColorDialog.DontUseNativeDialog)
+
+        if self.lw.item(row, 1).text():
+            current_color = QColor(self.lw.item(row, 1).text())
+            if current_color.isValid():
+                col_diag.setCurrentColor(current_color)
+
+        if col_diag.exec_():
+            color = col_diag.currentColor()
+            if color.name() == "#000000":  # black -> delete color
+                self.lw.item(row, 1).setText("")
+                self.lw.item(row, 1).setBackground(self.not_editable_column_color())
+            elif color.isValid():
+                self.lw.item(row, 1).setText(color.name())
+                self.lw.item(row, 1).setBackground(color)
+
     def add_behavioral_category(self):
         """
         add a behavioral category
         """
         category, ok = QInputDialog.getText(self, "New behavioral category", "Category name:")
         if ok:
-            self.lw.addItem(QListWidgetItem(category))
+            self.lw.insertRow(self.lw.rowCount())
+            item = QTableWidgetItem(category)
+            self.lw.setItem(self.lw.rowCount() - 1, 0, item)
+
+            item = QTableWidgetItem("")
+            # item.setFlags(Qt.ItemIsEnabled)
+            self.lw.setItem(self.lw.rowCount() - 1, 1, item)
 
     def remove_behavioral_category(self):
         """
         remove the selected behavioral category
         """
 
-        for SelectedItem in self.lw.selectedItems():
+        for selected_item in self.lw.selectedItems():
             # check if behavioral category is in use
-            category_to_remove = self.lw.item(self.lw.row(SelectedItem)).text().strip()
-            behaviors_in_category = []
+            if (
+                dialog.MessageDialog(
+                    cfg.programName,
+                    ("Confirm deletion of the behavioral category"),
+                    ("Confirm", cfg.CANCEL),
+                )
+                == cfg.CANCEL
+            ):
+                continue
+
+            category_to_remove = self.lw.item(self.lw.row(selected_item), 0).text().strip()
+            behaviors_in_category: list = []
             for idx in self.pj[cfg.ETHOGRAM]:
                 if (
                     cfg.BEHAVIOR_CATEGORY in self.pj[cfg.ETHOGRAM][idx]
@@ -130,16 +258,15 @@ class BehavioralCategories(QDialog):
                     behaviors_in_category.append(self.pj[cfg.ETHOGRAM][idx][cfg.BEHAVIOR_CODE])
             flag_remove = False
             if behaviors_in_category:
-
                 flag_remove = (
                     dialog.MessageDialog(
                         cfg.programName,
                         (
-                            "Some behavior belong to the <b>{1}</b> to remove:<br>"
-                            "{0}<br>"
+                            f"Some behavior belong to the <b>{category_to_remove}</b> to remove:<br>"
+                            f"{'<br>'.join(behaviors_in_category)}<br>"
                             "<br>Some features may not be available anymore.<br>"
-                        ).format("<br>".join(behaviors_in_category), category_to_remove),
-                        ["Remove category", cfg.CANCEL],
+                        ),
+                        ("Remove category", cfg.CANCEL),
                     )
                     == "Remove category"
                 )
@@ -148,17 +275,18 @@ class BehavioralCategories(QDialog):
                 flag_remove = True
 
             if flag_remove:
-                self.lw.takeItem(self.lw.row(SelectedItem))
+                self.lw.removeRow(self.lw.row(selected_item))
                 self.removed = category_to_remove
+
                 self.accept()
 
-    def pb_rename_category_clicked(self):
+    def pb_rename_category_clicked(self, row: int):
         """
         rename the selected behavioral category
         """
-        for SelectedItem in self.lw.selectedItems():
+        for selected_item in self.lw.selectedItems():
             # check if behavioral category is in use
-            category_to_rename = self.lw.item(self.lw.row(SelectedItem)).text().strip()
+            category_to_rename = self.lw.item(self.lw.row(selected_item), 0).text().strip()
             behaviors_in_category = []
             for idx in self.pj[cfg.ETHOGRAM]:
                 if (
@@ -172,9 +300,7 @@ class BehavioralCategories(QDialog):
                 flag_rename = (
                     dialog.MessageDialog(
                         cfg.programName,
-                        ("Some behavior belong to the <b>{1}</b> to rename:<br>" "{0}<br>").format(
-                            "<br>".join(behaviors_in_category), category_to_rename
-                        ),
+                        (f"Some behavior belong to the <b>{category_to_rename}</b> to rename:<br>{'<br>'.join(behaviors_in_category)}<br>"),
                         ["Rename category", cfg.CANCEL],
                     )
                     == "Rename category"
@@ -187,15 +313,14 @@ class BehavioralCategories(QDialog):
                     self, "Rename behavioral category", "New category name:", QLineEdit.Normal, category_to_rename
                 )
                 if ok:
-                    self.lw.item(self.lw.indexFromItem(SelectedItem).row()).setText(new_category_name)
+                    self.lw.item(self.lw.indexFromItem(selected_item).row(), 0).setText(new_category_name)
                     # check behaviors belonging to the renamed category
                     self.renamed = [category_to_rename, new_category_name]
-                    self.accept()
+                    # self.accept()
 
 
 class projectDialog(QDialog, Ui_dlgProject):
     def __init__(self, parent=None):
-
         super().__init__()
 
         self.setupUi(self)
@@ -211,23 +336,23 @@ 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",
-            "spreadsheet|from a spreadsheet file (XLSX)",
+            "spreadsheet|from a spreadsheet file (XLSX/ODS)",
             "jwatcher|from a JWatcher project",
             "text|from a text file (CSV or TSV)",
             "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)
 
@@ -251,21 +376,21 @@ 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",
-            "spreadsheet|from a spreadsheet file (XLSX)",
+            "spreadsheet|from a spreadsheet file (XLSX/ODS)",
             "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))
 
@@ -311,30 +436,41 @@ class projectDialog(QDialog, Ui_dlgProject):
         self.row_in_modification = -1
         self.flag_modified = False
 
-        for w in [
+        for w in (
             self.le_converter_name,
             self.le_converter_description,
             self.pteCode,
             self.pb_save_converter,
             self.pb_cancel_converter,
-        ]:
+        ):
             w.setEnabled(False)
 
         # disable widget for indep var setting
-        for widget in [
+        for widget in (
             self.leLabel,
             self.le_converter_description,
             self.cbType,
             self.lePredefined,
             self.dte_default_date,
             self.leSetValues,
-        ]:
+        ):
             widget.setEnabled(False)
 
         self.twBehaviors.horizontalHeader().sortIndicatorChanged.connect(self.sort_twBehaviors)
         self.twSubjects.horizontalHeader().sortIndicatorChanged.connect(self.sort_twSubjects)
         self.twVariables.horizontalHeader().sortIndicatorChanged.connect(self.sort_twVariables)
 
+    def not_editable_column_color(self):
+        """
+        return a color for the not editable column
+        """
+        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):
         """
         add menu option from dictionary
@@ -448,20 +584,14 @@ class projectDialog(QDialog, Ui_dlgProject):
 
         # check if some keys will be duplicated after conversion
         try:
-            all_keys = [
-                self.twBehaviors.item(row, cfg.behavioursFields["key"]).text()
-                for row in range(self.twBehaviors.rowCount())
-            ]
+            all_keys = [self.twBehaviors.item(row, cfg.behavioursFields["key"]).text() for row in range(self.twBehaviors.rowCount())]
         except Exception:
             pass
         if all_keys == [x.lower() for x in all_keys]:
             QMessageBox.information(self, cfg.programName, "All keys are already lower case")
             return
 
-        if (
-            dialog.MessageDialog(cfg.programName, "Confirm the conversion of key to lower case.", [cfg.YES, cfg.CANCEL])
-            == cfg.CANCEL
-        ):
+        if dialog.MessageDialog(cfg.programName, "Confirm the conversion of key to lower case.", [cfg.YES, cfg.CANCEL]) == cfg.CANCEL:
             return
 
         if len([x.lower() for x in all_keys]) != len(set([x.lower() for x in all_keys])):
@@ -482,11 +612,10 @@ class projectDialog(QDialog, Ui_dlgProject):
                 )
 
             # convert modifier shortcuts
-            if self.twBehaviors.item(row, cfg.behavioursFields["modifiers"]).text():
-
+            if self.twBehaviors.item(row, cfg.behavioursFields[cfg.MODIFIERS]).text():
                 modifiers_dict = (
-                    eval(self.twBehaviors.item(row, cfg.behavioursFields["modifiers"]).text())
-                    if self.twBehaviors.item(row, cfg.behavioursFields["modifiers"]).text()
+                    json.loads(self.twBehaviors.item(row, cfg.behavioursFields[cfg.MODIFIERS]).text())
+                    if self.twBehaviors.item(row, cfg.behavioursFields[cfg.MODIFIERS]).text()
                     else {}
                 )
 
@@ -495,16 +624,12 @@ class projectDialog(QDialog, Ui_dlgProject):
                         for idx2, value in enumerate(modifiers_dict[modifier_set]["values"]):
                             if re.findall(r"\((\w+)\)", value):
                                 modifiers_dict[modifier_set]["values"][idx2] = (
-                                    value.split("(")[0]
-                                    + "("
-                                    + re.findall(r"\((\w+)\)", value)[0].lower()
-                                    + ")"
-                                    + value.split(")")[-1]
+                                    value.split("(")[0] + "(" + re.findall(r"\((\w+)\)", value)[0].lower() + ")" + value.split(")")[-1]
                                 )
                     except Exception:
                         logging.warning("error during conversion of modifier short cut to lower case")
 
-                self.twBehaviors.item(row, cfg.behavioursFields["modifiers"]).setText(str(modifiers_dict))
+                self.twBehaviors.item(row, cfg.behavioursFields[cfg.MODIFIERS]).setText(json.dumps(modifiers_dict))
 
     def convert_subjects_keys_to_lower_case(self):
         """
@@ -512,20 +637,14 @@ class projectDialog(QDialog, Ui_dlgProject):
         """
         # check if some keys will be duplicated after conversion
         try:
-            all_keys = [
-                self.twSubjects.item(row, cfg.subjectsFields.index("key")).text()
-                for row in range(self.twSubjects.rowCount())
-            ]
+            all_keys = [self.twSubjects.item(row, cfg.subjectsFields.index("key")).text() for row in range(self.twSubjects.rowCount())]
         except Exception:
             pass
         if all_keys == [x.lower() for x in all_keys]:
             QMessageBox.information(self, cfg.programName, "All keys are already lower case")
             return
 
-        if (
-            dialog.MessageDialog(cfg.programName, "Confirm the conversion of key to lower case.", [cfg.YES, cfg.CANCEL])
-            == cfg.CANCEL
-        ):
+        if dialog.MessageDialog(cfg.programName, "Confirm the conversion of key to lower case.", [cfg.YES, cfg.CANCEL]) == cfg.CANCEL:
             return
 
         if len([x.lower() for x in all_keys]) != len(set([x.lower() for x in all_keys])):
@@ -550,47 +669,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]["code"] for key in self.pj[cfg.ETHOGRAM]]
-            for code in [bcm["areas"][key]["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]["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):
         """
@@ -599,27 +716,28 @@ class projectDialog(QDialog, Ui_dlgProject):
         if not self.twBehavCodingMap.selectedIndexes():
             QMessageBox.warning(self, cfg.programName, "Select a behaviors coding map")
         else:
-            if (
-                dialog.MessageDialog(
-                    cfg.programName, "Remove the selected behaviors coding map?", [cfg.YES, cfg.CANCEL]
-                )
-                == cfg.YES
-            ):
+            if dialog.MessageDialog(cfg.programName, "Remove the selected behaviors coding map?", [cfg.YES, cfg.CANCEL]) == cfg.YES:
                 del self.pj[cfg.BEHAVIORS_CODING_MAP][self.twBehavCodingMap.selectedIndexes()[0].row()]
                 self.twBehavCodingMap.removeRow(self.twBehavCodingMap.selectedIndexes()[0].row())
 
     def leLabel_changed(self):
-
+        """
+        independent variable label changed
+        """
         if self.selected_twvariables_row != -1:
             self.twVariables.item(self.selected_twvariables_row, 0).setText(self.leLabel.text())
 
     def leDescription_changed(self):
-
+        """
+        independent variable description changed
+        """
         if self.selected_twvariables_row != -1:
             self.twVariables.item(self.selected_twvariables_row, 1).setText(self.leDescription.text())
 
     def lePredefined_changed(self):
-
+        """
+        independent variable predefined value changed
+        """
         if self.selected_twvariables_row != -1:
             self.twVariables.item(self.selected_twvariables_row, 3).setText(self.lePredefined.text())
             if not self.lePredefined.hasFocus():
@@ -628,15 +746,19 @@ class projectDialog(QDialog, Ui_dlgProject):
                     QMessageBox.warning(self, f"{cfg.programName} - Independent variables error", msg)
 
     def leSetValues_changed(self):
-
+        """
+        independent variable available values changed
+        """
         if self.selected_twvariables_row != -1:
             self.twVariables.item(self.selected_twvariables_row, 4).setText(self.leSetValues.text())
 
     def dte_default_date_changed(self):
-
+        """
+        independent variable default timestamp changed
+        """
         if self.selected_twvariables_row != -1:
             self.twVariables.item(self.selected_twvariables_row, 3).setText(
-                self.dte_default_date.dateTime().toString(Qt.ISODate)
+                self.dte_default_date.dateTime().toString("yyyy-MM-ddTHH:mm:ss.zzz")
             )
 
     def pbBehaviorsCategories_clicked(self):
@@ -648,8 +770,13 @@ class projectDialog(QDialog, Ui_dlgProject):
 
         if bc.exec_():
             self.pj[cfg.BEHAVIORAL_CATEGORIES] = []
-            for index in range(bc.lw.count()):
-                self.pj[cfg.BEHAVIORAL_CATEGORIES].append(bc.lw.item(index).text().strip())
+            self.pj[cfg.BEHAVIORAL_CATEGORIES_CONF] = {}
+            for index in range(bc.lw.rowCount()):
+                self.pj[cfg.BEHAVIORAL_CATEGORIES].append(bc.lw.item(index, 0).text().strip())
+                self.pj[cfg.BEHAVIORAL_CATEGORIES_CONF][str(index)] = {
+                    "name": bc.lw.item(index, 0).text().strip(),
+                    cfg.COLOR: bc.lw.item(index, 1).text(),
+                }
 
             # sort
             self.pj[cfg.BEHAVIORAL_CATEGORIES] = sorted(self.pj[cfg.BEHAVIORAL_CATEGORIES])
@@ -657,14 +784,15 @@ class projectDialog(QDialog, Ui_dlgProject):
             # check if behavior belong to removed category
             if bc.removed:
                 for row in range(self.twBehaviors.rowCount()):
-                    if self.twBehaviors.item(row, cfg.behavioursFields["category"]):
-                        if self.twBehaviors.item(row, cfg.behavioursFields["category"]).text() == bc.removed:
+                    if self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]):
+                        if self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]).text() == bc.removed:
                             if (
                                 dialog.MessageDialog(
                                     cfg.programName,
                                     (
                                         f"The <b>{self.twBehaviors.item(row, cfg.behavioursFields['code']).text()}</b> behavior belongs "
-                                        f"to a behavioral category <b>{self.twBehaviors.item(row, cfg.behavioursFields['category']).text()}</b> "
+                                        "to a behavioral category "
+                                        f"<b>{self.twBehaviors.item(row, cfg.behavioursFields['category']).text()}</b> "
                                         "that is no more in the behavioral categories list.<br><br>"
                                         "Remove the behavior from category?"
                                     ),
@@ -672,16 +800,17 @@ class projectDialog(QDialog, Ui_dlgProject):
                                 )
                                 == cfg.YES
                             ):
-                                self.twBehaviors.item(row, cfg.behavioursFields["category"]).setText("")
+                                self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]).setText("")
             if bc.renamed:
                 for row in range(self.twBehaviors.rowCount()):
-                    if self.twBehaviors.item(row, cfg.behavioursFields["category"]):
-                        if self.twBehaviors.item(row, cfg.behavioursFields["category"]).text() == bc.renamed[0]:
-                            self.twBehaviors.item(row, cfg.behavioursFields["category"]).setText(bc.renamed[1])
+                    if self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]):
+                        if self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]).text() == bc.renamed[0]:
+                            self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]).setText(bc.renamed[1])
 
-    def twBehaviors_cellDoubleClicked(self, row, column):
+    def twBehaviors_cellDoubleClicked(self, row: int, column: int) -> None:
         """
         manage double-click on ethogram table:
+        * color
         * behavioral category
         * modifiers
         * exclusion
@@ -692,51 +821,53 @@ class projectDialog(QDialog, Ui_dlgProject):
             column (int): column double-clicked
         """
 
-        # check if double click on excluded column
-        if column == cfg.behavioursFields["excluded"]:
+        # excluded column
+        if column == cfg.behavioursFields[cfg.EXCLUDED]:
             self.exclusion_matrix()
 
-        # check if double click on 'coding map' column
-        if column == cfg.behavioursFields["coding map"]:
+        # coding map
+        if column == cfg.behavioursFields[cfg.CODING_MAP_sp]:
             if "with coding map" in self.twBehaviors.item(row, cfg.behavioursFields[cfg.TYPE]).text():
-                self.behaviorTypeChanged(row)
+                self.behavior_type_changed(row)
             else:
-                QMessageBox.information(
-                    self, cfg.programName, "Change the behavior type on first column to select a coding map"
-                )
+                QMessageBox.information(self, cfg.programName, "Change the behavior type on first column to select a coding map")
 
-        # check if double click on category
+        # behavior type
         if column == cfg.behavioursFields["type"]:
             self.behavior_type_doubleclicked(row)
 
+        # color
+        if column == cfg.behavioursFields[cfg.COLOR]:
+            self.color_doubleclicked(row)
+
         # behavioral category
-        if column == cfg.behavioursFields["category"]:
+        if column == cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]:
             self.category_doubleclicked(row)
 
-        if column == cfg.behavioursFields["modifiers"]:
+        # modifiers
+        if column == cfg.behavioursFields[cfg.MODIFIERS]:
             # check if behavior has coding map
             if (
-                self.twBehaviors.item(row, cfg.behavioursFields["coding map"]) is not None
-                and self.twBehaviors.item(row, cfg.behavioursFields["coding map"]).text()
+                self.twBehaviors.item(row, cfg.behavioursFields[cfg.CODING_MAP_sp]) is not None
+                and self.twBehaviors.item(row, cfg.behavioursFields[cfg.CODING_MAP_sp]).text()
             ):
                 QMessageBox.warning(self, cfg.programName, "Use the coding map to set/modify the areas")
             else:
                 subjects_list = []
                 for subject_row in range(self.twSubjects.rowCount()):
                     key = self.twSubjects.item(subject_row, 0).text() if self.twSubjects.item(subject_row, 0) else ""
-                    subjectName = (
-                        self.twSubjects.item(subject_row, 1).text().strip()
-                        if self.twSubjects.item(subject_row, 1)
-                        else ""
-                    )
+                    subjectName = self.twSubjects.item(subject_row, 1).text().strip() if self.twSubjects.item(subject_row, 1) else ""
                     subjects_list.append((subjectName, key))
 
                 addModifierWindow = add_modifier.addModifierDialog(
-                    self.twBehaviors.item(row, column).text(), subjects=subjects_list
+                    self.twBehaviors.item(row, column).text(),
+                    subjects=subjects_list,
+                    ask_at_stop_enabled=self.twBehaviors.item(row, cfg.behavioursFields["type"]).text() == cfg.STATE_EVENT,
                 )
                 addModifierWindow.setWindowTitle(f'Set modifiers for "{self.twBehaviors.item(row, 2).text()}" behavior')
+
                 if addModifierWindow.exec_():
-                    self.twBehaviors.item(row, column).setText(addModifierWindow.getModifiers())
+                    self.twBehaviors.item(row, column).setText(addModifierWindow.get_modifiers())
 
     def behavior_type_doubleclicked(self, row):
         """
@@ -748,14 +879,36 @@ class projectDialog(QDialog, Ui_dlgProject):
         else:
             selected = 0
 
-        new_type, ok = QInputDialog.getItem(
-            self, "Select a behavior type", "Types of behavior", cfg.BEHAVIOR_TYPES, selected, False
-        )
+        new_type, ok = QInputDialog.getItem(self, "Select a behavior type", "Types of behavior", cfg.BEHAVIOR_TYPES, selected, False)
 
         if ok and new_type:
             self.twBehaviors.item(row, cfg.behavioursFields["type"]).setText(new_type)
 
-            self.behaviorTypeChanged(row)
+            self.behavior_type_changed(row)
+
+    def color_doubleclicked(self, row: int) -> None:
+        """
+        select a color for behavior
+        Selecting black delete the color
+        """
+
+        col_diag = QColorDialog()
+        col_diag.setOptions(QColorDialog.ShowAlphaChannel | QColorDialog.DontUseNativeDialog)
+
+        if self.twBehaviors.item(row, cfg.behavioursFields[cfg.COLOR]).text():
+            current_color = QColor(self.twBehaviors.item(row, cfg.behavioursFields[cfg.COLOR]).text())
+            if current_color.isValid():
+                print(f"{current_color=}")
+                col_diag.setCurrentColor(current_color)
+
+        if col_diag.exec():
+            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(self.not_editable_column_color())
+            elif color.isValid():
+                self.twBehaviors.item(row, cfg.behavioursFields[cfg.COLOR]).setBackground(QColor(color.name()))
+                self.twBehaviors.item(row, cfg.behavioursFields[cfg.COLOR]).setText(color.name())
 
     def category_doubleclicked(self, row):
         """
@@ -764,19 +917,17 @@ class projectDialog(QDialog, Ui_dlgProject):
 
         categories = ["None"] + self.pj[cfg.BEHAVIORAL_CATEGORIES] if cfg.BEHAVIORAL_CATEGORIES in self.pj else ["None"]
 
-        if self.twBehaviors.item(row, cfg.behavioursFields["category"]).text() in categories:
-            selected = categories.index(self.twBehaviors.item(row, cfg.behavioursFields["category"]).text())
+        if self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]).text() in categories:
+            selected = categories.index(self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]).text())
         else:
             selected = 0
 
-        category, ok = QInputDialog.getItem(
-            self, "Select a behavioral category", "Behavioral categories", categories, selected, False
-        )
+        category, ok = QInputDialog.getItem(self, "Select a behavioral category", "Behavioral categories", categories, selected, False)
 
         if ok and category:
             if category == "None":
                 category = ""
-            self.twBehaviors.item(row, cfg.behavioursFields["category"]).setText(category)
+            self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CATEGORY]).setText(category)
 
     def check_variable_default_value(self, txt, varType):
         """
@@ -800,22 +951,15 @@ class projectDialog(QDialog, Ui_dlgProject):
 
         if self.twVariables.cellWidget(row, cfg.tw_indVarFields.index("type")).currentText() == cfg.SET_OF_VALUES:
             if self.twVariables.item(row, cfg.tw_indVarFields.index("possible values")).text() == "NA":
-                self.twVariables.item(row, cfg.tw_indVarFields.index("possible values")).setText(
-                    "Double-click to add values"
-                )
+                self.twVariables.item(row, cfg.tw_indVarFields.index("possible values")).setText("Double-click to add values")
         else:
             # check if set of values defined
             if self.twVariables.item(row, cfg.tw_indVarFields.index("possible values")).text() not in [
                 "NA",
                 "Double-click to add values",
             ]:
-                if (
-                    dialog.MessageDialog(cfg.programName, "Erase the set of values?", [cfg.YES, cfg.CANCEL])
-                    == cfg.CANCEL
-                ):
-                    self.twVariables.cellWidget(row, cfg.tw_indVarFields.index("type")).setCurrentIndex(
-                        cfg.SET_OF_VALUES_idx
-                    )
+                if dialog.MessageDialog(cfg.programName, "Erase the set of values?", [cfg.YES, cfg.CANCEL]) == cfg.CANCEL:
+                    self.twVariables.cellWidget(row, cfg.tw_indVarFields.index("type")).setCurrentIndex(cfg.SET_OF_VALUES_idx)
                     return
                 else:
                     self.twVariables.item(row, cfg.tw_indVarFields.index("possible values")).setText("NA")
@@ -844,7 +988,6 @@ class projectDialog(QDialog, Ui_dlgProject):
 
         existing_var = []
         for r in range(self.twVariables.rowCount()):
-
             if self.twVariables.item(r, 0).text().strip().upper() in existing_var:
                 return (
                     False,
@@ -882,7 +1025,6 @@ class projectDialog(QDialog, Ui_dlgProject):
         return True, "OK"
 
     def cbtype_changed(self):
-
         self.leSetValues.setVisible(self.cbType.currentText() == cfg.SET_OF_VALUES)
         self.label_5.setVisible(self.cbType.currentText() == cfg.SET_OF_VALUES)
 
@@ -892,10 +1034,9 @@ class projectDialog(QDialog, Ui_dlgProject):
         self.label_4.setVisible(self.cbType.currentText() != cfg.TIMESTAMP)
 
     def cbtype_activated(self):
-
         if self.cbType.currentText() == cfg.TIMESTAMP:
             self.twVariables.item(self.selected_twvariables_row, 3).setText(
-                self.dte_default_date.dateTime().toString(Qt.ISODate)
+                self.dte_default_date.dateTime().toString("yyyy-MM-ddTHH:mm:ss.zzz")
             )
             self.twVariables.item(self.selected_twvariables_row, 4).setText("")
         else:
@@ -975,7 +1116,7 @@ class projectDialog(QDialog, Ui_dlgProject):
             return
 
         for row in range(self.twBehaviors.rowCount()):
-            if not self.twBehaviors.item(row, cfg.behavioursFields["code"]).text():
+            if not self.twBehaviors.item(row, cfg.behavioursFields[cfg.BEHAVIOR_CODE]).text():
                 QMessageBox.critical(
                     None,
                     cfg.programName,
@@ -1005,12 +1146,9 @@ class projectDialog(QDialog, Ui_dlgProject):
             )
 
         for r in range(self.twBehaviors.rowCount()):
-
             if self.twBehaviors.item(r, cfg.behavioursFields[cfg.BEHAVIOR_CODE]):
-
                 if include_point_events == cfg.YES or (
-                    include_point_events == cfg.NO
-                    and "State" in self.twBehaviors.item(r, cfg.behavioursFields[cfg.TYPE]).text()
+                    include_point_events == cfg.NO and "State" in self.twBehaviors.item(r, cfg.behavioursFields[cfg.TYPE]).text()
                 ):
                     allBehaviors.append(self.twBehaviors.item(r, cfg.behavioursFields[cfg.BEHAVIOR_CODE]).text())
 
@@ -1065,9 +1203,7 @@ class projectDialog(QDialog, Ui_dlgProject):
 
                 if c_name != r_name:
                     ex.checkboxes[f"{r_name}|{c_name}"] = QCheckBox()
-                    ex.checkboxes[f"{r_name}|{c_name}"].setStyleSheet(
-                        "text-align: center; margin-left:50%; margin-right:50%;"
-                    )
+                    ex.checkboxes[f"{r_name}|{c_name}"].setStyleSheet("text-align: center; margin-left:50%; margin-right:50%;")
 
                     if flag_left_bottom:
                         # hide if cell in left-bottom part of table
@@ -1095,18 +1231,15 @@ class projectDialog(QDialog, Ui_dlgProject):
 
             # update excluded field
             for r in range(self.twBehaviors.rowCount()):
-                if include_point_events == cfg.YES or (
-                    include_point_events == cfg.NO and "State" in self.twBehaviors.item(r, 0).text()
-                ):
+                if include_point_events == cfg.YES or (include_point_events == cfg.NO and "State" in self.twBehaviors.item(r, 0).text()):
                     for e in excl:
                         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)
 
     def remove_all_behaviors(self):
-
         if not self.twBehaviors.rowCount():
             QMessageBox.critical(
                 None,
@@ -1162,7 +1295,6 @@ class projectDialog(QDialog, Ui_dlgProject):
         self.lbObservationsState.setText("")
 
         for r in range(self.twBehaviors.rowCount()):
-
             # check key
             if self.twBehaviors.item(r, cfg.PROJECT_BEHAVIORS_KEY_FIELD_IDX):
                 key = self.twBehaviors.item(r, cfg.PROJECT_BEHAVIORS_KEY_FIELD_IDX).text()
@@ -1205,9 +1337,16 @@ class projectDialog(QDialog, Ui_dlgProject):
             for field in cfg.behavioursFields:
                 item = QTableWidgetItem(self.twBehaviors.item(row, cfg.behavioursFields[field]))
                 self.twBehaviors.setItem(self.twBehaviors.rowCount() - 1, cfg.behavioursFields[field], item)
-                if field in [cfg.TYPE, "category", "excluded", "coding map", "modifiers"]:
+                if field in (cfg.TYPE, "category", "excluded", "coding map", "modifiers"):
+                    item.setFlags(Qt.ItemIsEnabled)
+                    item.setBackground(self.not_editable_column_color())
+                if field == cfg.COLOR:
                     item.setFlags(Qt.ItemIsEnabled)
-                    item.setBackground(QColor(230, 230, 230))
+                    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(self.not_editable_column_color())
+
         self.twBehaviors.scrollToBottom()
 
     def remove_behavior(self):
@@ -1227,27 +1366,22 @@ class projectDialog(QDialog, Ui_dlgProject):
 
         if not self.twBehaviors.selectedIndexes():
             QMessageBox.warning(self, cfg.programName, "Select a behaviour to be removed")
-        else:
-            if dialog.MessageDialog(cfg.programName, "Remove the selected behavior?", [cfg.YES, cfg.CANCEL]) == cfg.YES:
-
-                # check if behavior already used in observations
-                flag_break = False
-                codeToDelete = self.twBehaviors.item(self.twBehaviors.selectedIndexes()[0].row(), 2).text()
-                for obs_id in self.pj[cfg.OBSERVATIONS]:
-                    if codeToDelete in [
-                        event[cfg.EVENT_BEHAVIOR_FIELD_IDX] for event in self.pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]
-                    ]:
-                        if (
-                            dialog.MessageDialog(
-                                cfg.programName, "The code to remove is used in observations!", [cfg.REMOVE, cfg.CANCEL]
-                            )
-                            == cfg.CANCEL
-                        ):
-                            return
-                        break
+            return
 
-                self.twBehaviors.removeRow(self.twBehaviors.selectedIndexes()[0].row())
-                self.twBehaviors_cellChanged(0, 0)
+        if dialog.MessageDialog(cfg.programName, "Remove the selected behavior?", [cfg.YES, cfg.CANCEL]) == cfg.YES:
+            # check if behavior already used in observations
+            codeToDelete = self.twBehaviors.item(self.twBehaviors.selectedIndexes()[0].row(), 2).text()
+            for obs_id in self.pj[cfg.OBSERVATIONS]:
+                if codeToDelete in [event[cfg.EVENT_BEHAVIOR_FIELD_IDX] for event in self.pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]]:
+                    if (
+                        dialog.MessageDialog(cfg.programName, "The code to remove is used in observations!", [cfg.REMOVE, cfg.CANCEL])
+                        == cfg.CANCEL
+                    ):
+                        return
+                    break
+
+            self.twBehaviors.removeRow(self.twBehaviors.selectedIndexes()[0].row())
+            self.twBehaviors_cellChanged(0, 0)
 
     def add_behavior(self):
         """
@@ -1261,38 +1395,36 @@ class projectDialog(QDialog, Ui_dlgProject):
             if field_type == cfg.TYPE:
                 item.setText("Point event")
             # no manual editing, gray back ground
-            if field_type in [cfg.TYPE, "category", "modifiers", "excluded", "coding map"]:
+            if field_type in (cfg.TYPE, cfg.COLOR, "category", cfg.MODIFIERS, "modifiers", "excluded", "coding map"):
                 item.setFlags(Qt.ItemIsEnabled)
-                item.setBackground(QColor(230, 230, 230))
+                # item.setBackground(QColor(230, 230, 230))
+                item.setBackground(self.not_editable_column_color())
             self.twBehaviors.setItem(self.twBehaviors.rowCount() - 1, cfg.behavioursFields[field_type], item)
         self.twBehaviors.scrollToBottom()
 
-    def behaviorTypeChanged(self, row):
+    def behavior_type_changed(self, row: int) -> None:
         """
         event type combobox changed
         """
 
-        if "with coding map" in self.twBehaviors.item(row, cfg.behavioursFields[cfg.TYPE]).text():
+        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 coding map for "
-                f"{self.twBehaviors.item(row, cfg.behavioursFields['code']).text()} behavior",
+                f"Select a modifier coding map for {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 file")
+                    QMessageBox.critical(self, cfg.programName, "Error reding the coding map")
                     return
                 self.pj[cfg.CODING_MAP][new_map["name"]] = new_map
 
                 # add modifiers from coding map areas
-                modifstr = str(
+                modifstr = json.dumps(
                     {
                         "0": {
                             "name": new_map["name"],
@@ -1308,9 +1440,7 @@ class projectDialog(QDialog, Ui_dlgProject):
             else:
                 # if coding map already exists do not reset the behavior type if no filename selected
                 if not self.twBehaviors.item(row, cfg.behavioursFields["coding map"]).text():
-                    QMessageBox.critical(
-                        self, cfg.programName, 'No coding map was selected.\nEvent type will be reset to "Point event" '
-                    )
+                    QMessageBox.critical(self, cfg.programName, 'No coding map was selected.\nEvent type will be reset to "Point event" ')
                     self.twBehaviors.item(row, cfg.behavioursFields["type"]).setText("Point event")
         else:
             self.twBehaviors.item(row, cfg.behavioursFields["coding map"]).setText("")
@@ -1336,12 +1466,9 @@ class projectDialog(QDialog, Ui_dlgProject):
             QMessageBox.warning(self, cfg.programName, "Select a subject to remove")
         else:
             if dialog.MessageDialog(cfg.programName, "Remove the selected subject?", [cfg.YES, cfg.CANCEL]) == cfg.YES:
-
                 flagDel = False
                 if self.twSubjects.item(self.twSubjects.selectedIndexes()[0].row(), 1):
-                    subjectToDelete = self.twSubjects.item(
-                        self.twSubjects.selectedIndexes()[0].row(), 1
-                    ).text()  # 1: subject name
+                    subjectToDelete = self.twSubjects.item(self.twSubjects.selectedIndexes()[0].row(), 1).text()  # 1: subject name
 
                     subjectsInObs = []
                     for obs in self.pj[cfg.OBSERVATIONS]:
@@ -1421,19 +1548,18 @@ class projectDialog(QDialog, Ui_dlgProject):
 
         self.twSubjects_cellChanged(0, 0)
 
-    def twSubjects_cellChanged(self, row: int, column: int):
+    def twSubjects_cellChanged(self, row: int, column: int) -> None:
         """
         check if subject not unique
         """
 
-        subjects, keys = [], []
+        subjects: list = []
+        """keys: list = []"""
         self.lbSubjectsState.setText("")
 
         for r in range(self.twSubjects.rowCount()):
-
             # check key
             if self.twSubjects.item(r, 0):
-
                 # check key length
                 if (
                     self.twSubjects.item(r, 0).text().upper() not in list(cfg.function_keys.values())
@@ -1448,11 +1574,14 @@ class projectDialog(QDialog, Ui_dlgProject):
                     )
                     return
 
+                # control of duplicated key removed 2024-01-29
+                """
                 if self.twSubjects.item(r, 0).text() in keys:
                     self.lbSubjectsState.setText(f'<font color="red">Key duplicated at row # {r + 1}</font>')
                 else:
                     if self.twSubjects.item(r, 0).text():
                         keys.append(self.twSubjects.item(r, 0).text())
+                """
 
             # check subject
             if self.twSubjects.item(r, 1):
@@ -1471,14 +1600,14 @@ class projectDialog(QDialog, Ui_dlgProject):
         logging.debug(f"selected row: {self.selected_twvariables_row}")
 
         if self.selected_twvariables_row == -1:
-            for widget in [
+            for widget in (
                 self.leLabel,
                 self.leDescription,
                 self.cbType,
                 self.lePredefined,
                 self.dte_default_date,
                 self.leSetValues,
-            ]:
+            ):
                 widget.setEnabled(False)
                 self.leLabel.setText("")
                 self.leDescription.setText("")
@@ -1489,20 +1618,27 @@ class projectDialog(QDialog, Ui_dlgProject):
             return
 
         # enable widget for indep var setting
-        for widget in [
+        for widget in (
             self.leLabel,
             self.leDescription,
             self.cbType,
             self.lePredefined,
             self.dte_default_date,
             self.leSetValues,
-        ]:
+        ):
             widget.setEnabled(True)
 
         self.leLabel.setText(self.twVariables.item(row, 0).text())
         self.leDescription.setText(self.twVariables.item(row, 1).text())
         self.lePredefined.setText(self.twVariables.item(row, 3).text())
         self.leSetValues.setText(self.twVariables.item(row, 4).text())
+        if self.twVariables.item(row, 2).text() == cfg.TIMESTAMP:
+            if len(self.twVariables.item(row, 3).text()) == len("yyyy-MM-ddTHH:mm:ss.zzz"):
+                datetime_format = "yyyy-MM-ddThh:mm:ss.zzz"
+            if len(self.twVariables.item(row, 3).text()) == len("yyyy-MM-ddTHH:mm:ss"):
+                datetime_format = "yyyy-MM-ddThh:mm:ss"
+
+            self.dte_default_date.setDateTime(QDateTime.fromString(self.twVariables.item(row, 3).text(), datetime_format))
 
         self.cbType.clear()
         self.cbType.addItems(cfg.AVAILABLE_INDEP_VAR_TYPES)
@@ -1512,12 +1648,7 @@ class projectDialog(QDialog, Ui_dlgProject):
 
     def pbCancel_clicked(self):
         if self.flag_modified:
-            if (
-                dialog.MessageDialog(
-                    "BORIS", "The converters were modified. Are you sure to cancel?", [cfg.CANCEL, cfg.OK]
-                )
-                == cfg.OK
-            ):
+            if dialog.MessageDialog("BORIS", "The converters were modified. Are you sure to cancel?", [cfg.CANCEL, cfg.OK]) == cfg.OK:
                 self.reject()
         else:
             self.reject()
@@ -1525,12 +1656,12 @@ class projectDialog(QDialog, Ui_dlgProject):
     def check_ethogram(self) -> dict:
         """
         check ethogram for various parameter
-        returns ethogram dict or {cfg.CANCEL: True"} in case of error
+        returns ethogram dict or {cfg.CANCEL: True} in case of error
 
         """
         # store behaviors
-        missing_data = []
-        checked_ethogram = {}
+        missing_data: list = []
+        checked_ethogram: dict = {}
 
         # Ethogram
         # coding maps in ethogram
@@ -1538,16 +1669,19 @@ class projectDialog(QDialog, Ui_dlgProject):
         # check for leading/trailing space in behaviors and modifiers
         code_with_leading_trailing_spaces, modifiers_with_leading_trailing_spaces = [], []
         for r in range(self.twBehaviors.rowCount()):
-
             if (
-                self.twBehaviors.item(r, cfg.behavioursFields["code"]).text()
-                != self.twBehaviors.item(r, cfg.behavioursFields["code"]).text().strip()
+                self.twBehaviors.item(r, cfg.behavioursFields[cfg.BEHAVIOR_CODE]).text()
+                != self.twBehaviors.item(r, cfg.behavioursFields[cfg.BEHAVIOR_CODE]).text().strip()
             ):
-                code_with_leading_trailing_spaces.append(self.twBehaviors.item(r, cfg.behavioursFields["code"]).text())
+                code_with_leading_trailing_spaces.append(self.twBehaviors.item(r, cfg.behavioursFields[cfg.BEHAVIOR_CODE]).text())
 
             if self.twBehaviors.item(r, cfg.behavioursFields["modifiers"]).text():
                 try:
-                    modifiers_dict = eval(self.twBehaviors.item(r, cfg.behavioursFields["modifiers"]).text())
+                    modifiers_dict = (
+                        json.loads(self.twBehaviors.item(r, cfg.behavioursFields["modifiers"]).text())
+                        if self.twBehaviors.item(r, cfg.behavioursFields["modifiers"]).text()
+                        else {}
+                    )
                     for k in modifiers_dict:
                         for value in modifiers_dict[k]["values"]:
                             modif_code = value.split(" (")[0]
@@ -1563,7 +1697,9 @@ class projectDialog(QDialog, Ui_dlgProject):
                 (
                     "<b>Warning!</b> Some leading and/or trailing spaces are present"
                     " in the following behaviors code(s):<br>"
-                    f"<b>{'<br>'.join([util.replace_leading_trailing_chars(x, ' ', '&#9608;') for x in code_with_leading_trailing_spaces])}</b><br><br>"
+                    "<b>"
+                    f"{'<br>'.join([util.replace_leading_trailing_chars(x, ' ', '&#9608;') for x in code_with_leading_trailing_spaces])}"
+                    "</b><br><br>"
                     "Do you want to remove the leading and trailing spaces (visualized as black boxes) from behaviors?<br><br>"
                     """<font color="red"><b>Be careful with this option"""
                     """ if you have already done observations!</b></font>"""
@@ -1579,13 +1715,13 @@ class projectDialog(QDialog, Ui_dlgProject):
                 cfg.programName,
                 (
                     "<b>Warning!</b> Some leading and/or trailing spaces are present"
-                    " in the following modifier(s):<br>"
-                    f"<b>{'<br>'.join([util.replace_leading_trailing_chars(x, ' ', '&#9608;') for x in set(modifiers_with_leading_trailing_spaces)])}</b><br><br>"
-                    "Do you want to remove the leading and trailing spaces (visualized as black boxes) from modifiers?<br><br>"
+                    " in the following modifier(s):<br><b>"
+                    f"{'<br>'.join([util.replace_leading_trailing_chars(x, ' ', '&#9608;') for x in set(modifiers_with_leading_trailing_spaces)])}"
+                    "</b><br><br>Do you want to remove the leading and trailing spaces (visualized as black boxes) from modifiers?<br><br>"
                     """<font color="red"><b>Be careful with this option"""
                     """ if you have already done observations!</b></font>"""
                 ),
-                [cfg.YES, cfg.NO, cfg.CANCEL],
+                (cfg.YES, cfg.NO, cfg.CANCEL),
             )
         if remove_leading_trailing_spaces_in_modifiers == cfg.CANCEL:
             return {cfg.CANCEL: True}
@@ -1595,9 +1731,8 @@ class projectDialog(QDialog, Ui_dlgProject):
             row = {}
             for field in cfg.behavioursFields:
                 if self.twBehaviors.item(r, cfg.behavioursFields[field]):
-
                     # check for | char in code
-                    if field == "code" and "|" in self.twBehaviors.item(r, cfg.behavioursFields[field]).text():
+                    if field == cfg.BEHAVIOR_CODE and "|" in self.twBehaviors.item(r, cfg.behavioursFields[field]).text():
                         QMessageBox.warning(
                             self,
                             cfg.programName,
@@ -1614,10 +1749,9 @@ class projectDialog(QDialog, Ui_dlgProject):
                         row[field] = self.twBehaviors.item(r, cfg.behavioursFields[field]).text()
 
                     if field == "modifiers" and row["modifiers"]:
-
                         if remove_leading_trailing_spaces_in_modifiers == cfg.YES:
                             try:
-                                modifiers_dict = eval(row["modifiers"])
+                                modifiers_dict = json.loads(row["modifiers"]) if row["modifiers"] else {}
                                 for k in modifiers_dict:
                                     for idx, value in enumerate(modifiers_dict[k]["values"]):
                                         modif_code = value.split(" (")[0]
@@ -1628,19 +1762,16 @@ class projectDialog(QDialog, Ui_dlgProject):
 
                                 row["modifiers"] = dict(modifiers_dict)
                             except Exception:
-
                                 logging.critical("Error removing leading/trailing spaces in modifiers")
 
-                                QMessageBox.critical(
-                                    self, cfg.programName, "Error removing leading/trailing spaces in modifiers"
-                                )
+                                QMessageBox.critical(self, cfg.programName, "Error removing leading/trailing spaces in modifiers")
 
                         else:
-                            row["modifiers"] = eval(row["modifiers"])
+                            row["modifiers"] = json.loads(row["modifiers"]) if row["modifiers"] else {}
                 else:
                     row[field] = ""
 
-            if (row["type"]) and (row["code"]):
+            if (row["type"]) and (row[cfg.BEHAVIOR_CODE]):
                 checked_ethogram[str(len(checked_ethogram))] = row
             else:
                 missing_data.append(str(r + 1))
@@ -1662,27 +1793,40 @@ class projectDialog(QDialog, Ui_dlgProject):
             return {cfg.CANCEL: True}
 
         # check if behavior belong to category that is not in categories list
-        behavior_category = []
+        missing_behavior_category: list = []
         for idx in checked_ethogram:
             if cfg.BEHAVIOR_CATEGORY in checked_ethogram[idx]:
                 if checked_ethogram[idx][cfg.BEHAVIOR_CATEGORY]:
                     if checked_ethogram[idx][cfg.BEHAVIOR_CATEGORY] not in self.pj[cfg.BEHAVIORAL_CATEGORIES]:
-                        behavior_category.append(
+                        missing_behavior_category.append(
                             (checked_ethogram[idx][cfg.BEHAVIOR_CODE], checked_ethogram[idx][cfg.BEHAVIOR_CATEGORY])
                         )
-        if behavior_category:
-
+        if missing_behavior_category:
             response = dialog.MessageDialog(
                 f"{cfg.programName} - Behavioral categories",
                 (
-                    "The behavioral categorie(s) "
-                    f"{', '.join(set(['<b>' + x[1] + '</b>' + ' (used with <b>' + x[0] + '</b>)' for x in behavior_category]))} "
-                    "are no more defined in behavioral categories list"
+                    "The behavioral category/ies<br> "
+                    f"{', '.join(set(['<b>' + x[1] + '</b>' + ' (used with <b>' + x[0] + '</b>)<br>' for x in missing_behavior_category]))} "
+                    "are not defined in behavioral categories list.<br>"
                 ),
-                ["Add behavioral category/ies", "Ignore", cfg.CANCEL],
+                ["Add behavioral category/ies", cfg.IGNORE, cfg.CANCEL],
             )
             if response == "Add behavioral category/ies":
-                [self.pj[cfg.BEHAVIORAL_CATEGORIES].append(x1) for x1 in set(x[1] for x in behavior_category)]
+                if cfg.BEHAVIORAL_CATEGORIES_CONF not in self.pj:
+                    self.pj[cfg.BEHAVIORAL_CATEGORIES_CONF] = {}
+                for x1 in set(x[1] for x in missing_behavior_category):
+                    self.pj[cfg.BEHAVIORAL_CATEGORIES].append(x1)
+
+                    if self.pj[cfg.BEHAVIORAL_CATEGORIES_CONF]:
+                        index = str(max([int(k) for k in self.pj[cfg.BEHAVIORAL_CATEGORIES_CONF]]) + 1)
+                    else:
+                        index = "0"
+
+                    self.pj[cfg.BEHAVIORAL_CATEGORIES_CONF][index] = {
+                        "name": x1,
+                        cfg.COLOR: "",
+                    }
+
             if response == cfg.CANCEL:
                 return {cfg.CANCEL: True}
 
@@ -1713,7 +1857,7 @@ class projectDialog(QDialog, Ui_dlgProject):
             self.pj[cfg.TIME_FORMAT] = cfg.HHMMSS
 
         # store subjects
-        self.subjects_conf = {}
+        self.subjects_conf: dict = {}
 
         # check for leading/trailing spaces in subjects names
         subjects_name_with_leading_trailing_spaces = ""
@@ -1724,7 +1868,6 @@ class projectDialog(QDialog, Ui_dlgProject):
 
         remove_leading_trailing_spaces = cfg.NO
         if subjects_name_with_leading_trailing_spaces:
-
             remove_leading_trailing_spaces = dialog.MessageDialog(
                 cfg.programName,
                 (
@@ -1740,10 +1883,9 @@ class projectDialog(QDialog, Ui_dlgProject):
         # check subjects
         for row in range(self.twSubjects.rowCount()):
             # check key
+            key: str = ""
             if self.twSubjects.item(row, 0):
                 key = self.twSubjects.item(row, 0).text()
-            else:
-                key = ""
 
             # check subject name
             if self.twSubjects.item(row, 1):
@@ -1754,9 +1896,7 @@ class projectDialog(QDialog, Ui_dlgProject):
 
                 # check if subject name is empty
                 if subjectName == "":
-                    QMessageBox.warning(
-                        self, cfg.programName, f"The subject name can not be empty (check row #{row + 1})."
-                    )
+                    QMessageBox.warning(self, cfg.programName, f"The subject name can not be empty (check row #{row + 1}).")
                     return
 
                 if "|" in subjectName:
@@ -1767,13 +1907,11 @@ class projectDialog(QDialog, Ui_dlgProject):
                     )
                     return
             else:
-                QMessageBox.warning(
-                    self, cfg.programName, f"Missing subject name in subjects configuration at row #{row + 1}"
-                )
+                QMessageBox.warning(self, cfg.programName, f"Missing subject name in subjects configuration at row #{row + 1}")
                 return
 
             # description
-            subjectDescription = ""
+            subjectDescription: str = ""
             if self.twSubjects.item(row, 2):
                 subjectDescription = self.twSubjects.item(row, 2).text().strip()
 
@@ -1783,6 +1921,25 @@ class projectDialog(QDialog, Ui_dlgProject):
                 "description": subjectDescription,
             }
 
+        # check if coded subjects are defined in the subjects list
+        subjects_list: list = [self.subjects_conf[x]["name"] for x in self.subjects_conf]
+        coded_subjects = set(
+            util.flatten_list([[y[1] for y in self.pj[cfg.OBSERVATIONS][x].get(cfg.EVENTS, [])] for x in self.pj[cfg.OBSERVATIONS]])
+        )
+
+        not_defined_subjects: list = []
+        for subject in coded_subjects:
+            if subject and subject not in subjects_list:
+                not_defined_subjects.append(subject)
+
+        if not_defined_subjects:
+            QMessageBox.warning(
+                self,
+                cfg.programName,
+                f"The coded subject(s) <b>{', '.join(not_defined_subjects)}</b> is/are not defined in the subjects list.<br>You can use the <b>Explore project</b> to fix it.",
+            )
+            return
+
         self.pj[cfg.SUBJECTS] = dict(self.subjects_conf)
 
         # check ethogram
@@ -1820,7 +1977,7 @@ class projectDialog(QDialog, Ui_dlgProject):
         self.pj[cfg.INDEPENDENT_VARIABLES] = dict(self.indVar)
 
         # converters
-        converters = {}
+        converters: dict = {}
         for row in range(self.tw_converters.rowCount()):
             converters[self.tw_converters.item(row, 0).text()] = {
                 "name": self.tw_converters.item(row, 0).text(),
@@ -1840,9 +1997,7 @@ class projectDialog(QDialog, Ui_dlgProject):
         for converter in sorted(self.converters.keys()):
             self.tw_converters.setRowCount(self.tw_converters.rowCount() + 1)
             self.tw_converters.setItem(self.tw_converters.rowCount() - 1, 0, QTableWidgetItem(converter))  # id / name
-            self.tw_converters.setItem(
-                self.tw_converters.rowCount() - 1, 1, QTableWidgetItem(self.converters[converter]["description"])
-            )
+            self.tw_converters.setItem(self.tw_converters.rowCount() - 1, 1, QTableWidgetItem(self.converters[converter]["description"]))
             self.tw_converters.setItem(
                 self.tw_converters.rowCount() - 1,
                 2,