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

boris/utilities.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -19,32 +19,243 @@ Copyright 2012-2023 Olivier Friard
   MA 02110-1301, USA.
 """
 
-from cmath import isnan
+from decimal import Decimal as dec
+from decimal import getcontext, ROUND_DOWN
+from hachoir.metadata import extractMetadata
+from hachoir.parser import createParser
+from shutil import copyfile, which
+from typing import Union, Tuple
 import csv
 import datetime
-import hashlib
+import datetime as dt
+import exifread
 import json
 import logging
 import math
+import numpy as np
 import os
-import pathlib as pl
+from pathlib import Path
+from PIL.ImageQt import Image
+import platform
 import re
-import socket
+import shutil
 import subprocess
 import sys
 import urllib.parse
+import urllib.request
 import wave
-from decimal import Decimal as dec
-from decimal import getcontext, ROUND_DOWN
-from shutil import copyfile
-
-import numpy as np
-from PyQt5.QtGui import qRgb
-from PyQt5.QtGui import QPixmap, QImage
+import socket
 
-from PIL.ImageQt import Image
+from PySide6 import __version__ as pyside6_version
+from PySide6.QtGui import QPixmap, QImage
+from PySide6.QtCore import qVersion
 
 from . import config as cfg
+from . import version
+
+logger = logging.getLogger(__name__)
+
+if (sys.platform.startswith("win") or sys.platform.startswith("linux")) and ("-i" not in sys.argv) and ("--ipc" not in sys.argv):
+    try:
+        from . import mpv2 as mpv
+    except Exception:
+        logger.warning("MPV library not found")
+
+        if sys.platform.startswith("win"):
+            import ctypes
+
+            logger.info("The MPV library was not found!\nIt will be downloaded from the BORIS GitHub repository")
+            # ctypes.windll.user32.MessageBoxW(0, "The MPV library was not found!\nIt will be downloaded.", "BORIS", 0)
+
+            # test if following function works on windows
+            MessageBoxTimeoutW = ctypes.windll.user32.MessageBoxTimeoutW
+            MessageBoxTimeoutW.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_wchar_p, ctypes.c_uint, ctypes.c_uint, ctypes.c_uint]
+            ctypes.windll.user32.MessageBoxTimeoutW(
+                None, "The MPV library was not found.\nIt will be downloaded from the BORIS GitHub repository.", "MPV library", 0, 0, 10000
+            )  # time out
+
+            # download libmpv2.dll from https://github.com/boris-behav-obs/boris-behav-obs.github.io/releases/download/files/
+
+            url: str = "https://github.com/boris-behav-obs/boris-behav-obs.github.io/releases/download/files/"
+
+            external_files_dir = ""
+            # search where to download libmpv-2.dll
+
+            external_files_dir = Path(__file__).parent / "misc"
+            if not external_files_dir.is_dir():
+                logger.info(f"Creating {external_files_dir} directory")
+                external_files_dir.mkdir(parents=True, exist_ok=True)
+
+            logger.info(f"MPV library directory: {external_files_dir}")
+
+            local_filename = external_files_dir / "libmpv-2.dll"
+            logger.info("Downloading libmpv-2.dll...")
+            try:
+                urllib.request.urlretrieve(url + "libmpv-2.dll", local_filename)
+                logger.info(f"File downloaded as {local_filename}")
+            except Exception:
+                logger.critical("The MPV library can not be downloaded! Check your connection.")
+                ctypes.windll.user32.MessageBoxW(0, "The MPV library can not be downloaded!\nCheck your connection.", "BORIS", 0)
+                sys.exit(5)
+            # reload package
+            try:
+                from . import mpv2 as mpv
+            except Exception:
+                logger.critical("MPV library not found after dowloading")
+                sys.exit(5)
+
+        elif sys.platform.startswith("linux"):
+            text = (
+                "The MPV library was not found!\nInstall it\n\n"
+                "With Debian/Ubuntu/Mint:\nsudo apt install libmpv2\n\n"
+                "With Fedora:\nsudo dnf install mpv-libs\n\n"
+                "With OpenSUSE:\nsudo zypper install mpv\n\n"
+                "Arch Linux / Manjaro:\nsudo pacman -S mpv\n\n"
+            )
+            if shutil.which("zenity") is not None:
+                subprocess.run(["zenity", "--error", f"--text={text}"])
+            elif shutil.which("kdialog"):
+                subprocess.run(["kdialog", "--msgbox", text])
+            elif shutil.which("gxmessage"):
+                subprocess.run(["gxmessage", text])
+            elif shutil.which("xmessage"):
+                subprocess.run(["xmessage", text])
+
+            sys.exit(5)
+        else:
+            sys.exit(5)
+
+
+def test_mpv_ipc(socket_path: str = cfg.MPV_SOCKET) -> bool:
+    """
+    test if socket available
+    """
+    if not os.path.exists(socket_path):
+        return False
+
+    try:
+        client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        client.connect(socket_path)
+        client.close()
+        return True
+    except Exception:
+        return False
+
+
+def extract_exif_DateTimeOriginal(file_path: str) -> int:
+    """
+    extract the EXIF DateTimeOriginal tag
+    return epoch time
+    if the tag is not available return -1
+
+    Args:
+        file_path (str): path of the media file
+
+    Returns:
+        int: timestamp
+
+    """
+    try:
+        with open(file_path, "rb") as f_in:
+            tags = exifread.process_file(f_in, details=False, stop_tag="EXIF DateTimeOriginal")
+            if "EXIF DateTimeOriginal" in tags:
+                date_time_original = (
+                    f"{tags['EXIF DateTimeOriginal'].values[:4]}-"
+                    f"{tags['EXIF DateTimeOriginal'].values[5:7]}-"
+                    f"{tags['EXIF DateTimeOriginal'].values[8:10]} "
+                    f"{tags['EXIF DateTimeOriginal'].values.split(' ')[-1]}"
+                )
+                return int(datetime.datetime.strptime(date_time_original, "%Y-%m-%d %H:%M:%S").timestamp())
+            else:
+                try:
+                    # read from file name (YYYY-MM-DD_HHMMSS)
+                    return int(datetime.datetime.strptime(Path(file_path).stem, "%Y-%m-%d_%H%M%S").timestamp())
+                except Exception:
+                    # read from file name (YYYY-MM-DD_HH:MM:SS)
+                    return int(datetime.datetime.strptime(Path(file_path).stem, "%Y-%m-%d_%H:%M:%S").timestamp())
+
+    except Exception:
+        return -1
+
+
+def extract_video_creation_date(file_path: str) -> int | None:
+    """
+    returns the timestamp of the media creation date time with Hachoir
+    """
+
+    logger.debug(f"extract_video_creation_date for {file_path}")
+
+    if not Path(file_path).is_file():
+        logger.debug(f"{file_path} not found")
+        return None
+    try:
+        parser = createParser(file_path)
+        metadata = extractMetadata(parser)
+    except Exception:
+        return None
+
+    if metadata.has("creation_date"):
+        if metadata.get("creation_date") == datetime.datetime(1904, 1, 1, 0, 0):
+            return None
+        return metadata.get("creation_date").timestamp()
+    else:
+        return None
+
+
+def extract_date_time_from_file_name(file_path: str) -> int | None:
+    """
+    extract YYYY-MM-DD_HHMMSS or YYYY-MM-DD_HH:MM:SS from file name
+    """
+
+    patterns = (r"\d{4}-\d{2}-\d{2}_\d{6}", r"\d{4}-\d{2}-\d{2}_\d{2}:\d{2}:\d{2}")
+    for pattern in patterns:
+        matches = re.findall(pattern, file_path)
+
+        if matches:
+            if pattern == r"\d{4}-\d{2}-\d{2}_\d{6}":
+                logger.debug(
+                    f"extract_date_time_from_file_name timestamp from {file_path}: {int(datetime.datetime.strptime(matches[0], '%Y-%m-%d_%H%M%S').timestamp())}"
+                )
+
+                return int(datetime.datetime.strptime(matches[0], "%Y-%m-%d_%H%M%S").timestamp())
+
+            if pattern == r"\d{4}-\d{2}-\d{2}_\d{2}:\d{2}:\d{2}":
+                logger.debug(
+                    f"extract_date_time_from_file_name timestamp from {file_path}: {int(datetime.datetime.strptime(matches[0], '%Y-%m-%d_%H:%M:%S').timestamp())}"
+                )
+
+                return int(datetime.datetime.strptime(matches[0], "%Y-%m-%d_%H:%M:%S").timestamp())
+
+    return None
+
+
+def mpv_lib_version() -> Tuple[str, str, str]:
+    """
+    Version of MPV library
+
+    Returns:
+        str: MPV library version
+    """
+    if ("-i" in sys.argv) or ("--ipc" in sys.argv) or sys.platform.startswith("darwin"):
+        return "MPV IPC mode", "", ""
+
+    mpv_lib_file = None
+    if sys.platform.startswith("linux"):
+        mpv_lib_file = mpv.sofile
+    if sys.platform.startswith("win"):
+        mpv_lib_file = mpv.dll
+
+    return (".".join([str(x) for x in mpv._mpv_client_api_version()]), mpv_lib_file, mpv.MPV_VERSION)
+
+
+def python_mpv_script_version() -> str:
+    """
+    version of python-mpv script
+    """
+    try:
+        return mpv.__version__
+    except Exception:
+        return "Not found"
 
 
 def error_info(exc_info: tuple) -> tuple:
@@ -65,13 +276,12 @@ def error_info(exc_info: tuple) -> tuple:
     return (f"{exc_type}: {exc_obj}", fname, exc_tb.tb_lineno)
 
 
-def pil2pixmap(im) -> QPixmap:
+def pil2pixmap(im: Image) -> QPixmap:
     """
     convert PIL image to pixmap
     see https://stackoverflow.com/questions/34697559/pil-image-to-qpixmap-conversion-issue
     """
 
-    # print(im.mode)
     if im.mode == "RGB":
         r, g, b = im.split()
         im = Image.merge("RGB", (b, g, r))
@@ -117,7 +327,7 @@ def return_file_header(file_name: str, row_number: int = 5) -> list:
     Returns:
         list: first row_number row(s) of file_name
     """
