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

boris/observation.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.
 
@@ -20,14 +20,14 @@ This file is part of BORIS.
 
 """
 
-import glob
 import logging
 import os
+import pandas as pd
 import pathlib as pl
 
-from PyQt5.QtCore import Qt
-from PyQt5.QtGui import QColor
-from PyQt5.QtWidgets import (
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QColor
+from PySide6.QtWidgets import (
     QDialog,
     QVBoxLayout,
     QHBoxLayout,
@@ -42,10 +42,11 @@ from PyQt5.QtWidgets import (
     QApplication,
     QMenu,
     QListWidgetItem,
+    QHeaderView,
 )
 
 from . import config as cfg
-from . import dialog, duration_widget, plot_data_module, project_functions
+from . import dialog, plot_data_module, project_functions
 from . import utilities as util
 from . import gui_utilities
 from .observation_ui import Ui_Form
@@ -75,7 +76,10 @@ class AssignConverter(QDialog):
             self.cbb[-1].addItems(["None"] + sorted(converters.keys()))
 
             if column_idx in col_conv:
-                self.cbb[-1].setCurrentIndex((["None"] + sorted(converters.keys())).index(col_conv[column_idx]))
+                if col_conv[column_idx] in (["None"] + sorted(converters.keys())):
+                    self.cbb[-1].setCurrentIndex((["None"] + sorted(converters.keys())).index(col_conv[column_idx]))
+                else:
+                    self.cbb[-1].setCurrentIndex(0)
             else:
                 self.cbb[-1].setCurrentIndex(0)
             hbox.addWidget(self.cbb[-1])
@@ -96,7 +100,7 @@ class AssignConverter(QDialog):
 
 
 class Observation(QDialog, Ui_Form):
-    def __init__(self, tmp_dir, project_path="", converters={}, time_format=cfg.S, parent=None):
+    def __init__(self, tmp_dir: str, project_path: str = "", converters: dict = {}, time_format: str = cfg.S, parent=None):
         """
         Args:
             tmp_dir (str): path of temporary directory
@@ -110,22 +114,31 @@ class Observation(QDialog, Ui_Form):
         self.project_path = project_path
         self.converters = converters
         self.time_format = time_format
-        self.observation_time_interval = [0, 0]
+        self.observation_time_interval: tuple = [0, 0]
         self.mem_dir = ""
         self.test = None
 
         self.setupUi(self)
 
         # insert duration widget for time offset
-        self.obs_time_offset = duration_widget.Duration_widget(0)
+        # self.obs_time_offset = duration_widget.Duration_widget(0)
+        self.obs_time_offset = dialog.get_time_widget(0)
         self.horizontalLayout_6.insertWidget(1, self.obs_time_offset)
+        self.obs_time_offset.setEnabled(False)
+
+        # time offset
+        self.cb_time_offset.stateChanged.connect(self.cb_time_offset_changed)
+        # date offset
+        """self.cb_date_offset.stateChanged.connect(self.cb_date_offset_changed)"""
 
         # observation type
         self.rb_media_files.toggled.connect(self.obs_type_changed)
         self.rb_live.toggled.connect(self.obs_type_changed)
         self.rb_images.toggled.connect(self.obs_type_changed)
 
-        menu_items = [
+        # button menu for media
+
+        add_media_menu_items = [
             "media abs path|with absolute path",
             "media rel path|with relative path",
             {
@@ -135,26 +148,71 @@ class Observation(QDialog, Ui_Form):
                 ]
             },
         ]
-        menu = QMenu()
-        menu.triggered.connect(lambda x: self.add_media(mode=x.statusTip()))
-        self.add_button_menu(menu_items, menu)
-        self.pbAddVideo.setMenu(menu)
+
+        self.media_menu = QMenu()
+        # Add actions to the menu
+        """
+        self.action1 = QAction("with absolute path")
+        self.action2 = QAction("with relative path")
+        self.action3 = QAction("directory with absolute path")
+        self.action4 = QAction("directory with relative path")
+
+        self.menu.addAction(self.action1)
+        self.menu.addAction(self.action2)
+        self.menu.addAction(self.action3)
+        self.menu.addAction(self.action4)
+
+        # Connect actions to functions
+        self.action1.triggered.connect(lambda: self.add_media(mode="media abs path|with absolute path"))
+        self.action2.triggered.connect(lambda: self.add_media(mode="media rel path|with relative path"))
+        self.action3.triggered.connect(lambda: self.add_media(mode="dir abs path|with absolute path"))
+        self.action4.triggered.connect(lambda: self.add_media(mode="dir rel path|wih relative path"))
+        """
+
+        self.media_menu.triggered.connect(lambda x: self.add_media(mode=x.statusTip()))
+        self.add_button_menu(add_media_menu_items, self.media_menu)
+        self.pbAddVideo.setMenu(self.media_menu)
 
         self.pbRemoveVideo.clicked.connect(self.remove_media)
 
-        # add data file
+        # button menu for data file
         data_menu_items = [
             "data abs path|with absolute path",
             "data rel path|with relative path",
         ]
 
-        menu_data = QMenu()
-        menu_data.triggered.connect(lambda x: self.add_data_file(mode=x.statusTip()))
-        self.add_button_menu(data_menu_items, menu_data)
-        self.pb_add_data_file.setMenu(menu_data)
+        self.menu_data = QMenu()
+
+        # Add actions to the menu
+        """
+        self.data_action1 = QAction("with absolute path")
+        self.data_action2 = QAction("with relative path")
+        self.menu_data.addAction(self.data_action1)
+        self.menu_data.addAction(self.data_action2)
+
+        # Connect actions to functions
+        self.data_action1.triggered.connect(lambda: self.add_data_file(mode="data abs path|with absolute path"))
+        self.data_action2.triggered.connect(lambda: self.add_data_file(mode="data rel path|with relative path"))
+        """
+
+        self.menu_data.triggered.connect(lambda x: self.add_data_file(mode=x.statusTip()))
+        self.add_button_menu(data_menu_items, self.menu_data)
+        self.pb_add_data_file.setMenu(self.menu_data)
+
+        # button menu for images
+        images_menu_items = [
+            "images abs path|with absolute path",
+            "images rel path|with relative path",
+        ]
+
+        self.menu_images = QMenu()
+
+        self.menu_images.triggered.connect(lambda x: self.add_images_directory(mode=x.statusTip()))
+        self.add_button_menu(images_menu_items, self.menu_images)
+        self.pb_add_directory.setMenu(self.menu_images)
 
         self.pb_remove_data_file.clicked.connect(self.remove_data_file)
-        self.pb_view_data_head.clicked.connect(self.view_data_file_head)
+        self.pb_view_data_head.clicked.connect(self.view_data_file_head_tail)
         self.pb_plot_data.clicked.connect(self.plot_data_file)
 
         self.pb_use_media_file_name_as_obsid.clicked.connect(self.use_media_file_name_as_obsid)
