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

boris/player_dock_widget.py

@@ -1,7 +1,7 @@
 """
 BORIS
 Behavioral Observation Research Interactive Software
-Copyright 2012-2023 Olivier Friard
+Copyright 2012-2025 Olivier Friard
 
 This file is part of BORIS.
 
@@ -20,44 +20,31 @@ This file is part of BORIS.
 
 """
 
-# add misc directory to search path for mpv-1.dll
-import os
 import sys
 import logging
-import pathlib as pl
-import datetime as dt
+import functools
 
-os.environ["PATH"] = os.path.dirname(__file__) + os.sep + "misc" + os.pathsep + os.environ["PATH"]
-
-try:
+if (sys.platform.startswith("win") or sys.platform.startswith("linux")) and ("-i" not in sys.argv) and ("--ipc" not in sys.argv):
     from . import mpv2 as mpv
-
-    # check if MPV API v. 1
-    try:
-        if "libmpv.so.1" in mpv.sofile:
-            from . import mpv as mpv
-    except AttributeError:
-        if "mpv-1.dll" in mpv.dll:
-            from . import mpv as mpv
-
-except RuntimeError:  # libmpv found but version too old
-    from . import mpv as mpv
-
-except OSError:  # libmpv not found
-    msg = "LIBMPV library not found!\n"
-    logging.critical(msg)
-    # append to boris.log file
-    with open(pl.Path("~").expanduser() / "boris.log", "a") as f_out:
-        f_out.write(f"{dt.datetime.now():%Y-%m-%d %H:%M}\n")
-        f_out.write(msg)
-        f_out.write("-" * 80 + "\n")
-    sys.exit()
-
-
-from PyQt5.QtWidgets import QLabel, QDockWidget, QWidget, QHBoxLayout, QSlider, QSizePolicy, QStackedWidget
-from PyQt5.QtCore import pyqtSignal, QEvent, Qt
-
-import logging
+else:
+    import ipc_mpv
+import config as cfg
+import gui_utilities
+
+
+from PySide6.QtWidgets import (
+    QLabel,
+    QDockWidget,
+    QWidget,
+    QHBoxLayout,
+    QVBoxLayout,
+    QSlider,
+    QSizePolicy,
+    QStackedWidget,
+    QToolButton,
+)
+from PySide6.QtCore import Signal, QEvent, Qt
+from PySide6.QtGui import QIcon, QAction
 
 
 class Clickable_label(QLabel):