-    header = []
+    header: list = []
     try:
         with open(file_name) as f_in:
             for _ in range(row_number):
@@ -127,28 +337,36 @@ def return_file_header(file_name: str, row_number: int = 5) -> list:
     return header
 
 
-def bytes_to_str(b: bytes) -> str:
+def return_file_header_footer(file_name: str, file_row_number: int = 0, row_number: int = 5) -> Tuple[list, list]:
     """
-    Translate bytes to string.
+    return file header and footer
 
     Args:
-        b (bytes): byte to convert
+        file_name (str): path of file
+        file_row_number (int): total rows number of file
+        row_number (int): number of rows to return
 
     Returns:
-        str: converted byte
+        list: first row_number row(s) of file_name
     """
+    header: list = []
+    footer: list = []
+    try:
+        row_idx: int = 0
+        with open(file_name, "rt") as f_in:
+            for row in f_in:
+                if row_idx < row_number:
+                    header.append(row.strip())
+                if file_row_number > row_number * 2 and (row_idx >= file_row_number - row_number):
+                    footer.append(row.strip())
+                row_idx += 1
 
-    if isinstance(b, bytes):
-        fileSystemEncoding = sys.getfilesystemencoding()
-        # hack for PyInstaller
-        if fileSystemEncoding is None:
-            fileSystemEncoding = "UTF-8"
-        return b.decode(fileSystemEncoding)
-    else:
-        return b
+    except Exception:
+        return [], []
+    return header, footer
 
 
-def convertTime(time_format: str, sec: float) -> str:
+def convertTime(time_format: str, sec: Union[float, dec]) -> Union[str, None]:
     """
     convert time in base at the current format (S or HHMMSS)
 
@@ -171,6 +389,20 @@ def convertTime(time_format: str, sec: float) -> str:
     return None
 
 
+def smart_time_format(sec: Union[float, dec], time_format: str = cfg.S, cutoff: dec = cfg.SMART_TIME_CUTOFF_DEFAULT) -> str:
+    """
+    Smart time format
+    returns time in seconds if <= cutoff else in HH:MM:SS.ZZZ format
+    """
+    # cutoff = 0 follows the time format selectd by user
+    if cutoff == 0:
+        return convertTime(time_format, sec)
+    if sec <= cutoff:
+        return f"{sec:.3f}"
+    else:
+        return seconds2time(sec)
+
+
 def convert_time_to_decimal(pj: dict) -> dict:
     """
     convert time of project from float to decimal
@@ -183,7 +415,10 @@ def convert_time_to_decimal(pj: dict) -> dict:
     """
     for obs_id in pj[cfg.OBSERVATIONS]:
         if cfg.TIME_OFFSET in pj[cfg.OBSERVATIONS][obs_id]:
-            pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET] = dec(str(pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET]))
+            if pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET] is not None:
+                pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET] = dec(str(pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET]))
+            else:
+                pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET] = dec("0.000")
         for idx, _ in enumerate(pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]):
             pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS][idx][cfg.EVENT_TIME_FIELD_IDX] = dec(
                 pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS][idx][cfg.EVENT_TIME_FIELD_IDX]
@@ -192,23 +427,18 @@ def convert_time_to_decimal(pj: dict) -> dict:
     return pj
 
 
-def file_content_md5(file_name: str) -> str:
+def count_media_file(media_files: dict) -> int:
     """
-    returns the MD5 sum of file content
+    count number of media file for observation
     """
-    hash_md5 = hashlib.md5()
-    try:
-        with open(file_name, "rb") as f:
-            for chunk in iter(lambda: f.read(4096), b""):
-                hash_md5.update(chunk)
-        return hash_md5.hexdigest()
-    except FileNotFoundError:
-        return ""
+    return sum([len(media_files[idx]) for idx in media_files])
 
 
-def txt2np_array(file_name: str, columns_str: str, substract_first_value: str, converters=None, column_converter=None):
+def txt2np_array(
+    file_name: str, columns_str: str, substract_first_value: str, converters=None, column_converter=None
+) -> Tuple[bool, str, np.array]:
     """
-    read a txt file (tsv or csv) and return np array with passed columns
+    read a txt file (tsv or csv) and return a np array with columns cited in columns_str
 
     Args:
         file_name (str): path of the file to load in numpy array