@@ -162,6 +220,7 @@ class Observation(QDialog, Ui_Form):
 
         self.cbVisualizeSpectrogram.clicked.connect(self.extract_wav)
         self.cb_visualize_waveform.clicked.connect(self.extract_wav)
+
         self.cb_observation_time_interval.clicked.connect(self.limit_time_interval)
 
         self.pbSave.clicked.connect(self.pbSave_clicked)
@@ -169,21 +228,27 @@ class Observation(QDialog, Ui_Form):
         self.pbCancel.clicked.connect(self.pbCancel_clicked)
 
         self.tw_data_files.cellDoubleClicked[int, int].connect(self.tw_data_files_cellDoubleClicked)
+        self.tw_data_files.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
 
-        self.mediaDurations, self.mediaFPS, self.mediaHasVideo, self.mediaHasAudio = {}, {}, {}, {}
+        self.twVideo1.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
 
-        self.cbVisualizeSpectrogram.setEnabled(False)
-        self.cb_visualize_waveform.setEnabled(False)
-        self.cb_observation_time_interval.setEnabled(True)
+        self.mediaDurations, self.mediaFPS, self.mediaHasVideo, self.mediaHasAudio, self.media_creation_time = {}, {}, {}, {}, {}
 
-        # disabled due to problem when video goes back
-        self.cbCloseCurrentBehaviorsBetweenVideo.setChecked(False)
-        self.cbCloseCurrentBehaviorsBetweenVideo.setEnabled(False)
+        for w in (
+            self.cbVisualizeSpectrogram,
+            self.cb_visualize_waveform,
+            self.cb_observation_time_interval,
+            self.cb_media_creation_date_as_offset,
+            self.cbCloseCurrentBehaviorsBetweenVideo,
+        ):
+            w.setEnabled(False)
+
+        self.cb_observation_time_interval.setEnabled(True)
 
         self.cb_start_from_current_time.stateChanged.connect(self.cb_start_from_current_time_changed)
 
         # images
-        self.pb_add_directory.clicked.connect(self.add_images_directory)
+        # self.pb_add_directory.clicked.connect(self.add_images_directory)
         self.pb_remove_directory.clicked.connect(self.remove_images_directory)
 
         self.tabWidget.setCurrentIndex(0)
@@ -191,6 +256,60 @@ class Observation(QDialog, Ui_Form):
         # geometry
         gui_utilities.restore_geometry(self, "new observation", (800, 650))
 
+    # def cb_date_offset_changed(self):
+    #    """
+    #    activate/desactivate time value
+    #    """
+    #    self.de_date_offset.setEnabled(self.cb_date_offset.isChecked())
+
+    def check_media_creation_date(self):
+        """
+        check if all media files contain creation date time
+        search in metadata then in filename
+        """
+
+        creation_date_not_found: list = []
+        flag_filename_used = False
+
+        self.media_creation_time = {}
+
+        if self.cb_media_creation_date_as_offset.isChecked():
+            for row in range(self.twVideo1.rowCount()):
+                if self.twVideo1.item(row, 2).text():  # media file path
+                    date_time_original = util.extract_video_creation_date(
+                        project_functions.full_path(self.twVideo1.item(row, 2).text(), self.project_path)
+                    )
+                    if date_time_original is None:
+                        date_time_file_name = util.extract_date_time_from_file_name(self.twVideo1.item(row, 2).text())
+                        if date_time_file_name is None:
+                            creation_date_not_found.append(self.twVideo1.item(row, 2).text())
+                        else:
+                            self.media_creation_time[self.twVideo1.item(row, 2).text()] = date_time_file_name
+                            flag_filename_used = True
+                    else:
+                        self.media_creation_time[self.twVideo1.item(row, 2).text()] = date_time_original
+
+        if creation_date_not_found:
+            QMessageBox.warning(
+                self, cfg.programName, "The creation date time was not found for all media file(s).\nThe option was disabled."
+            )
+            self.cb_media_creation_date_as_offset.setChecked(False)
+            self.media_creation_time = {}
+            return 1
+
+        elif flag_filename_used:
+            QMessageBox.information(
+                self, cfg.programName, "The creation date time was not found in metadata. The media file name(s) was/were used"
+            )
+
+        return 0
+
+    def cb_time_offset_changed(self):
+        """
+        activate/desactivate date value
+        """
+        self.obs_time_offset.setEnabled(self.cb_time_offset.isChecked())
+
     def use_media_file_name_as_obsid(self) -> None:
         """
         set observation id with the media file name value (without path)
@@ -199,7 +318,7 @@ class Observation(QDialog, Ui_Form):
             QMessageBox.critical(self, cfg.programName, "A media file must be loaded in player #1")
             return
 
-        first_media_file = ""
+        first_media_file: str = ""
         for row in range(self.twVideo1.rowCount()):
             if int(self.twVideo1.cellWidget(row, 0).currentText()) == 1:
                 first_media_file = self.twVideo1.item(row, 2).text()
@@ -227,26 +346,76 @@ class Observation(QDialog, Ui_Form):
         change stacked widget page in base at the observation type
         """
 
-        for idx, rb in enumerate([self.rb_media_files, self.rb_live, self.rb_images]):
+        for idx, rb in enumerate((self.rb_media_files, self.rb_live, self.rb_images)):
             if rb.isChecked():
                 self.sw_observation_type.setCurrentIndex(idx + 1)
 
-    def add_images_directory(self):
+        # hide 'limit observation to time interval' for images
+        self.cb_observation_time_interval.setEnabled(not self.rb_images.isChecked())
+
+    def add_images_directory(self, mode: str):
         """
         add path to images directory
         """
-        dir_path = QFileDialog.getExistingDirectory(None, "Select directory", os.getenv("HOME"))
+
+        if mode.split("|")[0] not in (
+            "images abs path",
+            "images rel path",
+        ):
+            QMessageBox.critical(
+                self,
+                cfg.programName,
+                (f"Wrong mode to add a pictures directory {mode}"),
+            )
+            return
+
+        # check if project saved
+        if (" w/o" in mode or " rel " in mode) and (not self.project_file_name):
+            QMessageBox.critical(
+                self,
+                cfg.programName,
+                ("It is not possible to add a pictures directory with a relative path if the project is not already saved"),
+            )
+            return
+
+        fd = QFileDialog()
+        fd.setDirectory(os.path.expanduser("~") if (" abs " in mode) else str(pl.Path(self.project_path).parent))
+
+        dir_path = fd.getExistingDirectory(None, "Select directory")
+
+        if not dir_path:
+            return
+
         result = util.dir_images_number(dir_path)
         if not result.get("number of images", 0):
             response = dialog.MessageDialog(
                 cfg.programName,
-                "The directory does not contain images (*.jpg, *.jpeg, *.png)",
+                f"The directory does not contain images ({','.join(cfg.IMAGE_EXTENSIONS)})",
                 ["Cancel", "Add directory"],
             )
             if response == "Cancel":
                 return
 
