boris-behav-obs 8.16.5__py3-none-any.whl → 9.7.12__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,40 +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
-    # is v. 1 use the old version of mpv.py
-    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)
-    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):
@@ -62,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)
@@ -72,22 +63,40 @@ class Clickable_label(QLabel):
         """
         label clicked
         """
-        """logging.debug(f"mousepress event: label {self.id_} clicked")"""
+        logging.debug(f"mousepress event: label {self.id_} clicked {event.pos()}")
+
+        """
+        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}")
 
@@ -96,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)
 
@@ -141,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,
@@ -56,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,
@@ -76,7 +75,6 @@ class Plot_data(QWidget):
         column_converter,
         log_level="",
     ):
-
         super().__init__()
 
         self.installEventFilter(self)
@@ -103,17 +101,13 @@ class Plot_data(QWidget):
         self.hlayout1.addWidget(QLabel("Zoom"))
         self.hlayout1.addWidget(self.button_plus)
         self.hlayout1.addWidget(self.button_minus)
-        self.hlayout1.addItem(
-            QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
-        )
+        self.hlayout1.addItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
 
         self.hlayout2 = QHBoxLayout()
         self.hlayout2.addWidget(QLabel("Value"))
         self.lb_value = QLabel("")
         self.hlayout2.addWidget(self.lb_value)
-        self.hlayout2.addItem(
-            QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
-        )
+        self.hlayout2.addItem(QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
 
         self.layout.addLayout(self.hlayout1)
         self.layout.addLayout(self.hlayout2)
@@ -140,6 +134,8 @@ class Plot_data(QWidget):
             column_converter=column_converter,
         )
 
+        print(f"{error_msg=}")
+
         if not result:
             self.error_msg = error_msg
             return
@@ -186,7 +182,6 @@ class Plot_data(QWidget):
 
         # check if sampling rate is not constant
         if len(diff) != 1:
-
             """logging.debug("len diff != 1")"""
 
             min_time_step = min(diff)
@@ -197,9 +192,7 @@ class Plot_data(QWidget):
             if min_time_step > 1:
                 min_time_step = 1
 
-            x2 = np.arange(
-                min_time_value, max_time_value + min_time_step, min_time_step
-            )
+            x2 = np.arange(min_time_value, max_time_value + min_time_step, min_time_step)
             data = np.array((x2, np.interp(x2, data[:, 0], data[:, 1]))).T
             del x2
 
@@ -294,10 +287,7 @@ class Plot_data(QWidget):
         self.close()
 
     # Slot receives data and plots it
-    def plot(
-        self, x, y, position_data, position_start, min_value, max_value, position_end
-    ):
-
+    def plot(self, x, y, position_data, position_start, min_value, max_value, position_end):
         # print current value
         try:
             if x[0] == 0:
@@ -314,9 +304,7 @@ class Plot_data(QWidget):
             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=cfg.REALTIME_PLOT_CURSOR_COLOR, linestyle="-"
-            )
+            self.myplot.axes.axvline(x=position_data, color=cfg.REALTIME_PLOT_CURSOR_COLOR, linestyle="-")
 
             self.myplot.draw()
         except Exception:
@@ -324,7 +312,7 @@ class Plot_data(QWidget):
 
 
 class Plotter(QObject):
-    return_fig = pyqtSignal(
+    return_fig = Signal(
         np.ndarray,  # x array
         np.ndarray,  # y array
         float,  # position_data
@@ -334,14 +322,11 @@ 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
-        )
+        current_discrete_time = round(round(current_time / self.min_time_step) * self.min_time_step, 2)
 
         logging.debug("current_discrete_time: {}".format(current_discrete_time))
         logging.debug("self.interval: {}".format(self.interval))
@@ -349,17 +334,13 @@ 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"
-            )
+            logging.debug("self.min_time_value <= current_discrete_time <= self.max_time_value")
 
             idx = np.where(self.data[:, 0] == current_discrete_time)[0]
             if not len(idx):
                 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}")
@@ -396,28 +377,17 @@ 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}")
 
-            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)}")
 
-            a = (
-                self.interval / 2 - (current_time - self.max_time_value)
-            ) / self.min_time_step
+            a = (self.interval / 2 - (current_time - self.max_time_value)) / self.min_time_step
             logging.debug(f"a: {a}")
 
             if a >= 0:
-
                 logging.debug("a>=0")
 
                 st = int(round(len(self.data) - a))
@@ -443,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
@@ -453,9 +422,7 @@ class Plotter(QObject):
             if b >= 0:
                 d = np.append(header, self.data[0:b][:, 1], axis=0)
                 if len(d) < freq_interval:
-                    d = np.append(
-                        d, np.array([np.nan] * int(freq_interval - len(d))).T, axis=0
-                    )
+                    d = np.append(d, np.array([np.nan] * int(freq_interval - len(d))).T, axis=0)
 
             else:
                 d = np.array([np.nan] * int(self.interval / self.min_time_step)).T