@@ -235,42 +465,66 @@ def txt2np_array(file_name: str, columns_str: str, substract_first_value: str, c
         return False, f"Problem with columns {columns_str}", np.array([])
 
     # check converters
-    np_converters = {}
+    np_converters: dict = {}
     for column_idx in column_converter:
         if column_converter[column_idx] in converters:
-
             conv_name = column_converter[column_idx]
 
             function = f"""def {conv_name}(INPUT):\n"""
-            function += """    INPUT = INPUT.decode("utf-8") if isinstance(INPUT, bytes) else INPUT"""
+            function += """    INPUT = INPUT.decode("utf-8") if isinstance(INPUT, bytes) else INPUT\n\n"""
             for line in converters[conv_name]["code"].split("\n"):
                 function += f"    {line}\n"
             function += """    return OUTPUT"""
 
+            print("=============")
+            print(function)
+            print("=============")
+
+            import types
+
+            mod = types.ModuleType("converter_module")
+            exec(function, mod.__dict__)
+
+            """
             try:
                 exec(function)
             except Exception:
                 return False, f"error in converter: {sys.exc_info()[1]}", np.array([])
 
-            np_converters[column_idx - 1] = locals()[conv_name]
+            print(f"{converters=}")
+            print(f"{column_converter=}")
+            print(locals())
+            print(f"{conv_name=}")
+            """
+
+            # np_converters[column_idx - 1] = locals()['conv_name']
+            np_converters[column_idx - 1] = getattr(mod, conv_name)
 
         else:
-            return False, f"converter {cfg.converters_param[column_idx]} not found", np.array([])
+            return False, f"converter {column_converter[column_idx]} not found", np.array([])
 
     # snif txt file
     try:
         with open(file_name) as csvfile:
-            buff = csvfile.read(1024)
+            buff = csvfile.read(4096)
             snif = csv.Sniffer()
             dialect = snif.sniff(buff)
-            has_header = snif.has_header(buff)
+            """has_header = snif.has_header(buff)"""
+        # count number of header rows
+        header_rows_nb = 0
+        csv.register_dialect("dialect", dialect)
+        with open(file_name, "r") as f:
+            reader = csv.reader(f, dialect="dialect")
+            for row in reader:
+                if sum([isinstance(intfloatstr(x), str) for x in row]) == len(row):
+                    header_rows_nb += 1
+
     except Exception:
         return False, f"{sys.exc_info()[1]}", np.array([])
 
     try:
-        data = np.loadtxt(
-            file_name, delimiter=dialect.delimiter, usecols=columns, skiprows=has_header, converters=np_converters
-        )
+        data = np.loadtxt(file_name, delimiter=dialect.delimiter, usecols=columns, skiprows=header_rows_nb, converters=np_converters)
+
     except Exception:
         return False, f"{sys.exc_info()[1]}", np.array([])
 
@@ -281,7 +535,7 @@ def txt2np_array(file_name: str, columns_str: str, substract_first_value: str, c
     return True, "", data
 
 
-def versiontuple(version_str: str):
+def versiontuple(version_str: str) -> tuple:
     """
     Convert version from str to tuple of str
 
@@ -297,9 +551,34 @@ def versiontuple(version_str: str):
     return tuple(filled)
 
 
+def behavior_user_color(ethogram: dict, behavior_code: str) -> Union[str, None]:
+    """
+    returns the color of behavior if defined else None
+    """
+    for x in ethogram:
+        if ethogram[x][cfg.BEHAVIOR_CODE] == behavior_code:
+            if ethogram[x].get(cfg.COLOR, None) == "":
+                return None
+            else:
+                return ethogram[x].get(cfg.COLOR, None)
+
+    return None
+
+
+def behav_category_user_color(behavioral_categories: dict, name: str) -> Union[str, None]:
+    """
+    returns the color of the behavioral category if defined else None
+    """
+    for key in behavioral_categories:
+        if behavioral_categories[key]["name"] == name:
+            return behavioral_categories[key].get(cfg.COLOR, None)
+
+    return None
+
+
 def state_behavior_codes(ethogram: dict) -> list:
     """
-    behavior codes defined as STATE event
+    returns a list of behavior codes defined as STATE event
 
     Args:
         ethogram (dict): ethogram dictionary
@@ -308,12 +587,12 @@ def state_behavior_codes(ethogram: dict) -> list:
         list: list of behavior codes defined as STATE event
 
     """
-    return [ethogram[x][cfg.BEHAVIOR_CODE] for x in ethogram if cfg.STATE in ethogram[x][cfg.TYPE].upper()]
+    return [ethogram[x][cfg.BEHAVIOR_CODE] for x in ethogram if ethogram[x][cfg.TYPE] in cfg.STATE_EVENT_TYPES]
 
 
 def point_behavior_codes(ethogram: dict) -> list:
     """
-    behavior codes defined as POINT event
+    returns a list of behavior codes defined as POINT event
 
     Args:
         ethogram (dict): ethogram dictionary
@@ -322,7 +601,7 @@ def point_behavior_codes(ethogram: dict) -> list:
         list: list of behavior codes defined as POINT event
 
     """
-    return [ethogram[x][cfg.BEHAVIOR_CODE] for x in ethogram if cfg.POINT in ethogram[x][cfg.TYPE].upper()]
+    return [ethogram[x][cfg.BEHAVIOR_CODE] for x in ethogram if ethogram[x][cfg.TYPE] in (cfg.POINT_EVENT, cfg.POINT_EVENT_WITH_CODING_MAP)]
 
 
 def group_events(pj: dict, obs_id: str, include_modifiers: bool = False) -> dict:
@@ -347,7 +626,6 @@ def group_events(pj: dict, obs_id: str, include_modifiers: bool = False) -> dict
         intervals_behav = {}
 
         for event in pj[cfg.OBSERVATIONS][obs_id][cfg.EVENTS]:
-
             time_ = event[cfg.EVENT_TIME_FIELD_IDX]
             subject = event[cfg.EVENT_SUBJECT_FIELD_IDX]
             code = event[cfg.EVENT_BEHAVIOR_FIELD_IDX]
@@ -355,9 +633,7 @@ def group_events(pj: dict, obs_id: str, include_modifiers: bool = False) -> dict
 
             # check if code is state
             if code in state_events_list:
-
                 if (subject, code, modifier) in mem_behav and mem_behav[(subject, code, modifier)]:
-
                     if (subject, code, modifier) not in intervals_behav:
                         intervals_behav[(subject, code, modifier)] = []
                     intervals_behav[(subject, code, modifier)].append((mem_behav[(subject, code, modifier)], time_))
@@ -378,8 +654,21 @@ def group_events(pj: dict, obs_id: str, include_modifiers: bool = False) -> dict
         return {"error": ""}
 
 
+def flatten_list(nested_list) -> list:
+    """
+    Flatten a list of lists.
+    """
+    flattened: list = []
+    for item in nested_list:
+        if isinstance(item, list):
+            flattened.extend(flatten_list(item))
+        else:
+            flattened.append(item)
+    return flattened
+
+
 def get_current_states_modifiers_by_subject(
-    state_behaviors_codes: list, events: list, subjects: dict, time: dec, include_modifiers: bool = False
+    state_behaviors_codes: list, events: list, subjects: dict, time_: dec, include_modifiers: bool = False
 ) -> dict:
     """
     get current states and modifiers (if requested) for subjects at given time
@@ -394,57 +683,59 @@ def get_current_states_modifiers_by_subject(
     Returns:
         dict: current states by subject. dict of list
     """
-    current_states = {}
-    if time.is_nan():
+    current_states: dict = {}
+    if time_.is_nan():
         for idx in subjects:
             current_states[idx] = []
         return current_states
 
     # check if time contains NA
-    if [x for x in events if events[cfg.EVENT_TIME_FIELD_IDX][cfg.EVENT_TIME_FIELD_IDX].is_nan()]:
-        check_index = cfg.PJ_OBS_FIELDS[cfg.IMAGES]["image index"]
+    if [x for x in events if x[cfg.EVENT_TIME_FIELD_IDX].is_nan()]:
+        check_index = cfg.PJ_OBS_FIELDS[cfg.IMAGES][cfg.IMAGE_INDEX]
     else:
         check_index = cfg.EVENT_TIME_FIELD_IDX
 
     if include_modifiers:
         for idx in subjects:
-            current_states[idx] = []
-            for sbc in state_behaviors_codes:
-                bl = [
+            current_states[subjects[idx]["name"]] = {}
+        for x in events:
+            if x[check_index] > time_:
+                break
+            if x[cfg.EVENT_BEHAVIOR_FIELD_IDX] in state_behaviors_codes:
+                if (x[cfg.EVENT_BEHAVIOR_FIELD_IDX], x[cfg.EVENT_MODIFIER_FIELD_IDX]) not in current_states[x[cfg.EVENT_SUBJECT_FIELD_IDX]]:
+                    current_states[x[cfg.EVENT_SUBJECT_FIELD_IDX]][(x[cfg.EVENT_BEHAVIOR_FIELD_IDX], x[cfg.EVENT_MODIFIER_FIELD_IDX])] = (
+                        False
+                    )
+
+                current_states[x[cfg.EVENT_SUBJECT_FIELD_IDX]][
                     (x[cfg.EVENT_BEHAVIOR_FIELD_IDX], x[cfg.EVENT_MODIFIER_FIELD_IDX])
-                    for x in events
-                    if x[cfg.EVENT_SUBJECT_FIELD_IDX] == subjects[idx][cfg.SUBJECT_NAME]
-                    and x[cfg.EVENT_BEHAVIOR_FIELD_IDX] == sbc
-                    and x[check_index] <= time
-                ]
+                ] = not current_states[x[cfg.EVENT_SUBJECT_FIELD_IDX]][(x[cfg.EVENT_BEHAVIOR_FIELD_IDX], x[cfg.EVENT_MODIFIER_FIELD_IDX])]
 
-                if len(bl) % 2:  # test if odd
-                    current_states[idx].append(bl[-1][0] + f" ({bl[-1][1]})" * (bl[-1][1] != ""))
+        r: dict = {}
+        for idx in subjects:
+            r[idx] = [f"{bm[0]} ({bm[1]})" for bm in current_states[subjects[idx]["name"]] if current_states[subjects[idx]["name"]][bm]]
 
     else:
         for idx in subjects:
-            current_states[idx] = []
-            for sbc in state_behaviors_codes:
-                if (
-                    len(
-                        [
-                            x[cfg.EVENT_BEHAVIOR_FIELD_IDX]
-                            for x in events
-                            if x[cfg.EVENT_SUBJECT_FIELD_IDX] == subjects[idx][cfg.SUBJECT_NAME]
-                            and x[cfg.EVENT_BEHAVIOR_FIELD_IDX] == sbc
-                            and x[check_index] <= time
-                        ]
-                    )
-                    % 2
-                ):  # test if odd
-                    current_states[idx].append(sbc)
+            current_states[subjects[idx]["name"]] = {}
+            for b in state_behaviors_codes:
+                current_states[subjects[idx]["name"]][b] = False
+        for x in events:
+            if x[check_index] > time_:
+                break
+            if x[cfg.EVENT_BEHAVIOR_FIELD_IDX] in state_behaviors_codes:
+                current_states[x[cfg.EVENT_SUBJECT_FIELD_IDX]][x[cfg.EVENT_BEHAVIOR_FIELD_IDX]] = not current_states[
+                    x[cfg.EVENT_SUBJECT_FIELD_IDX]
+                ][x[cfg.EVENT_BEHAVIOR_FIELD_IDX]]
+
+        r: dict = {}
+        for idx in subjects:
+            r[idx] = [b for b in state_behaviors_codes if current_states[subjects[idx]["name"]][b]]
 
-    return current_states
+    return r
 
 
-def get_current_states_modifiers_by_subject_2(
-    state_behaviors_codes: list, events: list, subjects: dict, time: dec
-) -> dict:
+def get_current_states_modifiers_by_subject_2(state_behaviors_codes: list, events: list, subjects: dict, time: dec) -> dict:
     """
     get current states and modifiers for subjects at given time
     differs from get_current_states_modifiers_by_subject in the output format: [behavior, modifiers]
@@ -454,7 +745,6 @@ def get_current_states_modifiers_by_subject_2(
         events (list): list of events
         subjects (dict): dictionary of subjects
         time (Decimal): time
-        include_modifiers (bool): include modifier if True (default: False)
 
     Returns:
         dict: current states by subject. dict of list
@@ -508,7 +798,8 @@ def get_current_points_by_subject(
             point_events = [
                 (x[cfg.EVENT_BEHAVIOR_FIELD_IDX], x[cfg.EVENT_MODIFIER_FIELD_IDX])
                 for x in events
-                if x[cfg.EVENT_SUBJECT_FIELD_IDX] == subjects[idx]["name"] and x[cfg.EVENT_BEHAVIOR_FIELD_IDX] == sbc
+                if x[cfg.EVENT_SUBJECT_FIELD_IDX] == subjects[idx]["name"]
+                and x[cfg.EVENT_BEHAVIOR_FIELD_IDX] == sbc
                 # and abs(x[EVENT_TIME_FIELD_IDX] - time) <= tolerance
                 and time <= x[cfg.EVENT_TIME_FIELD_IDX] < (time + tolerance)
             ]
@@ -525,19 +816,6 @@ def get_current_points_by_subject(
     return current_points
 
 
-def get_ip_address():
-    """Get current IP address
-
-    Args:
-
-    Returns:
-        str: IP address
-    """
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    s.connect(("8.8.8.8", 80))
-    return s.getsockname()[0]
-
-
 def check_txt_file(file_name: str) -> dict:
     """
     Extract parameters of txt file (test for tsv csv)
@@ -554,35 +832,43 @@ def check_txt_file(file_name: str) -> dict:
     try:
         # snif txt file
         with open(file_name) as csvfile:
-            buff = csvfile.read(1024)
+            buff = csvfile.read(4096)
             snif = csv.Sniffer()
             dialect = snif.sniff(buff)
             has_header = snif.has_header(buff)
 
         csv.register_dialect("dialect", dialect)
-        rows_len = []
+        rows_len: list = []
         with open(file_name, "r") as f:
             reader = csv.reader(f, dialect="dialect")
             for row in reader:
-
                 if not row:
                     continue
+                """
                 if len(row) not in rows_len:
                     rows_len.append(len(row))
                     if len(rows_len) > 1:
                         break
+                """
+                rows_len.append(len(row))
+
+        rows_number = len(rows_len)
+        rows_uniq_len = set(rows_len)
 
         # test if file empty
-        if not len(rows_len):
+        if not rows_uniq_len:
             return {"error": "The file is empty"}
 
-        if len(rows_len) == 1 and rows_len[0] >= 2:
-            return {"homogeneous": True, "fields number": rows_len[0], "separator": dialect.delimiter}
-
-        if len(rows_len) > 1:
-            return {"homogeneous": False}
+        if len(rows_uniq_len) == 1:
+            return {
+                "homogeneous": True,
+                "fields number": rows_len[0],
+                "separator": dialect.delimiter,
+                "rows number": rows_number,
+                "has header": has_header,
+            }
         else:
-            return {"homogeneous": True, "fields number": rows_len[0], "separator": dialect.delimiter}
+            return {"homogeneous": False}
     except Exception:
         return {"error": str(sys.exc_info()[1])}
 
@@ -599,15 +885,15 @@ def extract_wav(ffmpeg_bin: str, media_file_path: str, tmp_dir: str) -> str:
         str: wav file path or "" if error
     """
 
-    wav_file_path = pl.Path(tmp_dir) / pl.Path(media_file_path + ".wav").name
+    wav_file_path = Path(tmp_dir) / Path(media_file_path + ".wav").name
 
     # check if media file is a wav file
     try:
         wav = wave.open(media_file_path, "r")
         wav.close()
-        logging.debug(f"{media_file_path} is a WAV file. Copying in the temp directory...")
+        logger.debug(f"{media_file_path} is a WAV file. Copying in the temp directory...")
         copyfile(media_file_path, wav_file_path)
-        logging.debug(f"{media_file_path} copied in {wav_file_path}")
+        logger.debug(f"{media_file_path} copied in {wav_file_path}")
         return str(wav_file_path)
     except Exception:
         if wav_file_path.is_file():
@@ -622,7 +908,7 @@ def extract_wav(ffmpeg_bin: str, media_file_path: str, tmp_dir: str) -> str:
         )
         out, error = p.communicate()
         out, error = out.decode("utf-8"), error.decode("utf-8")
-        logging.debug(f"{out}, {error}")
+        logger.debug(f"{out}, {error}")
 
         if "does not contain any stream" not in error:
             if wav_file_path.is_file():
@@ -638,40 +924,46 @@ def decimal_default(obj):
     raise TypeError
 
 
-def complete(l: list, max_: int) -> list:
+def complete(lst: list, max_: int) -> list:
     """
     complete list with empty string ("") until len = max
 
     Args:
-        l (list): list to complete
+        lst (list): list to complete
         max_ (int): number of items to reach
 
     Returns:
         list: list completed to max_ items with empty string ("")
     """
-    while len(l) < max_:
-        l.append("")
-    # l.extend([""] * (max_ - len(l)))
-    return l
+    while len(lst) < max_:
+        lst.append("")
+    return lst
 
 
 def datetime_iso8601(dt) -> str:
     """
-    current date time in ISO8601 format without milliseconds
+    current date time in ISO8601 format without microseconds
     example: 2019-06-13 10:01:02
 
     Returns:
-        str: date time in ISO8601 format
+        str: date time in ISO8601 format without microseconds
     """
-    return dt.isoformat(" ").split(".")[0]
+    return dt.isoformat(sep=" ", timespec="seconds")
 
 
-def seconds_of_day(dt) -> dec:
+def seconds_of_day(timestamp: dt.datetime) -> dec:
     """
     return the number of seconds since start of the day
+
+    Returns:
+        dev: number of seconds since the start of the day
     """
 
-    return dec((dt - datetime.datetime.combine(dt.date(), datetime.time(0))).total_seconds()).quantize(dec("0.001"))
+    # logger.debug("function: seconds_of_day")
+    # logger.debug(f"{timestamp = }")
+
+    t = timestamp.time()
+    return dec(t.hour * 3600 + t.minute * 60 + t.second + t.microsecond / 1000000).quantize(dec("0.001"))
 
 
 def sorted_keys(d: dict) -> list:
@@ -701,7 +993,7 @@ def intfloatstr(s: str) -> int:
             return s
 
 
-def distance(p1, p2):
+def distance(p1: tuple, p2: tuple) -> float:
     """
     euclidean distance between 2 points
     """
@@ -733,6 +1025,62 @@ def angle(vertex: tuple, side1: tuple, side2: tuple) -> float:
     )
 
 
+def oriented_angle(P1: tuple, P2: tuple, P3: tuple) -> float:
+    """
+    Calculate the oriented angle between two segments.
+
+    Args:
+        P1 (tuple): Coordinates of the vertex
+        P2 (tuple): Coordinates of the first point
+        P3 (tuple): Coordinates of the second point
+
+    Returns:
+        float: The oriented angle between the two segments in degrees.
+    """
+
+    x1, y1 = P1
+    x2, y2 = P2
+    x3, y3 = P1
+    x4, y4 = P3
+
+    angle_AB = math.atan2(y2 - y1, x2 - x1)
+    angle_CD = math.atan2(y4 - y3, x4 - x3)
+
+    oriented_angle = math.degrees(angle_AB - angle_CD)
+
+    return oriented_angle
+
+
+def oriented_angle_trigo(B: Tuple[float, float], A: Tuple[float, float], C: Tuple[float, float]) -> float:
+    """
+    Calculates the oriented angle between vectors BA and BC, in degrees.
+    The angle is positive in the counter-clockwise (trigonometric) direction.
+
+    Parameters:
+        B: The pivot point (the origin of the vectors BA and BC).
+        A, C: Points that define the vectors.
+
+    Returns:
+        Angle in degrees, between 0 and 360.
+    """
+    # Vectors BA and BC
+    v1 = (A[0] - B[0], A[1] - B[1])
+    v2 = (C[0] - B[0], C[1] - B[1])
+
+    # Dot product and 2D cross product (determinant)
+    dot = v1[0] * v2[0] + v1[1] * v2[1]
+    det = v1[0] * v2[1] - v1[1] * v2[0]
+
+    # Signed angle in radians, then converted to degrees
+    angle_rad = math.atan2(det, dot)
+    angle_deg = math.degrees(angle_rad)
+
+    if angle_deg < 0:
+        angle_deg += 360
+
+    return angle_deg
+
+
 def mem_info():
     """
     get info about total mem, used mem and available mem using:
@@ -750,9 +1098,7 @@ def mem_info():
             process = subprocess.run(["free", "-m"], stdout=subprocess.PIPE)
             # out, err = process.communicate()
             out = process.stdout
-            _, tot_mem, used_mem, _, _, _, available_mem = [
-                x.decode("utf-8") for x in out.split(b"\n")[1].split(b" ") if x != b""
-            ]
+            _, tot_mem, used_mem, _, _, _, available_mem = [x.decode("utf-8") for x in out.split(b"\n")[1].split(b" ") if x != b""]
             return False, {
                 "total_memory": int(tot_mem),
                 "used_memory": int(used_mem),
@@ -771,11 +1117,8 @@ def mem_info():
             return True, {"msg": error_info(sys.exc_info())[0]}
 
     if sys.platform.startswith("win"):
-
         try:
-            output = subprocess.run(
-                ["wmic", "computersystem", "get", "TotalPhysicalMemory", "/", "Value"], stdout=subprocess.PIPE
-            )
+            output = subprocess.run(["wmic", "computersystem", "get", "TotalPhysicalMemory", "/", "Value"], stdout=subprocess.PIPE)
             tot_mem = int(output.stdout.strip().split(b"=")[-1].decode("utf-8")) / 1024 / 1024
 
             output = subprocess.run(["wmic", "OS", "get", "FreePhysicalMemory", "/", "Value"], stdout=subprocess.PIPE)
@@ -788,7 +1131,7 @@ def mem_info():
     return True, {"msg": "Unknown operating system"}
 
 
-def polygon_area(poly):
+def polygon_area(poly: list) -> float:
     """
     area of polygon
     from http://www.mathopenref.com/coordpolygonarea.html
@@ -803,7 +1146,20 @@ def polygon_area(poly):
     return abs(tot / 2)
 
 
-def url2path(url):
+def polyline_length(poly: list) -> float:
+    """
+    length of polyline
+    """
+    tot = 0
+    for p in range(1, len(poly)):
+        x1, y1 = poly[p - 1]
+        x2, y2 = poly[p]
+        tot += ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
+
+    return tot
+
+
+def url2path(url: str) -> str:
     """
     convert URL in local path name
     under windows, check if path name begin with /
@@ -834,14 +1190,20 @@ def time2seconds(time_: str) -> dec:
         Decimal: time in seconds
     """
 
-    try:
-        flag_neg = "-" in time_
-        time_ = time_.replace("-", "")
-        tsplit = time_.split(":")
-        h, m, s = int(tsplit[0]), int(tsplit[1]), dec(tsplit[2])
-        return dec(-(h * 3600 + m * 60 + s)) if flag_neg else dec(h * 3600 + m * 60 + s)
-    except Exception:
-        return dec("0.000")
+    if " " in time_:
+        try:
+            return dec(str(dt.datetime.strptime(time_, "%Y-%m-%d %H:%M:%S.%f").timestamp()))
+        except Exception:
+            return dec("0.000")
+    else:
+        try:
+            flag_neg = "-" in time_
+            time_ = time_.replace("-", "")
+            tsplit = time_.split(":")
+            h, m, s = int(tsplit[0]), int(tsplit[1]), dec(tsplit[2])
+            return dec(-(h * 3600 + m * 60 + s)) if flag_neg else dec(h * 3600 + m * 60 + s)
+        except Exception:
+            return dec("0.000")
 
 
 def seconds2time(sec: dec) -> str:
@@ -855,10 +1217,11 @@ def seconds2time(sec: dec) -> str:
     """
 
     if math.isnan(sec):
-        return "NA"
+        return cfg.NA
 
-    if sec > 1_600_000_000:  # epoch time
-        t = datetime.datetime.fromtimestamp(float(sec))
+    # if sec > one day treat as date
+    if sec > cfg.DATE_CUTOFF:
+        t = dt.datetime.fromtimestamp(float(sec))
         return f"{t:%Y-%m-%d %H:%M:%S}.{t.microsecond / 1000:03.0f}"
 
     neg_sign = "-" * (sec < 0)
@@ -917,7 +1280,7 @@ def eol2space(s: str) -> str:
     return s.replace("\r\n", " ").replace("\n", " ").replace("\r", " ")
 
 
-def test_ffmpeg_path(FFmpegPath):
+def test_ffmpeg_path(FFmpegPath: str) -> Tuple[bool, str]:
     """
     test if ffmpeg has valid path
 
@@ -929,22 +1292,20 @@ def test_ffmpeg_path(FFmpegPath):
         str: message
     """
 
-    out, error = subprocess.Popen(
-        f'"{FFmpegPath}" -version', stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
-    ).communicate()
-    logging.debug(f"test ffmpeg path output: {out}")
-    logging.debug(f"test ffmpeg path error: {error}")
+    out, error = subprocess.Popen(f'"{FFmpegPath}" -version', stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True).communicate()
+    logger.debug(f"test ffmpeg path output: {out}")
+    logger.debug(f"test ffmpeg path error: {error}")
 
     if (b"avconv" in out) or (b"the Libav developers" in error):
         return False, "Please use FFmpeg from https://www.ffmpeg.org in place of FFmpeg from Libav project."
 
     if (b"ffmpeg version" not in out) and (b"ffmpeg version" not in error):
-        return False, "FFmpeg is required but it was not found...<br>See https://www.ffmpeg.org"
+        return False, "FFmpeg is required but it was not found.<br>See https://www.ffmpeg.org"
 
     return True, ""
 
 
-def check_ffmpeg_path():
+def check_ffmpeg_path() -> Tuple[bool, str]:
     """
     check for ffmpeg path
     firstly search for embedded version
@@ -955,45 +1316,110 @@ def check_ffmpeg_path():
         str: if bool True returns ffmpegpath else returns error message
     """
 
+    # search embedded ffmpeg
     if sys.platform.startswith("linux") or sys.platform.startswith("darwin"):
+        ffmpeg_executable = Path("ffmpeg")
+    elif sys.platform.startswith("win"):
+        ffmpeg_executable = Path("ffmpeg.exe")
 
-        ffmpeg_path = pl.Path("")
-        # search embedded ffmpeg
-        if sys.argv[0].endswith("start_boris.py"):
-            ffmpeg_path = pl.Path(sys.argv[0]).resolve().parent / "boris" / "misc" / "ffmpeg"
-        if sys.argv[0].endswith("__main__.py"):
-            ffmpeg_path = pl.Path(sys.argv[0]).resolve().parent / "misc" / "ffmpeg"
-
-        if not ffmpeg_path.is_file():
-            # search global ffmpeg
-            ffmpeg_path = "ffmpeg"
-
-        # test ffmpeg
-        r, msg = test_ffmpeg_path(str(ffmpeg_path))
-        if r:
-            return True, str(ffmpeg_path)
-        else:
-            return False, "FFmpeg is not available"
+    ffmpeg_path = Path(__file__).parent / "misc" / ffmpeg_executable
+
+    if not ffmpeg_path.is_file():
+        # search global ffmpeg
+        ffmpeg_path = ffmpeg_executable
 
+    # test ffmpeg
+    r, msg = test_ffmpeg_path(str(ffmpeg_path))
+    if r:
+        return True, str(ffmpeg_path)
+    else:
+        return False, "FFmpeg is not available"
+
+
+def smart_size_format(n: Union[float, int, str, None]) -> str:
+    """
+    format with kb, Mb or Gb in base of value
+    """
+    if n is None:
+        return cfg.NA
+    if str(n) == "NA":
+        return cfg.NA
+    if math.isnan(n):
+        return cfg.NA
+    if n < 1_000:
+        return f"{n:,.1f} b"
+    if n < 1_000_000:
+        return f"{n / 1_000:,.1f} Kb"
+    if n < 1_000_000_000:
+        return f"{n / 1_000_000:,.1f} Mb"
+    return f"{n / 1_000_000_000:,.1f} Gb"
+
+
+def get_systeminfo() -> str:
+    """
+    returns info about the system
+    """
+
+    mpv_lib_version_, mpv_lib_file_path, mpv_api_version = mpv_lib_version()
+
+    system_info = (
+        f"BORIS version: {version.__version__}\n"
+        f"OS: {platform.uname().system} {platform.uname().release} {platform.uname().version}\n"
+        f"CPU: {platform.uname().machine} {platform.uname().processor}\n"
+        f"Python {platform.python_version()} ({'64-bit' if sys.maxsize > 2**32 else '32-bit'})\n"
+        f"Qt {qVersion()} - PySide {pyside6_version}\n"
+        f"MPV library version: {mpv_lib_version_}\n"
+        f"MPV API version: {mpv_api_version}\n"
+        f"MPV library file path: {mpv_lib_file_path}\n\n"
+    )
+
+    r, memory = mem_info()
+    if not r:
+        system_info += (
+            f"Memory (RAM)  Total: {memory.get('total_memory', 'Not available'):.2f} Mb  "
+            f"Free: {memory.get('free_memory', 'Not available'):.2f} Mb\n\n"
+        )
+
+    return system_info
+
+    """
+    # system info
+    systeminfo = ""
     if sys.platform.startswith("win"):
+        # systeminfo = subprocess.getoutput("systeminfo")
+        systeminfo = subprocess.run("systeminfo /FO csv /NH", capture_output=True, text=True, encoding="mbcs", shell=True).stdout
+
+        import csv
+        from io import StringIO
+
+        # Parse it as CSV
+        f = StringIO(systeminfo)
+        reader = csv.reader(f)
+        parsed_data = list(reader)[0]
+        # Print specific fields by index
+        info_to_show = ""
+        info_to_show += f"Computer Name: {parsed_data[0]}\n"
+        info_to_show += f"OS Name: {parsed_data[1]}\n"
+        info_to_show += f"OS Version: {parsed_data[2]}\n"
+        info_to_show += f"System Manufacturer: {parsed_data[11]}\n"
+        info_to_show += f"System Model: {parsed_data[12]}\n"
+        info_to_show += f"Processor: {parsed_data[14]}\n"
+        info_to_show += f"Locale: {parsed_data[19]}\n"
+        info_to_show += f"Installed Memory: {parsed_data[22]}\n"
+
+        # info about graphic card
+        graphic_info = subprocess.run(
+            "wmic path win32_videocontroller get name", capture_output=True, text=True, encoding="mbcs", shell=True
+        ).stdout
+        info_to_show += graphic_info.replace("\n", "").replace("Name", "Graphic card model")
+
+        systeminfo = info_to_show
 
-        ffmpeg_path = pl.Path("")
-        # search embedded ffmpeg
-        if sys.argv[0].endswith("start_boris.py"):
-            ffmpeg_path = pl.Path(sys.argv[0]).resolve().parent / "boris" / "misc" / "ffmpeg.exe"
-        if sys.argv[0].endswith("__main__.py"):
-            ffmpeg_path = pl.Path(sys.argv[0]).resolve().parent / "misc" / "ffmpeg.exe"
-
-        if not ffmpeg_path.is_file():
-            # search global ffmpeg
-            ffmpeg_path = "ffmpeg"
-
-        # test ffmpeg
-        r, msg = test_ffmpeg_path(str(ffmpeg_path))
-        if r:
-            return True, str(ffmpeg_path)
-        else:
-            return False, "FFmpeg is not available"
+    if sys.platform.startswith("linux"):
+        systeminfo = subprocess.getoutput("cat /etc/*rel*; uname -a")
+
+    return systeminfo
+    """
 
 
 def ffprobe_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
@@ -1007,73 +1433,144 @@ def ffprobe_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
     Returns:
         dict
     """
-    # ffprobe -v quiet -print_format json -show_format -show_streams /tmp/ramdisk/video1.mp4
-    ffprobe_bin = ffmpeg_bin.replace("ffmpeg", "ffprobe")
 
-    command = f'"{ffprobe_bin}" -v quiet -print_format json -show_format -show_streams "{file_name}"'
+    # check ffprobe executable in same place than ffmpeg
+    ffprobe_bin = ffmpeg_bin.replace("ffmpeg", "ffprobe")
+    if not Path(ffprobe_bin).is_file():
+        if which(ffprobe_bin) is None:
+            return {"error": "ffprobe not found"}
 
-    # print(command)
+    command = f'"{ffprobe_bin}" -hide_banner -v error -print_format json -show_format -show_streams "{file_name}"'
 
     p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
     out, error = p.communicate()
+    if error:
+        if b"invalid data" in error:
+            return {"error": f"{error}"}
 
     try:
-        hasVideo, hasAudio, bitrate, resolution, fps, sample_rate, duration, frames_number, size = (
-            False,
-            False,
-            None,
-            None,
-            0,
-            None,
-            0,
-            None,
-            None,
-        )
-        audio_codec, video_codec = None, None
+        hasVideo = False
+        hasAudio = False
+        """bitrate = None"""
+        video_bitrate = None
+        audio_bitrate = []
+        resolution = None
+        fps: float = 0
+        sample_rate = None
+        duration = None
+        audio_duration = cfg.NA
+        frames_number = None
+        size = None
+        audio_codec = None
+        video_codec = None
+
         video_param = json.loads(out.decode("utf-8"))
         if "size" in video_param["format"]:
             size = int(video_param["format"]["size"])
 
         for stream in video_param["streams"]:
-
             if stream["codec_type"] == "video":
                 hasVideo = True
-                bitrate = int(stream["bit_rate"] / 1000) if "bit_rate" in stream else None
+                video_bitrate = int(stream["bit_rate"]) if "bit_rate" in stream else None
                 resolution = f"{stream['width']}x{stream['height']}"
-                fps = float(stream["avg_frame_rate"].replace("/1", "")) if "avg_frame_rate" in stream else 0
-                duration = float(stream["duration"])
-                frames_number = int(stream["nb_frames"]) if "nb_frames" in stream else None
+
+                """
+                if "avg_frame_rate" in stream:
+                    if stream["avg_frame_rate"] == "0/0":
+                        fps = 0
+                    else:
+                        try:
+                            fps = eval(stream["avg_frame_rate"])
+                        except Exception:
+                            fps = 0
+                """
+                if "r_frame_rate" in stream:
+                    if stream["r_frame_rate"] == "0/0":
+                        fps = 0
+                    else:
+                        try:
+                            fps = eval(stream["r_frame_rate"])
+                        except Exception:
+                            fps = 0
+                        if fps >= 1000 and "avg_frame_rate" in stream:  # case for some h265 video ("r_frame_rate": "1200000/1")
+                            try:
+                                fps = eval(stream["avg_frame_rate"])
+                            except Exception:
+                                pass
+
+                fps = round(fps, 3)
+
+                if "duration" in stream:
+                    duration = float(stream["duration"])
+                if "duration_ts" in stream:
+                    frames_number = int(stream["duration_ts"])
+                elif "nb_frames" in stream:
+                    frames_number = int(stream["nb_frames"])
+                else:
+                    frames_number = None
+
                 video_codec = stream["codec_long_name"] if "codec_long_name" in stream else None
 
             if stream["codec_type"] == "audio":
                 hasAudio = True
-                sample_rate = float(stream["sample_rate"])
-                duration = float(stream["duration"])
+                sample_rate = float(stream["sample_rate"]) if "sample_rate" in stream else cfg.NA
+                # TODO manage audio_duration parameter
+                audio_duration = float(stream["duration"]) if "duration" in stream else cfg.NA
                 audio_codec = stream["codec_long_name"]
+                audio_bitrate.append(int(stream.get("bit_rate", 0)))
+
+        # check duration
+        if duration is None:
+            if "duration" in video_param["format"]:
+                duration = float(video_param["format"]["duration"])
+            else:
+                duration = 0
+
+        # check bit rate
+        if "bit_rate" in video_param["format"]:
+            all_bitrate = int(video_param["format"]["bit_rate"])
+        else:
+            all_bitrate = None
+
+        if video_bitrate is None and all_bitrate is not None:
+            video_bitrate = all_bitrate - sum(audio_bitrate)
+
+        # extract format long name
+        format_long_name = video_param["format"]["format_long_name"] if "format_long_name" in video_param["format"] else cfg.NA
+
+        # extract creation time ("creation_time": "2023-03-22T16:50:32.000000Z")
+        creation_time = cfg.NA
+        if "tags" in video_param["format"] and "creation_time" in video_param["format"]["tags"]:
+            creation_time = video_param["format"]["tags"]["creation_time"].replace("T", " ")
+            if "." in creation_time:
+                creation_time = creation_time.split(".")[0]
 
         return {
             "analysis_program": "ffprobe",
             "frames_number": frames_number,
             "duration_ms": duration * 1000,
             "duration": duration,
+            "audio_duration": audio_duration,
             "fps": fps,
             "has_video": hasVideo,
             "has_audio": hasAudio,
-            "bitrate": bitrate,
+            "bitrate": video_bitrate,
             "resolution": resolution,
             "sample_rate": sample_rate,
             "file size": size,
             "audio_codec": audio_codec,
             "video_codec": video_codec,
+            "creation_time": creation_time,
+            "format_long_name": format_long_name,
         }
 
-    except Exception:
-        return {}
+    except Exception as e:
+        return {"error": str(e)}
 
 
 def accurate_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
     """
-    analyse frame rate and video duration with ffmpeg
+    analyse frame rate and video duration with ffprobe or ffmpeg if ffprobe not available
     Returns parameters: duration, duration_ms, bitrate, frames_number, fps, has_video (True/False), has_audio (True/False)
 
     Args:
@@ -1087,19 +1584,22 @@ def accurate_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
 
     ffprobe_results = ffprobe_media_analysis(ffmpeg_bin, file_name)
 
-    if ffprobe_results:
+    logger.debug(f"file_name: {file_name}")
+    logger.debug(f"ffprobe_results: {ffprobe_results}")
+
+    if ("error" not in ffprobe_results) and (ffprobe_results["bitrate"] is not None):
         return ffprobe_results
     else:
         # use ffmpeg
-        command = f'"{ffmpeg_bin}" -i "{file_name}" > {"NUL" if sys.platform.startswith("win") else "/dev/null"}'
+        command = f'"{ffmpeg_bin}" -hide_banner -i "{file_name}" > {"NUL" if sys.platform.startswith("win") else "/dev/null"}'
 
         p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
 
-        duration, fps, hasVideo, hasAudio, bitrate = 0, 0, False, False, -1
+        duration, fps, hasVideo, hasAudio, bitrate = 0, 0, False, False, None
         try:
-            error = p.communicate()[1]
-        except Exception:
-            return {"error": "Error reading file"}
+            _, error = p.communicate()
+        except Exception as e:
+            return {"error": str(e)}
 
         rows = error.split(b"\n")
 
@@ -1125,10 +1625,10 @@ def accurate_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
                 if b"bitrate:" in row:
                     re_results = re.search(b"bitrate: (.{1,10}) kb", row, re.IGNORECASE)
                     if re_results:
-                        bitrate = int(re_results.group(1).strip())
+                        bitrate = int(re_results.group(1).strip()) * 1000
                     break
         except Exception:
-            bitrate = -1
+            bitrate = None
 
         # fps
         fps = 0
@@ -1149,7 +1649,7 @@ def accurate_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
                 if b"Stream #" in row and b"Video:" in row:
                     hasVideo = True
                     # get resolution \d{3,5}x\d{3,5}
-                    re_results = re.search(b"\d{3,5}x\d{3,5}", row, re.IGNORECASE)
+                    re_results = re.search(r"\d{3,5}x\d{3,5}", row, re.IGNORECASE)
                     if re_results:
                         resolution = re_results.group(0).decode("utf-8")
                     break
@@ -1174,11 +1674,13 @@ def accurate_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
             "frames_number": int(fps * duration),
             "duration_ms": duration * 1000,
             "duration": duration,
+            "audio_duration": cfg.NA,
             "fps": fps,
             "has_video": hasVideo,
             "has_audio": hasAudio,
             "bitrate": bitrate,
             "resolution": resolution,
+            "format_long_name": "",
         }
 
 
@@ -1199,7 +1701,7 @@ def behavior_color(colors_list: list, idx: int, default_color: str = "darkgray")
     """
 
     try:
-        return colors_list[idx % len(colors_list)]
+        return colors_list[idx % len(colors_list)].replace("tab:", "")
     except Exception:
         return default_color
 
@@ -1219,12 +1721,37 @@ def all_behaviors(ethogram: dict) -> list:
     return [ethogram[x][cfg.BEHAVIOR_CODE] for x in sorted_keys(ethogram)]
 
 
+def all_subjects(subjects: dict) -> list:
+    """
+    extract all subjects from the subject configuration dictionary
+
+    Args:
+        subject configuration (dict)
+
+    Returns:
+        list: subjects name
+    """
+
+    return [subjects[x][cfg.SUBJECT_NAME] for x in sorted_keys(subjects)]
+
+
+def has_coding_map(ethogram: dict, behavior_idx: str) -> bool:
+    """
+    check if behavior index has a coding map
+    """
+    if not ethogram.get(behavior_idx, False):
+        return False
+    if not ethogram[behavior_idx].get("coding map", False):
+        return False
+    return True
+
+
 def dir_images_number(dir_path_str: str) -> dict:
     """
-    return number of images in dir_path (*.jpg, *.jpeg, *.png)
+    return number of images in dir_path (see cfg.IMAGE_EXTENSIONS)
     """
 
-    dir_path = pl.Path(dir_path_str)
+    dir_path = Path(dir_path_str)
     if not dir_path.is_dir():
         return {"error": f"The directory {dir_path_str} does not exists"}
     img_count = 0
@@ -1262,29 +1789,11 @@ def intersection(A, B, C, D):
             ym = slope * xm + intersept
         else:
             xm = (
-                (
-                    xd * xa * yc
-                    - xd * xb * yc
-                    - xd * xa * yb
-                    - xc * xa * yd
-                    + xc * xa * yb
-                    + xd * ya * xb
-                    + xc * xb * yd
-                    - xc * ya * xb
-                )
+                (xd * xa * yc - xd * xb * yc - xd * xa * yb - xc * xa * yd + xc * xa * yb + xd * ya * xb + xc * xb * yd - xc * ya * xb)
                 / (-yb * xd + yb * xc + ya * xd - ya * xc + xb * yd - xb * yc - xa * yd + xa * yc)
             ).quantize(dec(".001"), rounding=ROUND_DOWN)
             ym = (
-                (
-                    yb * xc * yd
-                    - yb * yc * xd
-                    - ya * xc * yd
-                    + ya * yc * xd
-                    - xa * yb * yd
-                    + xa * yb * yc
-                    + ya * xb * yd
-                    - ya * xb * yc
-                )
+                (yb * xc * yd - yb * yc * xd - ya * xc * yd + ya * yc * xd - xa * yb * yd + xa * yb * yc + ya * xb * yd - ya * xb * yc)
                 / (-yb * xd + yb * xc + ya * xd - ya * xc + xb * yd - xb * yc - xa * yd + xa * yc)
             ).quantize(dec(".001"), rounding=ROUND_DOWN)
 
@@ -1293,16 +1802,7 @@ def intersection(A, B, C, D):
         ymin1, ymax1 = min(ya, yb), max(ya, yb)
         ymin2, ymax2 = min(yc, yd), max(yc, yd)
 
-        return (
-            xm >= xmin1
-            and xm <= xmax1
-            and xm >= xmin2
-            and xm <= xmax2
-            and ym >= ymin1
-            and ym <= ymax1
-            and ym >= ymin2
-            and ym <= ymax2
-        )
+        return xm >= xmin1 and xm <= xmax1 and xm >= xmin2 and xm <= xmax2 and ym >= ymin1 and ym <= ymax1 and ym >= ymin2 and ym <= ymax2
 
     except Exception:  # for cases xa=xb=xc=xd
         return True