-        self.lw_images_directory.addItem(QListWidgetItem(dir_path))
+        # store directory for next usage
+        self.mem_dir = str(pl.Path(dir_path))
+
+        if " rel " in mode:
+            try:
+                pl.Path(dir_path).parent.relative_to(pl.Path(self.project_path).parent)
+            except ValueError:
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    f"The directory <b>{pl.Path(dir_path).parent}</b> is not contained in <b>{pl.Path(self.project_path).parent}</b>.",
+                )
+                return
+
+        if " rel " in mode:
+            # convert to relative path (relative to BORIS project file)
+            self.lw_images_directory.addItem(QListWidgetItem(str(pl.Path(dir_path).relative_to(pl.Path(self.project_path).parent))))
+        else:
+            self.lw_images_directory.addItem(QListWidgetItem(dir_path))
+        self.lb_images_info.setText(f"Number of images in {dir_path}: {result.get('number of images', 0)}")
 
     def remove_images_directory(self):
         """
@@ -285,10 +454,14 @@ class Observation(QDialog, Ui_Form):
         """
 
         if self.cb_observation_time_interval.isChecked():
-            time_interval_dialog = dialog.Ask_time(self.time_format)
+            time_interval_dialog = dialog.Ask_time(0)
+            if self.time_format == cfg.S:
+                time_interval_dialog.time_widget.rb_seconds.setChecked(True)
+            if self.time_format == cfg.HHMMSS:
+                time_interval_dialog.time_widget.rb_time.setChecked(True)
             time_interval_dialog.time_widget.set_time(0)
             time_interval_dialog.setWindowTitle("Start observation at")
-            time_interval_dialog.label.setText("Start observation at")
+            time_interval_dialog.label.setText("<b>Start</b> observation at")
             start_time, stop_time = 0, 0
             if time_interval_dialog.exec_():
                 start_time = time_interval_dialog.time_widget.get_time()
@@ -297,7 +470,7 @@ class Observation(QDialog, Ui_Form):
                 return
             time_interval_dialog.time_widget.set_time(0)
             time_interval_dialog.setWindowTitle("Stop observation at")
-            time_interval_dialog.label.setText("Stop observation at")
+            time_interval_dialog.label.setText("<b>Stop</b> observation at")
             if time_interval_dialog.exec_():
                 stop_time = time_interval_dialog.time_widget.get_time()
             else:
@@ -311,7 +484,10 @@ class Observation(QDialog, Ui_Form):
                     return
                 self.observation_time_interval = [start_time, stop_time]
                 self.cb_observation_time_interval.setText(
-                    f"Limit observation to a time interval: {start_time} - {stop_time}"
+                    (
+                        "Limit observation to a time interval: "
+                        f"{util.smart_time_format(start_time, self.time_format)} - {util.smart_time_format(stop_time, self.time_format)}"
+                    )
                 )
         else:
             self.observation_time_interval = [0, 0]
@@ -333,9 +509,7 @@ class Observation(QDialog, Ui_Form):
 
                 if w.exec_():
                     d = {}
-                    for col_idx, cb in zip(
-                        self.tw_data_files.item(row, cfg.PLOT_DATA_COLUMNS_IDX).text().split(","), w.cbb
-                    ):
+                    for col_idx, cb in zip(self.tw_data_files.item(row, cfg.PLOT_DATA_COLUMNS_IDX).text().split(","), w.cbb):
                         if cb.currentText() != "None":
                             d[col_idx] = cb.currentText()
                     self.tw_data_files.item(row, cfg.PLOT_DATA_CONVERTERS_IDX).setText(str(d))
@@ -350,12 +524,12 @@ class Observation(QDialog, Ui_Form):
 
         if self.pb_plot_data.text() != "Show plot":
             self.test.close_plot()
+            self.text = None
             # update button text
             self.pb_plot_data.setText("Show plot")
             return
 
         if self.tw_data_files.selectedIndexes() or self.tw_data_files.rowCount() == 1:
-
             if self.tw_data_files.rowCount() == 1:
                 row_idx = 0
             else:
@@ -375,9 +549,7 @@ class Observation(QDialog, Ui_Form):
             time_interval = int(self.tw_data_files.item(row_idx, cfg.PLOT_DATA_TIMEINTERVAL_IDX).text())
             time_offset = int(self.tw_data_files.item(row_idx, cfg.PLOT_DATA_TIMEOFFSET_IDX).text())
 
-            substract_first_value = self.tw_data_files.cellWidget(
-                row_idx, cfg.PLOT_DATA_SUBSTRACT1STVALUE_IDX
-            ).currentText()
+            substract_first_value = self.tw_data_files.cellWidget(row_idx, cfg.PLOT_DATA_SUBSTRACT1STVALUE_IDX).currentText()
 
             plot_color = self.tw_data_files.cellWidget(row_idx, cfg.PLOT_DATA_PLOTCOLOR_IDX).currentText()
 
@@ -411,7 +583,7 @@ class Observation(QDialog, Ui_Form):
 
             if self.test.error_msg:
                 QMessageBox.critical(self, cfg.programName, f"Impossible to plot data:\n{self.test.error_msg}")
-                del self.test
+                self.test = None
                 return
 
             # self.test.setWindowFlags(self.test.windowFlags() | Qt.WindowStaysOnTopHint)
@@ -419,16 +591,22 @@ class Observation(QDialog, Ui_Form):
             self.test.update_plot(0)
             # update button text
             self.pb_plot_data.setText("Close plot")
-
         else:
             QMessageBox.warning(self, cfg.programName, "Select a data file")
 