@@ -66,7 +53,7 @@ class Clickable_label(QLabel):
     Label emits a signal when clicked
     """
 
-    mouse_pressed_signal = pyqtSignal(int, QEvent)
+    mouse_pressed_signal = Signal(int, QEvent)
 
     def __init__(self, id_, parent=None):
         QLabel.__init__(self, parent)
@@ -76,23 +63,40 @@ class Clickable_label(QLabel):
         """
         label clicked
         """
+        logging.debug(f"mousepress event: label {self.id_} clicked {event.pos()}")
 
-        logging.debug(f"mousepress event: label {self.id_} clicked")
+        """
+        super().mousePressEvent(event)
+        x, y = event.pos().x(), event.pos().y()
+        draw_on_pixmap(self, x, y)  # Example usage
+        """
 
         self.mouse_pressed_signal.emit(self.id_, event)
 
 
+def mpv_logger(player_id, loglevel, component, message):
+    """
+    redirect MPV log messages to general logging system
+    """
+
+    logging.debug(f"MPV player #{player_id}: [{loglevel}] {component}: {message}")
+
+
 class DW_player(QDockWidget):
+    """
+    Define the player class
+    """
 
-    key_pressed_signal = pyqtSignal(QEvent)
-    volume_slider_moved_signal = pyqtSignal(int, int)
-    view_signal = pyqtSignal(int, str, int)
-    resize_signal = pyqtSignal(int)
+    key_pressed_signal = Signal(QEvent)
+    volume_slider_moved_signal = Signal(int, int)
+    mute_action_triggered_signal = Signal(int)
+    view_signal = Signal(int, str, int)
+    resize_signal = Signal(int)
 
     def __init__(self, id_, parent=None):
         super().__init__(parent)
+        # print("ipc", parent.MPV_IPC_MODE)
         self.id_ = id_
-        self.zoomed = False
         self.setWindowTitle(f"Player #{id_ + 1}")
         self.setObjectName(f"player{id_ + 1}")
 
@@ -101,23 +105,46 @@ class DW_player(QDockWidget):
 
         self.videoframe = QWidget(self)
 
-        self.player = mpv.MPV(
-            wid=str(int(self.videoframe.winId())),
-            # vo='x11', # You may not need this
-            log_handler=None,
-            loglevel="debug",
-        )
-
-        self.player.screenshot_format = "png"
+        if parent.MPV_IPC_MODE:
+            self.player = ipc_mpv.IPC_MPV(socket_path=f"{cfg.MPV_SOCKET}{self.id_}")
+        else:
+            self.player = mpv.MPV(
+                wid=str(int(self.videoframe.winId())),
+                vo="x11" if sys.platform.startswith("linux") else "",
+                log_handler=functools.partial(mpv_logger, self.id_),
+                loglevel="debug",
+            )
+
+            self.player.screenshot_format = "png"
         self.hlayout.addWidget(self.videoframe)
 
+        # layout volume slider and mute button
+        self.vlayout = QVBoxLayout()
+
+        # volume slider
         self.volume_slider = QSlider(Qt.Vertical, self)
         self.volume_slider.setFocusPolicy(Qt.NoFocus)
         self.volume_slider.setMaximum(100)
         self.volume_slider.setValue(50)
         self.volume_slider.sliderMoved.connect(self.volume_slider_moved)
 
-        self.hlayout.addWidget(self.volume_slider)
+        self.vlayout.addWidget(self.volume_slider)
+
+        # mute button
+        self.mute_button = QToolButton()
+        self.mute_button.setFocusPolicy(Qt.NoFocus)
+        self.mute_button.setAutoRaise(True)
+        self.mute_action = QAction()
+
+        theme_mode = gui_utilities.theme_mode()
+
+        self.mute_action.setIcon(QIcon(f":/volume_xmark_{theme_mode}"))
+        self.mute_action.triggered.connect(self.mute_action_triggered)
+        self.mute_button.setDefaultAction(self.mute_action)
+
+        self.vlayout.addWidget(self.mute_button)
+
+        self.hlayout.addLayout(self.vlayout)
 
         self.stack1.setLayout(self.hlayout)
 
@@ -146,21 +173,24 @@ class DW_player(QDockWidget):
         """
         self.volume_slider_moved_signal.emit(self.id_, self.volume_slider.value())
 
-    def keyPressEvent(self, event):
+    def mute_action_triggered(self):
         """
-        emit signal when key pressed on dock widget
+        emit signal when mute action is triggered
         """
-        self.key_pressed_signal.emit(event)
+        theme_mode = gui_utilities.theme_mode()
+        if self.player.mute:
+            self.mute_action.setIcon(QIcon(f":/volume_xmark_{theme_mode}"))
+        else:
+            self.mute_action.setIcon(QIcon(f":/volume_off_{theme_mode}"))
+        self.mute_action_triggered_signal.emit(self.id_)
 
-    '''
-    def view_signal_triggered(self, msg, button):
+    def keyPressEvent(self, event):
         """
-        transmit signal received by video frame
+        emit signal when key pressed on dock widget
         """
-        self.view_signal.emit(self.id_, msg, button)
-    '''
+        self.key_pressed_signal.emit(event)
 
-    def resizeEvent(self, dummy):
+    def resizeEvent(self, _):
         """
         emits signal when dockwidget resized
         """

boris/plot_data_module.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
@@ -29,8 +29,8 @@ from decimal import Decimal as dec
 import numpy as np
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
-from PyQt5.QtCore import pyqtSignal, QEvent, QThread, QObject, pyqtSlot, QTimer
-from PyQt5.QtWidgets import (
+from PySide6.QtCore import Signal, QEvent, QThread, QObject, Slot, QTimer
+from PySide6.QtWidgets import (
     QSizePolicy,
     QWidget,
     QPushButton,
@@ -42,6 +42,7 @@ from PyQt5.QtWidgets import (
 )
 
 from . import utilities as util
+from . import config as cfg
 
 
 class MyMplCanvas(FigureCanvas):
@@ -55,11 +56,10 @@ class MyMplCanvas(FigureCanvas):
 
 
 class Plot_data(QWidget):
-
-    send_fig = pyqtSignal(float)
+    send_fig = Signal(float)
 
     # send keypress event to mainwindow
-    sendEvent = pyqtSignal(QEvent)
+    sendEvent = Signal(QEvent)
 
     def __init__(
         self,
@@ -75,7 +75,6 @@ class Plot_data(QWidget):
         column_converter,
         log_level="",
     ):
-
         super().__init__()
 
         self.installEventFilter(self)
@@ -133,14 +132,18 @@ class Plot_data(QWidget):
             substract_first_value,
             converters=converters,
             column_converter=column_converter,
-        )  # txt2np_array defined in utilities.py
+        )
+
+        print(f"{error_msg=}")
 
         if not result:
             self.error_msg = error_msg
             return
 
