boris-behav-obs 8.16.5__py3-none-any.whl → 9.7.12__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,31 +19,252 @@ Copyright 2012-2023 Olivier Friard
   MA 02110-1301, USA.
 """
 
+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
-from typing import Union, Tuple
+import socket
 
-import numpy as np
-from PyQt5.QtGui import QPixmap, QImage
-
-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 is_subdir(a: Path, b: Path) -> bool:
+    """
+    Return True if directory A is inside directory B.
+    """
+    a = a.resolve()
+    b = b.resolve()
+    return a.is_relative_to(b)
+
+
+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:
@@ -154,28 +375,7 @@ def return_file_header_footer(file_name: str, file_row_number: int = 0, row_numb
     return header, footer
 
 
-def bytes_to_str(b: bytes) -> str:
-    """
-    Translate bytes to string.
-
-    Args:
-        b (bytes): byte to convert
-
-    Returns:
-        str: converted byte
-    """
-
-    if isinstance(b, bytes):
-        fileSystemEncoding = sys.getfilesystemencoding()
-        # hack for PyInstaller
-        if fileSystemEncoding is None:
-            fileSystemEncoding = "UTF-8"
-        return b.decode(fileSystemEncoding)
-    else:
-        return b
-
-
-def convertTime(time_format: str, sec: Union[float, dec]) -> str:
+def convertTime(time_format: str, sec: Union[float, dec]) -> Union[str, None]:
     """
     convert time in base at the current format (S or HHMMSS)
 
@@ -198,10 +398,12 @@ def convertTime(time_format: str, sec: Union[float, dec]) -> str:
     return None
 
 
-def dynamic_time_format(sec: Union[float, dec], cutoff: dec, time_format: str) -> str:
+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:
@@ -222,7 +424,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]
@@ -238,20 +443,6 @@ def count_media_file(media_files: dict) -> int:
     return sum([len(media_files[idx]) for idx in media_files])
 
 
-def file_content_md5(file_name: str) -> str:
-    """
-    returns the MD5 sum of file content
-    """
-    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 ""
-
-
 def txt2np_array(
     file_name: str, columns_str: str, substract_first_value: str, converters=None, column_converter=None
 ) -> Tuple[bool, str, np.array]:
@@ -289,20 +480,37 @@ def txt2np_array(
             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:
@@ -324,9 +532,7 @@ def txt2np_array(
         return False, f"{sys.exc_info()[1]}", np.array([])
 
     try:
-        data = np.loadtxt(
-            file_name, delimiter=dialect.delimiter, usecols=columns, skiprows=header_rows_nb, 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([])
@@ -338,7 +544,7 @@ def txt2np_array(
     return True, "", data
 
 
-def versiontuple(version_str: str):
+def versiontuple(version_str: str) -> tuple:
     """
     Convert version from str to tuple of str
 
@@ -381,7 +587,7 @@ def behav_category_user_color(behavioral_categories: dict, name: str) -> Union[s
 
 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
@@ -390,12 +596,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
@@ -404,7 +610,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:
@@ -457,8 +663,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
@@ -474,7 +693,7 @@ def get_current_states_modifiers_by_subject(
         dict: current states by subject. dict of list
     """
     current_states: dict = {}
-    if time.is_nan():
+    if time_.is_nan():
         for idx in subjects:
             current_states[idx] = []
         return current_states
@@ -487,43 +706,45 @@ def get_current_states_modifiers_by_subject(
 
     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]
@@ -533,7 +754,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
@@ -587,7 +807,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)
             ]
@@ -604,19 +825,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)
@@ -686,15 +894,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():
@@ -709,7 +917,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():
@@ -743,21 +951,28 @@ def complete(lst: list, max_: int) -> list:
 
 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:
@@ -787,7 +1002,7 @@ def intfloatstr(s: str) -> int:
             return s
 
 
-def distance(p1, p2):
+def distance(p1: tuple, p2: tuple) -> float:
     """
     euclidean distance between 2 points
     """
@@ -819,6 +1034,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:
@@ -836,9 +1107,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),
@@ -858,9 +1127,7 @@ def mem_info():
 
     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)
@@ -873,7 +1140,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
@@ -888,7 +1155,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 /
@@ -919,17 +1199,23 @@ 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:
+def seconds2time(sec: dec | None) -> str:
     """
     convert seconds to hh:mm:ss.sss format
 
@@ -938,12 +1224,15 @@ def seconds2time(sec: dec) -> str:
     Returns:
         str: time in format hh:mm:ss
     """
+    if sec is None:
+        return cfg.NA
 
     if math.isnan(sec):
         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)
@@ -1002,7 +1291,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
 
@@ -1014,22 +1303,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
@@ -1040,43 +1327,24 @@ 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_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_executable = Path("ffmpeg")
+    elif sys.platform.startswith("win"):
+        ffmpeg_executable = Path("ffmpeg.exe")
 
-    if sys.platform.startswith("win"):
-        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"
+    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:
@@ -1098,6 +1366,73 @@ def smart_size_format(n: Union[float, int, str, None]) -> str:
     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
+
+    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:
     """
     analyse video parameters with ffprobe (if available)
@@ -1109,28 +1444,32 @@ 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
+
+    # 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"}
 
     command = f'"{ffprobe_bin}" -hide_banner -v error -print_format json -show_format -show_streams "{file_name}"'
 
-    # print(command)
-
     p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
     out, error = p.communicate()
     if error:
-        return {"error": f"{error}"}
+        if b"invalid data" in error:
+            return {"error": f"{error}"}
 
     try:
         hasVideo = False
         hasAudio = False
-        '''bitrate = None'''
+        """bitrate = None"""
         video_bitrate = None
         audio_bitrate = []
         resolution = None
-        fps = 0
+        fps: float = 0
         sample_rate = None
-        duration = 0
+        duration = None
+        audio_duration = cfg.NA
         frames_number = None
         size = None
         audio_codec = None
@@ -1164,9 +1503,16 @@ def ffprobe_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
                             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
 
-                duration = float(stream["duration"])
-                # frames_number = int(stream["nb_frames"]) if "nb_frames" in stream else None
+                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:
@@ -1178,11 +1524,19 @@ def ffprobe_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
 
             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"])
@@ -1192,11 +1546,22 @@ def ffprobe_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
         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,
@@ -1206,6 +1571,8 @@ def ffprobe_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
             "file size": size,
             "audio_codec": audio_codec,
             "video_codec": video_codec,
+            "creation_time": creation_time,
+            "format_long_name": format_long_name,
         }
 
     except Exception as e:
@@ -1214,7 +1581,7 @@ def ffprobe_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
 
 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:
@@ -1228,13 +1595,14 @@ def accurate_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
 
     ffprobe_results = ffprobe_media_analysis(ffmpeg_bin, file_name)
 
+    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}" -hide_banner -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)
 
@@ -1292,7 +1660,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
@@ -1317,11 +1685,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": "",
         }
 
 
@@ -1362,12 +1732,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 (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
@@ -1405,29 +1800,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)
 
@@ -1436,16 +1813,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