-    def add_data_file(self, mode=True):
+    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() - 5, window_color.green() - 5, window_color.blue() - 5)
+
+    def add_data_file(self, mode: str):
         """
         user select a data file to be plotted synchronously with media file
 
         Args:
-            flag_path (bool): True to store path of data file else False
+            mode (str): statusTip() data abs path / data rel path
         """
 
         if mode.split("|")[0] not in (
@@ -447,9 +625,7 @@ class Observation(QDialog, Ui_Form):
             QMessageBox.critical(
                 self,
                 cfg.programName,
-                (
-                    "It is not possible to add a data file without path or with a relative path if the project is not already saved"
-                ),
+                ("It is not possible to add a data file with a relative path if the project is not already saved"),
             )
             return
 
@@ -458,127 +634,137 @@ class Observation(QDialog, Ui_Form):
             QMessageBox.warning(
                 self,
                 cfg.programName,
-                (
-                    "It is not yet possible to plot more than 2 external data sources"
-                    "This limitation will be removed in future"
-                ),
+                ("It is not yet possible to plot more than 2 external data sourcesThis limitation will be removed in future"),
             )
             return
 
         fd = QFileDialog()
         fd.setDirectory(os.path.expanduser("~") if (" abs " in mode) else str(pl.Path(self.project_path).parent))
 
-        fn = fd.getOpenFileName(self, "Add data file", "", "All files (*)")
-        file_name = fn[0] if type(fn) is tuple else fn
-
-        if file_name:
+        file_name, _ = fd.getOpenFileName(self, "Add data file", "", "All files (*)")
+        if not file_name:
+            return
 
-            columns_to_plot = "1,2"  # columns to plot by default
+        columns_to_plot = "1,2"  # columns to plot by default
 
-            # check data file
-            r = util.check_txt_file(file_name)  # check_txt_file defined in utilities
+        # check data file
+        file_parameters = util.check_txt_file(file_name)
 
-            if "error" in r:
-                QMessageBox.critical(self, cfg.programName, r["error"])
-                return
+        if "error" in file_parameters:
+            QMessageBox.critical(self, cfg.programName, f"Error on file {file_name}: {file_parameters['error']}")
+            return
 
-            if not r["homogeneous"]:  # not all rows have 2 columns
-                QMessageBox.critical(self, cfg.programName, "This file does not contain a constant number of columns")
-                return
+        if not file_parameters["homogeneous"]:  # the number of columns is not constant
+            QMessageBox.critical(self, cfg.programName, "This file does not contain a constant number of columns")
+            return
 
-            header = util.return_file_header(file_name, row_number=10)
+        header, footer = util.return_file_header_footer(file_name, file_row_number=file_parameters["rows number"], row_number=5)
 
-            if not header:
-                return  # problem with header
+        if not header:
+            QMessageBox.critical(self, cfg.programName, f"Error on file {pl.Path(file_name).name}")
+            return
 
-            w = dialog.View_data_head()
-            w.setWindowTitle(f"Data file: {pl.Path(file_name).name}")
-            """w.setWindowFlags(Qt.WindowStaysOnTopHint)"""
+        w = dialog.View_data()
+        w.setWindowTitle("View data")
+        w.lb.setText(f"View first and last rows of <b>{pl.Path(file_name).name}</b> file")
 
-            w.tw.setColumnCount(r["fields number"])
+        w.tw.setColumnCount(file_parameters["fields number"])
+        if footer:
+            hf = header + [file_parameters["separator"].join(["..."] * file_parameters["fields number"])] + footer
+            w.tw.setRowCount(len(header) + len(footer) + 1)
+        else:
+            hf = header
             w.tw.setRowCount(len(header))
 
-            for row in range(len(header)):
-                for col, v in enumerate(header[row].split(r["separator"])):
-                    item = QTableWidgetItem(v)
-                    item.setFlags(Qt.ItemIsEnabled)
-                    w.tw.setItem(row, col, item)
-
-            while True:
-                flag_ok = True
-                if w.exec_():
-                    columns_to_plot = w.le.text().replace(" ", "")
-                    for col in columns_to_plot.split(","):
-                        try:
-                            col_idx = int(col)
-                        except ValueError:
-                            QMessageBox.critical(
-                                self, cfg.programName, f"<b>{col}</b> does not seem to be a column index"
-                            )
-                            flag_ok = False
-                            break
-                        if col_idx <= 0 or col_idx > r["fields number"]:
-                            QMessageBox.critical(self, cfg.programName, f"<b>{col}</b> is not a valid column index")
-                            flag_ok = False
-                            break
-                    if flag_ok:
+        for idx, row in enumerate(hf):
+            for col, v in enumerate(row.split(file_parameters["separator"])):
+                item = QTableWidgetItem(v)
+                item.setFlags(Qt.ItemIsEnabled)
+                w.tw.setItem(idx, col, item)
+
+        # stats
+        try:
+            df = pd.read_csv(file_name, sep=file_parameters["separator"], header=None if not file_parameters["has header"] else [0])
+            # set columns names to based 1 index
+            if not file_parameters["has header"]:
+                df.columns = range(1, len(df.columns) + 1)
+
+            stats_out = str(df.describe())
+        except Exception:
+            stats_out = "Not available"
+        w.stats.setPlainText(stats_out)
+
+        while True:
+            flag_ok = True
+            if w.exec_():
+                columns_to_plot = w.le.text().replace(" ", "")
+                for col in columns_to_plot.split(","):
+                    try:
+                        col_idx = int(col)
+                    except ValueError:
+                        QMessageBox.critical(self, cfg.programName, f"<b>{col}</b> does not seem to be a column index")
+                        flag_ok = False
                         break
-                else:
-                    return
-
+                    if col_idx <= 0 or col_idx > file_parameters["fields number"]:
+                        QMessageBox.critical(self, cfg.programName, f"<b>{col}</b> is not a valid column index")
+                        flag_ok = False
+                        break
+                if flag_ok:
+                    break
             else:
                 return
 
-            self.tw_data_files.setRowCount(self.tw_data_files.rowCount() + 1)
-
-            if " rel " in mode:
-
-                try:
-                    file_path = str(pl.Path(file_name).relative_to(pl.Path(self.project_path).parent))
-                except ValueError:
-                    QMessageBox.critical(
-                        self,
-                        cfg.programName,
-                        f"The directory <b>{pl.Path(file_name).parent}</b> is not contained in <b>{pl.Path(self.project_path).parent}</b>.",
-                    )
-                    return
+        else:
+            return
 
-            else:  # save absolute path
-                file_path = file_name
-
-            for col_idx, value in zip(
-                [
-                    cfg.PLOT_DATA_FILEPATH_IDX,
-                    cfg.PLOT_DATA_COLUMNS_IDX,
-                    cfg.PLOT_DATA_PLOTTITLE_IDX,
-                    cfg.PLOT_DATA_VARIABLENAME_IDX,
-                    cfg.PLOT_DATA_CONVERTERS_IDX,
-                    cfg.PLOT_DATA_TIMEINTERVAL_IDX,
-                    cfg.PLOT_DATA_TIMEOFFSET_IDX,
-                ],
-                [file_path, columns_to_plot, "", "", "", "60", "0"],
-            ):
-                item = QTableWidgetItem(value)
-                if col_idx == cfg.PLOT_DATA_CONVERTERS_IDX:
-                    item.setFlags(Qt.ItemIsEnabled)
-                    item.setBackground(QColor(230, 230, 230))
-                self.tw_data_files.setItem(self.tw_data_files.rowCount() - 1, col_idx, item)
-
-            # substract first value
-            combobox = QComboBox()
-            combobox.addItems(["True", "False"])
-            self.tw_data_files.setCellWidget(
-                self.tw_data_files.rowCount() - 1, cfg.PLOT_DATA_SUBSTRACT1STVALUE_IDX, combobox
-            )
+        self.tw_data_files.setRowCount(self.tw_data_files.rowCount() + 1)
 
-            # plot line color
-            combobox = QComboBox()
-            combobox.addItems(cfg.DATA_PLOT_STYLES)
-            self.tw_data_files.setCellWidget(self.tw_data_files.rowCount() - 1, cfg.PLOT_DATA_PLOTCOLOR_IDX, combobox)
+        if " rel " in mode:
+            try:
+                file_path = str(pl.Path(file_name).relative_to(pl.Path(self.project_path).parent))
+            except ValueError:
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    f"The directory <b>{pl.Path(file_name).parent}</b> is not contained in <b>{pl.Path(self.project_path).parent}</b>.",
+                )
+                return
 