+        """
         logging.debug("data[50]: {}".format(data[:50]))
         logging.debug("shape: {}".format(data.shape))
+        """
 
         if data.shape == (0,):
             self.error_msg = "Empty input file"
@@ -150,7 +153,7 @@ class Plot_data(QWidget):
         data = data[data[:, 0].argsort()]
 
         # unique
-        u, idx = np.unique(data[:, 0], return_index=True)
+        _, idx = np.unique(data[:, 0], return_index=True)
         data = data[idx]
 
         # time
@@ -162,24 +165,28 @@ class Plot_data(QWidget):
         # check if time is linear
         diff = set(np.round(np.diff(data, axis=0)[:, 0], 4))
 
+        # check if only one time value is available
+        if not diff:
+            self.error_msg = "only one time value is present"
+            return
+
         if min(diff) == 0:
             self.error_msg = "more values for same time"
             return
 
-        logging.debug(f"diff: {diff}")
+        """logging.debug(f"diff: {diff}")"""
 
         min_time_step = min(diff)
 
-        logging.debug(f"min_time_step: {min_time_step}")
+        """logging.debug(f"min_time_step: {min_time_step}")"""
 
         # check if sampling rate is not constant
         if len(diff) != 1:
-
-            logging.debug("len diff != 1")
+            """logging.debug("len diff != 1")"""
 
             min_time_step = min(diff)
 
-            logging.debug(f"min_time_step: {min_time_step}")
+            """logging.debug(f"min_time_step: {min_time_step}")"""
 
             # increase value for low sampling rate (> 1 s)
             if min_time_step > 1:
@@ -189,7 +196,7 @@ class Plot_data(QWidget):
             data = np.array((x2, np.interp(x2, data[:, 0], data[:, 1]))).T
             del x2
 
-            logging.debug(f"data[:,0]: {data[:, 0]}")
+            """logging.debug(f"data[:,0]: {data[:, 0]}")"""
 
             # time
             min_time_value, max_time_value = min(data[:, 0]), max(data[:, 0])
@@ -204,9 +211,9 @@ class Plot_data(QWidget):
             data = data[0 :: int(round(0.04 / min_time_step, 2))]
             min_time_step = 0.04
 
-        logging.debug(f"new data after subsampling: {data[:50]}")
+        """logging.debug(f"new data after subsampling: {data[:50]}")"""
 
-        min_value, max_value = min(data[:, 1]), max(data[:, 1])
+        min_var_value, max_var_value = min(data[:, 1]), max(data[:, 1])
 
         max_frequency = 1 / min_time_step
 
@@ -241,7 +248,7 @@ class Plot_data(QWidget):
         if min_time_step < 0.2:
             self.time_out = 200
         else:
