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

boris/ipc_mpv.py

@@ -0,0 +1,325 @@
+"""
+BORIS
+Behavioral Observation Research Interactive Software
+Copyright 2012-2025 Olivier Friard
+
+This file is part of BORIS.
+
+  BORIS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 3 of the License, or
+  any later version.
+
+  BORIS is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not see <http://www.gnu.org/licenses/>.
+
+"""
+
+import socket
+import json
+import subprocess
+
+import logging
+import config as cfg
+
+logger = logging.getLogger(__name__)
+
+
+class IPC_MPV:
+    """
+    class for managing mpv through Inter Process Communication (IPC)
+    """
+
+    media_durations: list = []
+    cumul_media_durations: list = []
+    fps: list = []
+    _pause: bool = False
+
+    def __init__(self, socket_path: str = cfg.MPV_SOCKET, parent=None):
+        # print(f"{parent=}")
+        self.socket_path = socket_path
+        self.process = None
+        # self.sock = None
+        self.init_mpv()
+        # self.init_socket()
+
+    def init_mpv(self):
+        """
+        Start mpv process and embed it in the PySide6 application.
+        """
+        logger.info("Start mpv ipc process")
+        # print(f"{self.winId()=}")
+        self.process = subprocess.Popen(
+            [
+                "mpv",
+                "--ontop",
+                "--no-border",
+                "--osc=no",  # no on screen commands
+                "--input-ipc-server=" + self.socket_path,
+                # "--wid=" + str(int(self.winId())),  # Embed in the widget
+                "--idle",  # Keeps mpv running with no video
+                "--input-default-bindings=no",
+                "--input-vo-keyboard=no",
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+    def send_command(self, command):
+        """
+        Send a JSON command to the mpv IPC server.
+        """
+        # print(f"send command: {command}")
+        try:
+            # Create a Unix socket
+            with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client:
+                # Connect to the MPV IPC server
+                client.connect(self.socket_path)
+                # Send the JSON command
+                # print(f"{json.dumps(command).encode('utf-8')=}")
+                client.sendall(json.dumps(command).encode("utf-8") + b"\n")
+                # Receive the response
+                response = client.recv(2000)
+
+                # print(f"{response=}")
+                # Parse the response as JSON
+                response_data = json.loads(response.decode("utf-8"))
+                if response_data["error"] != "success":
+                    logging.warning(f"send command: {command} response data: {response_data}")
+                # Return the 'data' field which contains the playback position
+                return response_data.get("data")
+        except FileNotFoundError:
+            logger.critical("Error: Socket file not found.")
+        except Exception as e:
+            logger.critical(f"An error occurred: {e}")
+        return None
+
+    @property
+    def time_pos(self):
+        time_pos = self.send_command({"command": ["get_property", "time-pos"]})
+        return time_pos
+
+    @property
+    def duration(self):
+        duration_ = self.send_command({"command": ["get_property", "duration"]})
+        return duration_
+
+    @property
+    def video_zoom(self):
+        return self.send_command({"command": ["get_property", "video-zoom"]})
+
+    @video_zoom.setter
+    def video_zoom(self, value):
+        self.send_command({"command": ["set_property", "video-zoom", value]})
+        return
+
+    @property
+    def pause(self):
+        return self.send_command({"command": ["get_property", "pause"]})
+
+    @pause.setter
+    def pause(self, value):
+        return self.send_command({"command": ["set_property", "pause", value]})
+
+    @property
+    def estimated_frame_number(self):
+        return self.send_command({"command": ["get_property", "estimated-frame-number"]})
+
+    def stop(self):
+        self.send_command({"command": ["stop"]})
+        return
+
+    @property
+    def playlist(self):
+        return self.send_command({"command": ["get_property", "playlist"]})
+
+    def playlist_next(self):
+        self.send_command({"command": ["playlist-next"]})
+        return
+
+    def playlist_prev(self):
+        self.send_command({"command": ["playlist-prev"]})
+        return
+
+    @property
+    def playlist_pos(self):
+        return self.send_command({"command": ["get_property", "playlist-pos"]})
+
+    @playlist_pos.setter
+    def playlist_pos(self, value):
+        return self.send_command({"command": ["set_property", "playlist-pos", value]})
+
+    @property
+    def playlist_count(self):
+        return self.send_command({"command": ["get_property", "playlist-count"]})
+
+    def playlist_append(self, media):
+        return self.send_command({"command": ["loadfile", media, "append"]})
+
+    def wait_until_playing(self):
+        return
+
+    def seek(self, value, mode: str):
+        self.send_command({"command": ["seek", value, mode]})
+        return
+
+    @property
+    def playback_time(self):
+        playback_time_ = self.send_command({"command": ["get_property", "playback-time"]})
+        return playback_time_
+
+    def frame_step(self):
+        self.send_command({"command": ["frame-step"]})
+        return
+
+    def frame_back_step(self):
+        self.send_command({"command": ["frame-back-step"]})
+        return
+
+    def screenshot_to_file(self, value):
+        self.send_command({"command": ["screenshot-to-file", value, "video"]})
+        return
+
+    @property
+    def speed(self):
+        return self.send_command({"command": ["get_property", "speed"]})
+
+    @speed.setter
+    def speed(self, value):
+        self.send_command({"command": ["set_property", "speed", value]})
+        return
+
+    @property
+    def video_rotate(self):
+        return self.send_command({"command": ["get_property", "video-rotate"]})
+
+    @video_rotate.setter
+    def video_rotate(self, value):
+        self.send_command({"command": ["set_property", "video-rotate", value]})
+        return
+
+    @property
+    def sub_visibility(self):
+        return self.send_command({"command": ["get_property", "sub-visibility"]})
+
+    @sub_visibility.setter
+    def sub_visibility(self, value):
+        self.send_command({"command": ["set_property", "sub-visibility", value]})
+        return
+
+    @property
+    def brightness(self):
+        return self.send_command({"command": ["get_property", "brightness"]})
+
+    @brightness.setter
+    def brightness(self, value):
+        self.send_command({"command": ["set_property", "brightness", value]})
+        return
+
+    @property
+    def contrast(self):
+        return self.send_command({"command": ["get_property", "contrast"]})
+
+    @contrast.setter
+    def contrast(self, value):
+        self.send_command({"command": ["set_property", "contrast", value]})
+        return
+
+    @property
+    def saturation(self):
+        return self.send_command({"command": ["get_property", "saturation"]})
+
+    @saturation.setter
+    def saturation(self, value):
+        self.send_command({"command": ["set_property", "saturation", value]})
+        return
+
+    @property
+    def gamma(self):
+        return self.send_command({"command": ["get_property", "gamma"]})
+
+    @gamma.setter
+    def gamma(self, value):
+        self.send_command({"command": ["set_property", "gamma", value]})
+        return
+
+    @property
+    def hue(self):
+        return self.send_command({"command": ["get_property", "hue"]})
+
+    @hue.setter
+    def hue(self, value):
+        self.send_command({"command": ["set_property", "hue", value]})
+        return
+
+    @property
+    def container_fps(self):
+        return self.send_command({"command": ["get_property", "container-fps"]})
+
+    @property
+    def width(self):
+        return self.send_command({"command": ["get_property", "width"]})
+
+    @property
+    def height(self):
+        return self.send_command({"command": ["get_property", "height"]})
+
+    @property
+    def video_format(self):
+        return self.send_command({"command": ["get_property", "video-format"]})
+
+    @property
+    def deinterlace(self):
+        return self.send_command({"command": ["get_property", "deinterlace"]})
+
+    @deinterlace.setter
+    def deinterlace(self, value):
+        self.send_command({"command": ["set_property", "deinterlace", value]})
+        return
+
+    @property
+    def audio_bitrate(self):
+        return self.send_command({"command": ["get_property", "audio-bitrate"]})
+
+    @property
+    def eof_reached(self):
+        return self.send_command({"command": ["get_property", "eof-reached"]})
+
+    @property
+    def core_idle(self):
+        return self.send_command({"command": ["get_property", "core-idle"]})
+
+    @property
+    def video_pan_x(self):
+        return self.send_command({"command": ["get_property", "video-pan-x"]})
+
+    @video_pan_x.setter
+    def video_pan_x(self, value):
+        self.send_command({"command": ["set_property", "video-pan-x", value]})
+        return
+
+    @property
+    def video_pan_y(self):
+        return self.send_command({"command": ["get_property", "video-pan-y"]})
+
+    @video_pan_y.setter
+    def video_pan_y(self, value):
+        self.send_command({"command": ["set_property", "video-pan-y", value]})
+        return
+
+
+    """
+    @property
+    def xxx(self):
+        return self.send_command({"command": ["get_property", "xxx"]})
+
+    @xxx.setter
+    def xxx(self, value):
+        self.send_command({"command": ["set_property", "xxx", value]})
+        return
+    """

boris/irr.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
@@ -25,7 +25,7 @@ import logging
 from decimal import Decimal as dec
 
 import numpy as np
-from PyQt5.QtWidgets import QInputDialog, QMessageBox
+from PySide6.QtWidgets import QInputDialog, QMessageBox
 
 from . import config as cfg
 from . import db_functions, dialog, project_functions, select_subj_behav
@@ -126,7 +126,7 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     first_event = cursor.execute(
         (
             "SELECT min(start) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
+            f"WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "
         ),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
@@ -134,27 +134,18 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     logging.debug(f"first_event: {first_event}")
 
     last_event = cursor.execute(
-        (
-            "SELECT max(stop) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT max(stop) FROM aggregated_events WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
 
     logging.debug(f"last_event: {last_event}")
 
     nb_events1 = cursor.execute(
-        (
-            "SELECT COUNT(*) FROM aggregated_events "
-            f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1,) + tuple(selected_subjects),
     ).fetchone()[0]
     nb_events2 = cursor.execute(
-        (
-            "SELECT COUNT(*) FROM aggregated_events "
-            f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid2,) + tuple(selected_subjects),
     ).fetchone()[0]
 
@@ -162,10 +153,8 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
 
     currentTime = dec(str(first_event))
     while currentTime <= last_event:
-
         for obsid in [obsid1, obsid2]:
             for subject in selected_subjects:
-
                 s = subj_behav_modif(cursor, obsid, subject, currentTime, interval, include_modifiers)
 
                 if s not in total_states:
@@ -185,11 +174,9 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     seq2 = {}
     currentTime = dec(str(first_event))
     while currentTime <= last_event:
-
         seq1[currentTime] = []
         seq2[currentTime] = []
         for subject in selected_subjects:
-
             s1 = subj_behav_modif(cursor, obsid1, subject, currentTime, interval, include_modifiers)
             s2 = subj_behav_modif(cursor, obsid2, subject, currentTime, interval, include_modifiers)
 
@@ -211,11 +198,7 @@ def cohen_kappa(cursor, obsid1: str, obsid2: str, interval: dec, selected_subjec
     logging.debug(f"contingency_table:\n {contingency_table}")
 
     template = (
-        "Observation: {obsid1}\n"
-        "number of events: {nb_events1}\n\n"
-        "Observation: {obsid2}\n"
-        "number of events: {nb_events2:.0f}\n\n"
-        "K = {K:.3f}"
+        "Observation: {obsid1}\nnumber of events: {nb_events1}\n\nObservation: {obsid2}\nnumber of events: {nb_events2:.0f}\n\nK = {K:.3f}"
     )
 
     # out += "Observation length: <b>{:.3f} s</b><br>".format(self.observationTotalMediaLength(obsid1))
@@ -298,8 +281,8 @@ def irr_cohen_kappa(self):
         selected_observations,
         start_coding=dec("NaN"),
         end_coding=dec("NaN"),
-        flagShowIncludeModifiers=True,
-        flagShowExcludeBehaviorsWoEvents=False,
+        show_include_modifiers=True,
+        show_exclude_non_coded_behaviors=False,
         n_observations=len(selected_observations),
     )
     if parameters == {}:
@@ -309,9 +292,7 @@ def irr_cohen_kappa(self):
         return
 
     # ask for time slice
-    i, ok = QInputDialog.getDouble(
-        self, "IRR - Cohen's Kappa (time-unit)", "Time unit (in seconds):", 1.0, 0.001, 86400, 3
-    )
+    i, ok = QInputDialog.getDouble(self, "IRR - Cohen's Kappa (time-unit)", "Time unit (in seconds):", 1.0, 0.001, 86400, 3)
     if not ok:
         return
     interval = util.float2decimal(i)
@@ -354,7 +335,7 @@ def irr_cohen_kappa(self):
         out2 += "\t".join(["%8.6f" % x for x in irr_results[r, :]]) + "\n"
 
     self.results = dialog.Results_dialog()
-    self.results.setWindowTitle(f"BORIS - IRR - Cohen's Kappa (time-unit) analysis results")
+    self.results.setWindowTitle("BORIS - IRR - Cohen's Kappa (time-unit) analysis results")
     self.results.ptText.setReadOnly(True)
     if len(selected_observations) == 2:
         self.results.ptText.appendPlainText(out)
@@ -363,9 +344,7 @@ def irr_cohen_kappa(self):
     self.results.show()
 
 
-def needleman_wunsch_identity(
-    cursor, obsid1: str, obsid2: str, interval, selected_subjects: list, include_modifiers: bool
-):
+def needleman_wunsch_identity(cursor, obsid1: str, obsid2: str, interval, selected_subjects: list, include_modifiers: bool):
     """
     Needleman - Wunsch identity between 2 observations
 
@@ -408,22 +387,19 @@ def needleman_wunsch_identity(
         align1 = align1[::-1]
         align2 = align2[::-1]
 
-        i, j = 0, 0
-
+        i = 0
         symbol = []
-        found = 0
         score = 0
         identity = 0
         for i in range(0, len(align1)):
             if align1[i] == align2[i]:
                 symbol.append(align1[i])
-                identity = identity + 1
+                identity += 1
                 score += match_score(align1[i], align2[i])
 
             elif align1[i] != align2[i] and align1[i] != "-" and align2[i] != "-":
                 score += match_score(align1[i], align2[i])
                 symbol.append(" ")
-                found = 0
 
             # if one of them is a gap, output a space
             elif align1[i] == "-" or align2[i] == "-":
@@ -487,52 +463,43 @@ def needleman_wunsch_identity(
     first_event = cursor.execute(
         (
             "SELECT min(start) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
+            f"WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "
         ),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
 
     if first_event is None:
         logging.debug(f"An observation has no recorded events: {obsid1} or {obsid2}")
+
         return -100, f"An observation has no recorded events: {obsid1} {obsid2}"
 
     logging.debug(f"first_event: {first_event}")
 
     last_event = cursor.execute(
-        (
-            "SELECT max(start) FROM aggregated_events "
-            f"WHERE observation in (?, ?) AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT max(stop) FROM aggregated_events WHERE observation in (?, ?) AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1, obsid2) + tuple(selected_subjects),
     ).fetchone()[0]
 
     logging.debug(f"last_event: {last_event}")
 
     nb_events1 = cursor.execute(
-        (
-            "SELECT COUNT(*) FROM aggregated_events "
-            f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid1,) + tuple(selected_subjects),
     ).fetchone()[0]
 
     nb_events2 = cursor.execute(
-        (
-            "SELECT COUNT(*) FROM aggregated_events "
-            f"WHERE observation = ? AND subject in ({','.join('?'*len(selected_subjects))}) "
-        ),
+        (f"SELECT COUNT(*) FROM aggregated_events WHERE observation = ? AND subject in ({','.join('?' * len(selected_subjects))}) "),
         (obsid2,) + tuple(selected_subjects),
     ).fetchone()[0]
 
-    seq1, seq2 = {}, {}
+    seq1: dict = {}
+    seq2: dict = {}
 
     currentTime = dec(str(first_event))
     while currentTime <= last_event:
-
         seq1[currentTime], seq2[currentTime] = [], []
 
         for subject in selected_subjects:
-
             s1 = subj_behav_modif(cursor, obsid1, subject, currentTime, interval, include_modifiers)
             s2 = subj_behav_modif(cursor, obsid2, subject, currentTime, interval, include_modifiers)
 
@@ -574,9 +541,7 @@ def needleman_wunch(self):
     if not selected_observations:
         return
     if len(selected_observations) < 2:
-        QMessageBox.information(
-            self, cfg.programName, "You have to select at least 2 observations for Needleman-Wunsch similarity"
-        )
+        QMessageBox.information(self, cfg.programName, "You have to select at least 2 observations for Needleman-Wunsch similarity")
         return
 
     # check if coded behaviors are defined in ethogram
@@ -606,8 +571,8 @@ def needleman_wunch(self):
         selected_observations,
         start_coding=dec("NaN"),
         end_coding=dec("NaN"),
-        flagShowIncludeModifiers=True,
-        flagShowExcludeBehaviorsWoEvents=False,
+        show_include_modifiers=True,
+        show_exclude_non_coded_behaviors=False,
         n_observations=len(selected_observations),
     )
 
@@ -631,9 +596,7 @@ def needleman_wunch(self):
 
     cursor = db_connector.cursor()
     out = (
-        "Needleman-Wunsch similarity\n\n"
-        f"Time unit: {interval:.3f} s\n"
-        f"Selected subjects: {', '.join(parameters[cfg.SELECTED_SUBJECTS])}\n\n"
+        f"Needleman-Wunsch similarity\n\nTime unit: {interval:.3f} s\nSelected subjects: {', '.join(parameters[cfg.SELECTED_SUBJECTS])}\n\n"
     )
     mem_done = []
     nws_results = np.ones((len(selected_observations), len(selected_observations)))
@@ -662,7 +625,7 @@ def needleman_wunch(self):
         out2 += "\t".join([f"{x:8.6f}" for x in nws_results[r, :]]) + "\n"
 
     self.results = dialog.Results_dialog()
-    self.results.setWindowTitle(cfg.programName + " - Needleman-Wunsch similarity")
+    self.results.setWindowTitle(f"{cfg.programName} - Needleman-Wunsch similarity")
     self.results.ptText.setReadOnly(True)
     if len(selected_observations) == 2:
         self.results.ptText.appendPlainText(out)