-    def view_data_file_head(self):
+        else:  # save absolute path
+            file_path = file_name
+
+        for col_idx, value in zip(
+            [
+                cfg.PLOT_DATA_FILEPATH_IDX,
+                cfg.PLOT_DATA_COLUMNS_IDX,
+                cfg.PLOT_DATA_PLOTTITLE_IDX,
+                cfg.PLOT_DATA_VARIABLENAME_IDX,
+                cfg.PLOT_DATA_CONVERTERS_IDX,
+                cfg.PLOT_DATA_TIMEINTERVAL_IDX,
+                cfg.PLOT_DATA_TIMEOFFSET_IDX,
+            ],
+            [file_path, columns_to_plot, "", "", "", "60", "0"],
+        ):
+            item = QTableWidgetItem(value)
+            if col_idx == cfg.PLOT_DATA_CONVERTERS_IDX:
+                item.setFlags(Qt.ItemIsEnabled)
+                # item.setBackground(QColor(230, 230, 230))
+                item.setBackground(self.not_editable_column_color())
+            self.tw_data_files.setItem(self.tw_data_files.rowCount() - 1, col_idx, item)
+
+        # substract first value
+        combobox = QComboBox()
+        combobox.addItems(["True", "False"])
+        self.tw_data_files.setCellWidget(self.tw_data_files.rowCount() - 1, cfg.PLOT_DATA_SUBSTRACT1STVALUE_IDX, combobox)
+
+        # plot line color
+        combobox = QComboBox()
+        combobox.addItems(cfg.DATA_PLOT_STYLES)
+        self.tw_data_files.setCellWidget(self.tw_data_files.rowCount() - 1, cfg.PLOT_DATA_PLOTCOLOR_IDX, combobox)
+
+    def view_data_file_head_tail(self) -> None:
         """
-        view first parts of data file
+        view first and last rows of data file
         """
 
         if not self.tw_data_files.selectedIndexes() and self.tw_data_files.rowCount() != 1:
@@ -587,111 +773,202 @@ class Observation(QDialog, Ui_Form):
         if self.tw_data_files.rowCount() == 1:
             data_file_path = project_functions.full_path(self.tw_data_files.item(0, 0).text(), self.project_path)
             columns_to_plot = self.tw_data_files.item(0, 1).text()
-        else:
+        else:  #  selected file
             data_file_path = project_functions.full_path(
                 self.tw_data_files.item(self.tw_data_files.selectedIndexes()[0].row(), 0).text(), self.project_path
             )
             columns_to_plot = self.tw_data_files.item(self.tw_data_files.selectedIndexes()[0].row(), 1).text()
 
         file_parameters = util.check_txt_file(data_file_path)
+
         if "error" in file_parameters:
             QMessageBox.critical(self, cfg.programName, f"Error on file {data_file_path}: {file_parameters['error']}")
             return
-        header = util.return_file_header(data_file_path)
-
-        if header:
+        header, footer = util.return_file_header_footer(data_file_path, file_row_number=file_parameters["rows number"], row_number=5)
 
-            w = dialog.View_data_head()
-            w.setWindowTitle(f"Data file: {pl.Path(data_file_path).name}")
-            w.label.setText("Index of columns to plot")
-            w.le.setEnabled(False)
-            w.le.setText(columns_to_plot)
-            w.pbCancel.setVisible(False)
+        if not header:
+            QMessageBox.critical(self, cfg.programName, f"Error on file {pl.Path(data_file_path).name}")
+            return
 
-            w.tw.setColumnCount(file_parameters["fields number"])
+        w = dialog.View_data()
+        w.setWindowTitle("View data")
+        w.lb.setText(f"View first and last rows of <b>{pl.Path(data_file_path).name}</b> file")
+        w.pbOK.setText(cfg.CLOSE)
+        w.label.setText("Index of columns to plot")
+        w.le.setEnabled(False)
+        w.le.setText(columns_to_plot)
+        w.pbCancel.setVisible(False)
+
+        w.tw.setColumnCount(file_parameters["fields number"])
+        if footer:
+            hf = header + [file_parameters["separator"].join(["..."] * file_parameters["fields number"])] + footer
+            w.tw.setRowCount(len(header) + len(footer) + 1)
+        else:
+            hf = header
             w.tw.setRowCount(len(header))
 
-            for row in range(len(header)):
-                for col, v in enumerate(header[row].split(file_parameters["separator"])):
-                    w.tw.setItem(row, col, QTableWidgetItem(v))
+        for idx, row in enumerate(hf):
+            for col, v in enumerate(row.split(file_parameters["separator"])):
+                item = QTableWidgetItem(v)
+                item.setFlags(Qt.ItemIsEnabled)
+                w.tw.setItem(idx, col, item)
 
-            w.exec_()
+        # stats
+        try:
+            df = pd.read_csv(
+                data_file_path,
+                sep=file_parameters["separator"],
+                header=None if not file_parameters["has header"] else [0],
+            )
+            # set columns names to based 1 index
+            if not file_parameters["has header"]:
+                df.columns = range(1, len(df.columns) + 1)
 
-        else:
-            QMessageBox.critical(self, cfg.programName, f"Error on file {data_file_path}")
+            stats_out = str(df.describe())
+        except Exception:
+            stats_out = "Not available"
+        w.stats.setPlainText(stats_out)
+
+        w.exec_()
 
     def extract_wav(self):
         """
         extract wav of all media files loaded in player #1
         """
 
-        if self.cbVisualizeSpectrogram.isChecked() or self.cb_visualize_waveform.isChecked():
-            flag_wav_produced = False
-            # check if player 1 is selected
-            flag_player1 = False
-            for row in range(self.twVideo1.rowCount()):
-                if self.twVideo1.cellWidget(row, 0).currentText() == "1":
-                    flag_player1 = True
+        if not self.cbVisualizeSpectrogram.isChecked() and not self.cb_visualize_waveform.isChecked():
+            return
 
-            if not flag_player1:
-                QMessageBox.critical(self, cfg.programName, "The player #1 is not selected")
-                self.cbVisualizeSpectrogram.setChecked(False)
-                self.cb_visualize_waveform.setChecked(False)
-                return
-            """
-            if dialog.MessageDialog(programName, ("You choose to visualize the spectrogram or waveform for the media in player #1.<br>"
-                                                  "The WAV will be extracted from the media files, be patient"), [YES, NO]) == YES:
-            """
-            if True:
+        flag_wav_produced = False
+        # check if player 1 is selected
+        flag_player1 = False
+        for row in range(self.twVideo1.rowCount()):
+            if self.twVideo1.cellWidget(row, 0).currentText() == "1":
+                flag_player1 = True
 
-                w = dialog.Info_widget()
-                w.resize(350, 100)
-                # w.setWindowFlags(Qt.WindowStaysOnTopHint)
-                w.setWindowTitle("BORIS")
-                w.label.setText("Extracting WAV from media files...")
+        if not flag_player1:
+            QMessageBox.critical(self, cfg.programName, "The player #1 is not selected")
+            self.cbVisualizeSpectrogram.setChecked(False)
+            self.cb_visualize_waveform.setChecked(False)
+            return
 