-            self.time_out = min_time_step * 1000
+            self.time_out = round(min_time_step * 1000)
 
     def eventFilter(self, receiver, event):
         """
@@ -281,40 +288,31 @@ class Plot_data(QWidget):
 
     # Slot receives data and plots it
     def plot(self, x, y, position_data, position_start, min_value, max_value, position_end):
-
-        logging.debug(f"len x (plot): {len(x)}")
-        logging.debug(f"len y (plot): {len(y)}")
-
         # print current value
         try:
             if x[0] == 0:
                 self.lb_value.setText(str(round(y[position_data], 3)))
             else:
                 self.lb_value.setText(str(round(y[len(y) // 2], 3)))
-        except:
+        except Exception:
             self.lb_value.setText("Read error")
 
         try:
             self.myplot.axes.clear()
-
             self.myplot.axes.set_title(self.plot_title)
-
             self.myplot.axes.set_xlim(position_start, position_end)
-
             self.myplot.axes.set_ylabel(self.y_label, rotation=90, labelpad=10)
             self.myplot.axes.set_ylim((min_value, max_value))
-
             self.myplot.axes.plot(x, y, self.plot_style)
-            self.myplot.axes.axvline(x=position_data, color="red", linestyle="-")
+            self.myplot.axes.axvline(x=position_data, color=cfg.REALTIME_PLOT_CURSOR_COLOR, linestyle="-")
 
             self.myplot.draw()
-        except:
-            logging.debug("error")
-            pass  # only for protection agains crash
+        except Exception:
+            logging.debug(f"error in plotting external data: {sys.exc_info()[1]}")
 
 
 class Plotter(QObject):
-    return_fig = pyqtSignal(
+    return_fig = Signal(
         np.ndarray,  # x array
         np.ndarray,  # y array
         float,  # position_data
@@ -324,9 +322,8 @@ class Plotter(QObject):
         float,  # position end
     )
 
-    @pyqtSlot(float)
+    @Slot(float)
     def replot(self, current_time):  # time_ in s
-
         logging.debug("current_time: {}".format(current_time))
 
         current_discrete_time = round(round(current_time / self.min_time_step) * self.min_time_step, 2)
@@ -337,7 +334,6 @@ class Plotter(QObject):
         freq_interval = int(round(self.interval / self.min_time_step))
 
         if self.min_time_value <= current_discrete_time <= self.max_time_value:
-
             logging.debug("self.min_time_value <= current_discrete_time <= self.max_time_value")
 
             idx = np.where(self.data[:, 0] == current_discrete_time)[0]
@@ -345,7 +341,6 @@ class Plotter(QObject):
                 idx = np.where(abs(self.data[:, 0] - current_discrete_time) <= 0.02)[0]
 
             if len(idx):
-
                 position_data = idx[0]
 
                 logging.debug(f"position data: {position_data}")
@@ -382,14 +377,9 @@ class Plotter(QObject):
                 d = np.array([np.nan] * int(self.interval / self.min_time_step)).T
 
         elif current_time > self.max_time_value:
-
             logging.debug(f"self.interval/self.min_time_step/2: {self.interval / self.min_time_step / 2}")
 
-            dim_footer = int(
-                round(
-                    (current_time - self.max_time_value) / self.min_time_step + self.interval / self.min_time_step / 2
-                )
-            )
+            dim_footer = int(round((current_time - self.max_time_value) / self.min_time_step + self.interval / self.min_time_step / 2))
 
             footer = np.array([np.nan] * dim_footer).T
             logging.debug(f"len footer: {len(footer)}")
@@ -398,7 +388,6 @@ class Plotter(QObject):
             logging.debug(f"a: {a}")
 
             if a >= 0:
-
                 logging.debug("a>=0")
 
                 st = int(round(len(self.data) - a))
@@ -424,7 +413,6 @@ class Plotter(QObject):
                 logging.debug(f"len d a<0: {len(d)}")
 
         elif current_time < self.min_time_value:
-
             x = (self.min_time_value - current_time) / self.min_time_step
             dim_header = int(round(self.interval / self.min_time_step / 2 + x))
             header = np.array([np.nan] * dim_header).T
@@ -444,7 +432,11 @@ class Plotter(QObject):
 
         logging.debug(f"self.min_time_step: {self.min_time_step}")
 
-        x = np.arange(current_time - self.interval // 2, current_time + self.interval // 2, self.min_time_step)
+        x = np.arange(
+            current_time - self.interval // 2,
+            current_time + self.interval // 2,
+            self.min_time_step,
+        )
 
         logging.debug(f"len x 1: {len(x)}")
 
@@ -489,7 +481,12 @@ if __name__ == "__main__":
         "convert_time_ecg": {
             "name": "convert_time_ecg",
             "description": "convert '%d/%m/%Y %H:%M:%S.%f' in seconds from epoch",
-            "code": '\nimport datetime\nepoch = datetime.datetime.utcfromtimestamp(0)\ndatetime_format = "%d/%m/%Y %H:%M:%S.%f"\n\nOUTPUT = (datetime.datetime.strptime(INPUT, datetime_format) - epoch).total_seconds()\n',
+            "code": (
+                "\nimport datetime\n"
+                "epoch = datetime.datetime.utcfromtimestamp(0)\n"
+                'datetime_format = "%d/%m/%Y %H:%M:%S.%f"\n\n'
+                "OUTPUT = (datetime.datetime.strptime(INPUT, datetime_format) - epoch).total_seconds()\n"
+            ),
         },
         "hhmmss_2_seconds": {
             "name": "hhmmss_2_seconds",