-                for row in range(self.twVideo1.rowCount()):
-                    # check if player 1
-                    if self.twVideo1.cellWidget(row, 0).currentText() != "1":
-                        continue
+        if True:
+            w = dialog.Info_widget()
+            w.resize(350, 100)
+            # w.setWindowFlags(Qt.WindowStaysOnTopHint)
+            w.setWindowTitle("BORIS")
+            w.label.setText("Extracting WAV from media files...")
 
-                    media_file_path = project_functions.full_path(
-                        self.twVideo1.item(row, cfg.MEDIA_FILE_PATH_IDX).text(), self.project_path
-                    )
-                    if self.twVideo1.item(row, cfg.HAS_AUDIO_IDX).text() == "False":
+            for row in range(self.twVideo1.rowCount()):
+                # check if player 1
+                if self.twVideo1.cellWidget(row, 0).currentText() != "1":
+                    continue
+
+                media_file_path = project_functions.full_path(self.twVideo1.item(row, cfg.MEDIA_FILE_PATH_IDX).text(), self.project_path)
+                if self.twVideo1.item(row, cfg.HAS_AUDIO_IDX).text() == "False":
+                    QMessageBox.critical(self, cfg.programName, f"The media file {media_file_path} does not seem to have audio")
+                    flag_wav_produced = False
+                    break
+
+                if os.path.isfile(media_file_path):
+                    w.show()
+                    QApplication.processEvents()
+
+                    if util.extract_wav(self.ffmpeg_bin, media_file_path, self.tmp_dir) == "":
                         QMessageBox.critical(
-                            self, cfg.programName, f"The media file {media_file_path} does not seem to have audio"
+                            self,
+                            cfg.programName,
+                            f"Error during extracting WAV of the media file {media_file_path}",
                         )
                         flag_wav_produced = False
                         break
 
-                    if os.path.isfile(media_file_path):
-                        w.show()
-                        QApplication.processEvents()
+                    w.hide()
 
-                        if util.extract_wav(self.ffmpeg_bin, media_file_path, self.tmp_dir) == "":
-                            QMessageBox.critical(
-                                self,
-                                cfg.programName,
-                                f"Error during extracting WAV of the media file {media_file_path}",
-                            )
-                            flag_wav_produced = False
-                            break
+                    flag_wav_produced = True
+                else:
+                    QMessageBox.warning(self, cfg.programName, f"<b>{media_file_path}</b> file not found")
 
-                        w.hide()
+            if not flag_wav_produced:
+                self.cbVisualizeSpectrogram.setChecked(False)
+                self.cb_visualize_waveform.setChecked(False)
 
-                        flag_wav_produced = True
-                    else:
-                        QMessageBox.warning(self, cfg.programName, f"<b>{media_file_path}</b> file not found")
+    def check_creation_date(self) -> int:
+        """
+        check if media file exists
+        check if Creation Date tag is present in metadata of media file
 
-                if not flag_wav_produced:
-                    self.cbVisualizeSpectrogram.setChecked(False)
-                    self.cb_visualize_waveform.setChecked(False)
-            """
+        Returns:
+            int: 0 if OK else error code: 1 -> media file date not used, 2 -> media file not found
+
+        """
+
+        # check if media files exist
+
+        media_not_found_list: list = []
+        for row in range(self.twVideo1.rowCount()):
+            if not pl.Path(self.twVideo1.item(row, 2).text()).is_file():
+                media_not_found_list.append(self.twVideo1.item(row, 2).text())
+
+        """
+        if media_list:
+            dlg = dialog.Results_dialog()
+            dlg.setWindowTitle("BORIS")
+            dlg.pbOK.setText("OK")
+            dlg.pbCancel.setVisible(False)
+            dlg.ptText.clear()
+            dlg.ptText.appendHtml(
+                (
+                    "Some media file(s) were not found:<br>"
+                    f"{'<br>'.join(media_list)}<br><br>"
+                    "You cannot select the <b>Use the media creation date/time option</b>."
+                )
+            )
+            dlg.ptText.moveCursor(QTextCursor.Start)
+            ret = dlg.exec_()
+        """
+
+        """
+        not_tagged_media_list: list = []
+        for row in range(self.twVideo1.rowCount()):
+            if self.twVideo1.item(row, 2).text() not in media_not_found_list:
+                media_info = util.accurate_media_analysis(self.ffmpeg_bin, self.twVideo1.item(row, 2).text())
+                if cfg.MEDIA_CREATION_TIME not in media_info or media_info[cfg.MEDIA_CREATION_TIME] == cfg.NA:
+                    not_tagged_media_list.append(self.twVideo1.item(row, 2).text())
+                else:
+                    creation_time_epoch = int(dt.datetime.strptime(media_info[cfg.MEDIA_CREATION_TIME], "%Y-%m-%d %H:%M:%S").timestamp())
+                    self.media_creation_time[self.twVideo1.item(row, 2).text()] = creation_time_epoch
+
+        if not_tagged_media_list:
+            dlg = dialog.Results_dialog()
+            dlg.setWindowTitle("BORIS")
+            dlg.pbOK.setText("Yes")
+            dlg.pbCancel.setVisible(True)
+            dlg.pbCancel.setText("No")
+
+            dlg.ptText.clear()
+            dlg.ptText.appendHtml(
+                (
+                    "Some media file does not contain the <b>Creation date/time</b> metadata tag:<br>"
+                    f"{'<br>'.join(not_tagged_media_list)}<br><br>"
+                    "Use the media file date/time instead?"
+                )
+            )
+            dlg.ptText.moveCursor(QTextCursor.Start)
+            ret = dlg.exec_()
+
+            if ret == 1:  #  use file creation time
+                for media in not_tagged_media_list:
+                    self.media_creation_time[media] = pl.Path(media).stat().st_ctime
+                return 0  # OK use media file creation date/time
             else:
-                self.cbVisualizeSpectrogram.setChecked(False)
-                self.cb_visualize_waveform.setChecked(False)
-            """
+                self.cb_media_creation_date_as_offset.setChecked(False)
+                self.media_creation_time = {}
+                return 1
+        else:
+            return 0  # OK all media have a 'creation time' tag
+        """
+        return 0
 
     def closeEvent(self, event):
         """
@@ -699,6 +976,7 @@ class Observation(QDialog, Ui_Form):
         """
         if self.test is not None:
             self.test.close_plot()
+            self.text = None
 
     def pbCancel_clicked(self):
         """
@@ -706,13 +984,16 @@ class Observation(QDialog, Ui_Form):
         """
         if self.test is not None:
             self.test.close_plot()
+            self.text = None
         self.reject()
 
-    def check_parameters(self):
+    def check_parameters(self) -> bool:
         """
         check observation parameters
 
-        return True if everything OK else False
+        Returns:
+            bool: True if everything is OK else False
+
         """
 
         def is_numeric(s):
@@ -733,21 +1014,40 @@ class Observation(QDialog, Ui_Form):
 
         # check if observation id not empty
         if not self.leObservationId.text():
-            self.qm = QMessageBox()
-            self.qm.setIcon(QMessageBox.Critical)
-            self.qm.setText("The <b>observation id</b> is mandatory and must be unique.")
-            self.qm.exec_()
+            QMessageBox.critical(
+                self,
+                cfg.programName,
+                "The <b>observation id</b> is mandatory and must be unique.",
+            )
             return False
 
         # check if observation_type
         if not any((self.rb_media_files.isChecked(), self.rb_live.isChecked(), self.rb_images.isChecked())):
-            self.qm = QMessageBox()
-            self.qm.setIcon(QMessageBox.Critical)
-            self.qm.setText("Choose an observation type.")
-            self.qm.exec_()
+            QMessageBox.critical(
+                self,
+                cfg.programName,
+                "Choose an observation type.",
+            )
             return False
 
+        # check if offset is correct
+        if self.cb_time_offset.isChecked():
+            if self.obs_time_offset.get_time() is None:
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    "Check the time offset value.",
+                )
+                return False
+
         if self.rb_media_files.isChecked():  # observation based on media file(s)
+            # check if media file exists
+            media_file_not_found: list = []
+            for row in range(self.twVideo1.rowCount()):
+                # check if media file exists
+                if not pl.Path(self.twVideo1.item(row, 2).text()).is_file():
+                    media_file_not_found.append(self.twVideo1.item(row, 2).text())
+
             # check player number
             players_list: list = []
             players: dict = {}  # for storing duration
@@ -760,18 +1060,20 @@ class Observation(QDialog, Ui_Form):
 
             # check if player #1 is used
             if not players_list or min(players_list) > 1:
-                self.qm = QMessageBox()
-                self.qm.setIcon(QMessageBox.Critical)
-                self.qm.setText("A media file must be loaded in player #1")
-                self.qm.exec_()
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    "A media file must be loaded in player #1",
+                )
                 return False
 
             # check if players are used in crescent order
             if set(list(range(min(players_list), max(players_list) + 1))) != set(players_list):
-                self.qm = QMessageBox()
-                self.qm.setIcon(QMessageBox.Critical)
-                self.qm.setText("Some player are not used. Please reorganize your media files")
-                self.qm.exec_()
+                QMessageBox.critical(
+                    self,
+                    cfg.programName,
+                    "Some player are not used. Please reorganize your media files",
+                )
                 return False
 
             # check if more media in player #1 and media in other players
@@ -803,7 +1105,7 @@ class Observation(QDialog, Ui_Form):
                     return False
 
             # check that the longuest media is in player #1
-            durations = []
+            durations: list = []
             for i in sorted(list(players.keys())):
                 durations.append(sum(players[i]))
             if [x for x in durations[1:] if x > durations[0]]:
@@ -825,6 +1127,20 @@ class Observation(QDialog, Ui_Form):
                     )
                     return False
 
+            # check if offset set and only player #1 is used
+            if len(set(players_list)) == 1:
+                for row in range(self.twVideo1.rowCount()):
+                    if float(self.twVideo1.item(row, 1).text()):
+                        QMessageBox.critical(
+                            self,
+                            cfg.programName,
+                            (
+                                "It is not possible to use offset value(s) with only one player,<br>"
+                                "The offset values are use to synchronise various players."
+                            ),
+                        )
+                        return False
+
             # check offset for external data files
             for row in range(self.tw_data_files.rowCount()):
                 if not is_numeric(self.tw_data_files.item(row, cfg.PLOT_DATA_TIMEOFFSET_IDX).text()):
@@ -840,6 +1156,18 @@ class Observation(QDialog, Ui_Form):
                     )
                     return False
 
+            # check media creation time tag in metadata
+            # Disable because the check will be made at the observation start
+            """
+            if self.cb_media_creation_date_as_offset.isChecked():
+                if self.check_creation_date():
+                    return False
+            """
+
+            # check media creation date time (if option enabled)
+            if self.check_media_creation_date():
+                return False
+
         if self.rb_images.isChecked():  # observation based on images directory
             if not self.lw_images_directory.count():
                 QMessageBox.critical(self, cfg.programName, "You have to select at least one images directory")
@@ -848,9 +1176,7 @@ class Observation(QDialog, Ui_Form):
         # check if indep variables are correct type
         for row in range(self.twIndepVariables.rowCount()):
             if self.twIndepVariables.item(row, 1).text() == cfg.NUMERIC:
-                if self.twIndepVariables.item(row, 2).text() and not is_numeric(
-                    self.twIndepVariables.item(row, 2).text()
-                ):
+                if self.twIndepVariables.item(row, 2).text() and not is_numeric(self.twIndepVariables.item(row, 2).text()):
                     QMessageBox.critical(
                         self,
                         cfg.programName,
@@ -872,11 +1198,10 @@ class Observation(QDialog, Ui_Form):
                 )
                 return False
 
+        # check if numeric indep variable values are numeric
         for row in range(self.twIndepVariables.rowCount()):
             if self.twIndepVariables.item(row, 1).text() == cfg.NUMERIC:
-                if self.twIndepVariables.item(row, 2).text() and not is_numeric(
-                    self.twIndepVariables.item(row, 2).text()
-                ):
+                if self.twIndepVariables.item(row, 2).text() and not is_numeric(self.twIndepVariables.item(row, 2).text()):
                     QMessageBox.critical(
                         self,
                         cfg.programName,
@@ -888,12 +1213,13 @@ class Observation(QDialog, Ui_Form):
 
     def pbLaunch_clicked(self):
         """
-        Close window and start observation
+        Close dialog and start the observation
         """
 
         if self.check_parameters():
             if self.test is not None:
                 self.test.close_plot()
+                self.text = None
             self.done(2)
 
     def pbSave_clicked(self):
@@ -904,6 +1230,7 @@ class Observation(QDialog, Ui_Form):
             self.state = "accepted"
             if self.test is not None:
                 self.test.close_plot()
+                self.text = None
             self.accept()
         else:
             self.state = "refused"
@@ -921,24 +1248,54 @@ class Observation(QDialog, Ui_Form):
              str: error message or empty string
         """
 
+        logging.debug(f"check_media function for {file_path}")
+
         media_info = util.accurate_media_analysis(self.ffmpeg_bin, file_path)
+
+        logging.debug(f"{media_info=}")
+
         if "error" in media_info:
-            return False, media_info["error"]
+            return (True, media_info["error"])
+
+        if media_info["format_long_name"] == "Tele-typewriter":
+            return (True, "Text file")
+
+        if media_info["duration"] > 0:
+            if " rel " in mode:
+                # convert to relative path (relative to BORIS project file)
+                file_path = str(pl.Path(file_path).relative_to(pl.Path(self.project_path).parent))
+
+            self.mediaDurations[file_path] = float(media_info["duration"])
+        elif media_info["has_video"] is False and media_info["audio_duration"]:
+            self.mediaDurations[file_path] = float(media_info["audio_duration"])
         else:
-            if media_info["duration"] > 0:
+            return (True, "Media duration not available")
 
-                if " rel " in mode:
-                    # convert to relative path (relative to BORIS project file)
-                    file_path = str(pl.Path(file_path).relative_to(pl.Path(self.project_path).parent))
-
-                self.mediaDurations[file_path] = float(media_info["duration"])
-                self.mediaFPS[file_path] = float(media_info["fps"])
-                self.mediaHasVideo[file_path] = media_info["has_video"]
-                self.mediaHasAudio[file_path] = media_info["has_audio"]
-                self.add_media_to_listview(file_path)
-                return (False, "")
-            else:
-                return (True, "Media duration not available")
+        self.mediaFPS[file_path] = float(media_info["fps"])
+        self.mediaHasVideo[file_path] = media_info["has_video"]
+        self.mediaHasAudio[file_path] = media_info["has_audio"]
+
+        logging.debug(f"{file_path=}")
+
+        self.add_media_to_listview(file_path)
+        return (False, "")
+
+    def update_media_options(self):
+        """
+        update the media options
+        """
+        for w in (
+            self.cbVisualizeSpectrogram,
+            self.cb_visualize_waveform,
+            self.cb_observation_time_interval,
+            self.cb_media_creation_date_as_offset,
+        ):
+            w.setEnabled(self.twVideo1.rowCount() > 0)
+
+        # enable stop ongoing state events if n. media > 1
+        self.cbCloseCurrentBehaviorsBetweenVideo.setEnabled(self.twVideo1.rowCount() > 0)
+
+        # self.creation_date_as_offset()
 
     def add_media(self, mode: str):
         """
@@ -966,9 +1323,7 @@ class Observation(QDialog, Ui_Form):
             QMessageBox.critical(
                 self,
                 cfg.programName,
-                (
-                    "It is not possible to add a media file without path or with a relative path if the project is not already saved"
-                ),
+                ("It is not possible to add a media file without path or with a relative path if the project is not already saved"),
             )
             return
 
@@ -979,9 +1334,9 @@ class Observation(QDialog, Ui_Form):
             fd.setDirectory(os.path.expanduser("~") if (" abs " in mode) else str(pl.Path(self.project_path).parent))
 
         if "media " in mode:
+            file_paths, _ = fd.getOpenFileNames(self, "Add media file(s)", "", "All files (*)")
 
-            fn = fd.getOpenFileNames(self, "Add media file(s)", "", "All files (*)")
-            file_paths = fn[0] if type(fn) is tuple else fn
+            logging.debug(f"{file_paths=}")
 
             if file_paths:
                 # store directory for next usage
@@ -1003,39 +1358,40 @@ class Observation(QDialog, Ui_Form):
                     if error:
                         QMessageBox.critical(self, cfg.programName, f"<b>{file_path}</b>. {msg}")
 
-        if "dir " in mode:
-
+        if "dir " in mode:  # add media from dir
             dir_name = fd.getExistingDirectory(self, "Select directory")
             if dir_name:
                 response = ""
-                for file_path in glob.glob(dir_name + os.sep + "*"):
-                    (error, msg) = self.check_media(file_path, mode)
+                for file_path in sorted(pl.Path(dir_name).glob("*")):
+                    if not file_path.is_file():
+                        continue
+                    (error, msg) = self.check_media(str(file_path), mode)
                     if error:
                         if response != "Skip all non media files":
                             response = dialog.MessageDialog(
                                 cfg.programName,
                                 f"<b>{file_path}</b> {msg}",
-                                ["Continue", "Skip all non media files", "Cancel"],
+                                ["Continue", "Skip all non media files", cfg.CANCEL],
                             )
-                            if response == "Cancel":
+                            if response == cfg.CANCEL:
                                 break
+                # ask to use directory name / path as observation id
+                if response != cfg.CANCEL:
+                    selected_obs_id = dialog.MessageDialog(
+                        cfg.programName,
+                        "Select the observation id",
+                        [dir_name, str(pl.Path(dir_name).name), cfg.CANCEL],
+                    )
+                    if selected_obs_id != cfg.CANCEL:
+                        self.leObservationId.setText(selected_obs_id)
 
-        for w in [
-            self.cbVisualizeSpectrogram,
-            self.cb_visualize_waveform,
-            self.cb_observation_time_interval,
-            self.cbCloseCurrentBehaviorsBetweenVideo,
-        ]:
-            w.setEnabled(self.twVideo1.rowCount() > 0)
-
-        # disabled for problems
-        self.cbCloseCurrentBehaviorsBetweenVideo.setEnabled(False)
+        self.update_media_options()
 
     def add_media_to_listview(self, file_name):
         """
         add media file path to list widget
         """
-
+        # add a row
         self.twVideo1.setRowCount(self.twVideo1.rowCount() + 1)
 
         for col_idx, s in enumerate(
@@ -1076,33 +1432,22 @@ class Observation(QDialog, Ui_Form):
         remove all selected media files from list widget
         """
 
-        if self.twVideo1.selectedIndexes():
-            rows_to_delete = set([x.row() for x in self.twVideo1.selectedIndexes()])
-            for row in sorted(rows_to_delete, reverse=True):
-                media_path = self.twVideo1.item(row, cfg.MEDIA_FILE_PATH_IDX).text()
-                self.twVideo1.removeRow(row)
-                if media_path not in [
-                    self.twVideo1.item(idx, cfg.MEDIA_FILE_PATH_IDX).text() for idx in range(self.twVideo1.rowCount())
-                ]:
-                    try:
-                        del self.mediaDurations[media_path]
-                    except NameError:
-                        pass
-                    try:
-                        del self.mediaFPS[media_path]
-                    except NameError:
-                        pass
-
-            for w in [
-                self.cbVisualizeSpectrogram,
-                self.cb_visualize_waveform,
-                self.cb_observation_time_interval,
-                self.cbCloseCurrentBehaviorsBetweenVideo,
-            ]:
-                w.setEnabled(self.twVideo1.rowCount() > 0)
+        if not self.twVideo1.selectedIndexes():
+            QMessageBox.warning(self, cfg.programName, "No media file selected")
+            return
 
-            # disabled for problems
-            self.cbCloseCurrentBehaviorsBetweenVideo.setEnabled(False)
+        rows_to_delete = set([x.row() for x in self.twVideo1.selectedIndexes()])
+        for row in sorted(rows_to_delete, reverse=True):
+            media_path = self.twVideo1.item(row, cfg.MEDIA_FILE_PATH_IDX).text()
+            self.twVideo1.removeRow(row)
+            if media_path not in [self.twVideo1.item(idx, cfg.MEDIA_FILE_PATH_IDX).text() for idx in range(self.twVideo1.rowCount())]:
+                try:
+                    del self.mediaDurations[media_path]
+                except NameError:
+                    pass
+                try:
+                    del self.mediaFPS[media_path]
+                except NameError:
+                    pass
 
-        else:
-            QMessageBox.warning(self, cfg.programName, "No media file selected")
+        self.update_media_options()