boris-behav-obs 9.2.1__tar.gz → 9.2.2__tar.gz

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: boris-behav-obs
-Version: 9.2.1
+Version: 9.2.2
 Summary: BORIS - Behavioral Observation Research Interactive Software
 Author-email: Olivier Friard <olivier.friard@unito.it>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -686,13 +686,10 @@ Project-URL: Issues, https://github.com/olivierfriard/BORIS/issues
 Classifier: Topic :: Scientific/Engineering
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Education
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.12
 Description-Content-Type: text/x-rst
 License-File: LICENSE.TXT
@@ -705,7 +702,7 @@ Requires-Dist: pyreadr
 Requires-Dist: pyside6==6.8.0.2
 Requires-Dist: hachoir>=3.3.0
 Provides-Extra: dev
-Requires-Dist: black; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/behavior_binary_table.py

@@ -80,12 +80,12 @@ def create_behavior_binary_table(pj: dict, selected_observations: list, paramete
                 end_time = dec(max_obs_length)
 
         if parameters_obs["time"] == cfg.TIME_OBS_INTERVAL:
-            obs_interval = pj[cfg.OBSERVATIONS][obs_id][cfg.OBSERVATION_TIME_INTERVAL]
+            obs_interval = pj[cfg.OBSERVATIONS][obs_id].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])
             offset = pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET]
             start_time = dec(obs_interval[0]) + offset
             # Use max observation length for end time if no interval is defined (=0)
             max_obs_length, _ = observation_operations.observation_length(pj, [obs_id])
-            end_time = dec(obs_interval[1]) + offset if obs_interval[1] != 0 else dec(max_obs_length)
+            end_time = dec(obs_interval[1]) + offset if obs_interval[1] not in (0, None) else dec(max_obs_length)
 
         if obs_id not in results_df:
             results_df[obs_id] = {}
@@ -166,8 +166,8 @@ def behavior_binary_table(self):
         None,
         cfg.programName,
         (
-            "Depending of the length of your observations "
-            "the execution of this function may be very long.<br>"
+            "Depending on the length of yours observations "
+            "the execution of this function may take a long time.<br>"
             "The program interface may freeze, be patient. <br>"
         ),
     )
@@ -216,8 +216,6 @@ def behavior_binary_table(self):
         selected_observations,
         start_coding=start_coding,
         end_coding=end_coding,
-        # start_interval=start_interval,
-        # end_interval=end_interval,
         start_interval=start_interval,
         end_interval=end_interval,
         maxTime=max_media_duration_all_obs,

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/core.py

@@ -3639,10 +3639,9 @@ class MainWindow(QMainWindow, Ui_MainWindow):
                 self.liveTimer.stop()
                 self.liveObservationStarted = False
                 # set current time to end of observation interval
-                current_time = dec(self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[1])                
+                current_time = dec(self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[1])
                 self.pb_live_obs.setText("Live observation finished")
 
-
         self.lb_current_media_time.setText(util.convertTime(self.timeFormat, current_time))
 
         # extract State events
@@ -3672,7 +3671,6 @@ class MainWindow(QMainWindow, Ui_MainWindow):
                 self.liveTimer.stop()
                 self.pb_live_obs.setText("Live observation stopped (scan sampling)")
 
-
     def start_live_observation(self):
         """
         activate the live observation mode
@@ -5754,10 +5752,7 @@ class MainWindow(QMainWindow, Ui_MainWindow):
         if self.playerType == cfg.MEDIA:
             self.pause_video()
 
-            if cfg.OBSERVATION_TIME_INTERVAL in self.pj[cfg.OBSERVATIONS][self.observationId]:
-                self.seek_mediaplayer(int(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.OBSERVATION_TIME_INTERVAL][0]))
-            else:
-                self.seek_mediaplayer(0)
+            self.seek_mediaplayer(int(self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[0]))
 
             self.update_visualizations()
 

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/export_events.py

@@ -788,7 +788,7 @@ def export_events_as_textgrid(self) -> None:
 
         if parameters["time"] == cfg.TIME_OBS_INTERVAL:
             max_media_duration, _ = observation_operations.media_duration(self.pj[cfg.OBSERVATIONS], [obs_id])
-            obs_interval = self.pj[cfg.OBSERVATIONS][obs_id][cfg.OBSERVATION_TIME_INTERVAL]
+            obs_interval = self.pj[cfg.OBSERVATIONS][obs_id].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])
             offset = float(self.pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET])
             min_time = float(obs_interval[0]) + offset
             # Use max media duration for max time if no interval is defined (=0)

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/observation_operations.py

@@ -359,14 +359,20 @@ def time_intervals_range(observations: dict, observations_list: list) -> Tuple[O
         decimal.Decimal: time of latest end interval
 
     """
-    start_interval_list = []
-    end_interval_list = []
+    start_interval_list: list = []
+    end_interval_list: list = []
     for obs_id in observations_list:
         observation = observations[obs_id]
         offset = observation[cfg.TIME_OFFSET]
-        if dec(observation[cfg.OBSERVATION_TIME_INTERVAL][0]) + offset and dec(observation[cfg.OBSERVATION_TIME_INTERVAL][1]) + offset:
-            start_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][0]) + offset)
-            end_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][1]) + offset)
+        # check if observation interval is defined
+        if (
+            not observation.get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[0]
+            and not observation.get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[1]
+        ):
+            return None, None
+
+        start_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][0]) + offset)
+        end_interval_list.append(dec(observation[cfg.OBSERVATION_TIME_INTERVAL][1]) + offset)
 
     if not start_interval_list:
         earliest_start_interval = None
@@ -872,8 +878,8 @@ def new_observation(self, mode: str = cfg.NEW, obsId: str = "") -> None:
             observationWindow.cb_observation_time_interval.setText(
                 (
                     "Limit observation to a time interval: "
-                    f"{self.pj[cfg.OBSERVATIONS][obsId][cfg.OBSERVATION_TIME_INTERVAL][0]} - "
-                    f"{self.pj[cfg.OBSERVATIONS][obsId][cfg.OBSERVATION_TIME_INTERVAL][1]}"
+                    f"{self.pj[cfg.OBSERVATIONS][obsId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[0]} - "
+                    f"{self.pj[cfg.OBSERVATIONS][obsId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[1]}"
                 )
             )
 
@@ -1950,8 +1956,9 @@ def initialize_new_media_observation(self) -> bool:
             )
 
             # position media
-            if cfg.OBSERVATION_TIME_INTERVAL in self.pj[cfg.OBSERVATIONS][self.observationId]:
-                self.seek_mediaplayer(int(self.pj[cfg.OBSERVATIONS][self.observationId][cfg.OBSERVATION_TIME_INTERVAL][0]), player=i)
+            self.seek_mediaplayer(
+                int(self.pj[cfg.OBSERVATIONS][self.observationId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])[0]), player=i
+            )
 
             # restore video zoom level
             if cfg.ZOOM_LEVEL in self.pj[cfg.OBSERVATIONS][self.observationId][cfg.MEDIA_INFO]:

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/player_dock_widget.py

@@ -23,7 +23,18 @@ This file is part of BORIS.
 import sys
 import logging
 import functools
-from PySide6.QtWidgets import QLabel, QDockWidget, QWidget, QHBoxLayout, QVBoxLayout, QSlider, QSizePolicy, QStackedWidget, QToolButton
+from PySide6.QtWidgets import (
+    QApplication,
+    QLabel,
+    QDockWidget,
+    QWidget,
+    QHBoxLayout,
+    QVBoxLayout,
+    QSlider,
+    QSizePolicy,
+    QStackedWidget,
+    QToolButton,
+)
 from PySide6.QtCore import Signal, QEvent, Qt
 from PySide6.QtGui import QIcon, QAction
 
@@ -141,7 +152,10 @@ class DW_player(QDockWidget):
         self.mute_button.setFocusPolicy(Qt.NoFocus)
         self.mute_button.setAutoRaise(True)
         self.mute_action = QAction()
-        self.mute_action.setIcon(QIcon(":/volume_xmark"))
+
+        theme_mode = "dark" if QApplication.instance().palette().window().color().value() < 128 else "light"
+
+        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)
 
@@ -180,10 +194,11 @@ class DW_player(QDockWidget):
         """
         emit signal when mute action is triggered
         """
+        theme_mode = "dark" if QApplication.instance().palette().window().color().value() < 128 else "light"
         if self.player.mute:
-            self.mute_action.setIcon(QIcon(":/volume_xmark"))
+            self.mute_action.setIcon(QIcon(f":/volume_xmark_{theme_mode}"))
         else:
-            self.mute_action.setIcon(QIcon(":/volume_off"))
+            self.mute_action.setIcon(QIcon(f":/volume_off_{theme_mode}"))
         self.mute_action_triggered_signal.emit(self.id_)
 
     def keyPressEvent(self, event):

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/plot_events.py

@@ -441,7 +441,7 @@ def create_events_plot(
             max_time = float(obs_length)
 
         if interval == cfg.TIME_OBS_INTERVAL:
-            obs_interval = self.pj[cfg.OBSERVATIONS][obs_id][cfg.OBSERVATION_TIME_INTERVAL]
+            obs_interval = self.pj[cfg.OBSERVATIONS][obs_id].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])
             offset = float(self.pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET])
             min_time = float(obs_interval[0]) + offset
             # Use max media duration for max time if no interval is defined (=0)

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/plugins.py

@@ -65,24 +65,44 @@ def load_plugins(self):
     """
     load selected plugins in analysis menu
     """
+
+    def msg():
+        QMessageBox.warning(
+            self,
+            cfg.programName,
+            f"A plugin with the same name is already loaded ({self.config_param[cfg.ANALYSIS_PLUGINS][plugin_name]}).\n\nThe plugin from {file_} is not loaded.",
+            QMessageBox.Ok | QMessageBox.Default,
+            QMessageBox.NoButton,
+        )
+
     self.menu_plugins.clear()
     self.config_param[cfg.ANALYSIS_PLUGINS] = {}
 
     # load BORIS plugins
-    for file_ in (Path(__file__).parent / "analysis_plugins").glob("*.py"):
+    for file_ in sorted((Path(__file__).parent / "analysis_plugins").glob("*.py")):
         if file_.name == "__init__.py":
             continue
         plugin_name = get_plugin_name(file_)
         if plugin_name is not None and plugin_name not in self.config_param.get(cfg.EXCLUDED_PLUGINS, set()):
+            # check if plugin with same name already loaded
+            if plugin_name in self.config_param[cfg.ANALYSIS_PLUGINS]:
+                msg()
+                continue
+
             self.config_param[cfg.ANALYSIS_PLUGINS][plugin_name] = str(file_)
 
     # load personal plugins
     if self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, ""):
-        for file_ in Path(self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, "")).glob("*.py"):
+        for file_ in sorted(Path(self.config_param.get(cfg.PERSONAL_PLUGINS_DIR, "")).glob("*.py")):
             if file_.name == "__init__.py":
                 continue
             plugin_name = get_plugin_name(file_)
             if plugin_name is not None and plugin_name not in self.config_param.get(cfg.EXCLUDED_PLUGINS, set()):
+                # check if plugin with same name already loaded
+                if plugin_name in self.config_param[cfg.ANALYSIS_PLUGINS]:
+                    msg()
+                    continue
+
                 self.config_param[cfg.ANALYSIS_PLUGINS][plugin_name] = str(file_)
 
     logging.debug(f"{self.config_param.get(cfg.ANALYSIS_PLUGINS, {})=}")
@@ -108,7 +128,7 @@ def plugin_df_filter(df: pd.DataFrame, observations_list: list = [], parameters:
         # filter selected behaviors
         df = df[df["Behavior"].isin(parameters["selected behaviors"])]
 
-        if parameters["time"] == "interval of observation":
+        if parameters["time"] == cfg.TIME_OBS_INTERVAL:
             # filter each observation with observation interval start/stop
 
             # keep events between observation interval start time and observation interval stop/end
@@ -142,6 +162,7 @@ def plugin_df_filter(df: pd.DataFrame, observations_list: list = [], parameters:
                     | ((df["Start (s)"] < MIN_TIME) & (df["Stop (s)"] > MAX_TIME))
                 ]
 
+                # cut state events to interval
                 df_interval.loc[df["Start (s)"] < MIN_TIME, "Start (s)"] = MIN_TIME
                 df_interval.loc[df["Stop (s)"] > MAX_TIME, "Stop (s)"] = MAX_TIME
 
@@ -152,7 +173,7 @@ def plugin_df_filter(df: pd.DataFrame, observations_list: list = [], parameters:
     print("filtered")
     print("=" * 50)
 
-    print(f"{df=}")
+    # print(f"{df=}")
 
     return df
 
@@ -205,8 +226,12 @@ def run_plugin(self, plugin_name):
     if not selected_observations:
         return
 
+    logging.info("preparing dtaaframe for plugin")
+
     df = project_functions.project2dataframe(self.pj, selected_observations)
 
+    logging.info("done")
+
     """
     logging.debug("dataframe info")
     logging.debug(f"{df.info()}")
@@ -214,7 +239,9 @@ def run_plugin(self, plugin_name):
     """
 
     # filter the dataframe with parameters
+    logging.info("filtering dataframe for plugin")
     filtered_df = plugin_df_filter(df, observations_list=selected_observations, parameters=parameters)
+    logging.info("done")
 
     plugin_results = plugin_module.run(filtered_df)
     # test if plugin_tests is a tuple: if not transform to tuple

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/project_functions.py

@@ -1899,20 +1899,12 @@ def project2dataframe(pj: dict, observations_list: list = []) -> pd.DataFrame:
             if idx_event in stop_event_idx:
                 continue
             data["Observation id"].append(obs_id)
-            data["Observation date"].append(pj["observations"][obs_id]["date"])
-            data["Description"].append(" ".join(pj["observations"][obs_id]["description"].splitlines()))
-            data["Observation type"].append(pj["observations"][obs_id]["type"])
-
-            data["Observation interval start"].append(
-                pj["observations"][obs_id]["observation time interval"][0]
-                if pj["observations"][obs_id]["observation time interval"][0]
-                else None
-            )
-            data["Observation interval stop"].append(
-                pj["observations"][obs_id]["observation time interval"][1]
-                if pj["observations"][obs_id]["observation time interval"][1]
-                else None
-            )
+            data["Observation date"].append(pj[cfg.OBSERVATIONS][obs_id]["date"])
+            data["Description"].append(" ".join(pj[cfg.OBSERVATIONS][obs_id]["description"].splitlines()))
+            data["Observation type"].append(pj[cfg.OBSERVATIONS][obs_id]["type"])
+
+            data["Observation interval start"].append(pj[cfg.OBSERVATIONS][obs_id].get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[0])
+            data["Observation interval stop"].append(pj[cfg.OBSERVATIONS][obs_id].get(cfg.OBSERVATION_TIME_INTERVAL, [None, None])[1])
 
             # data["Source"].append("")
             # data["Time offset (s)"].append(pj["observations"][obs_id]["time offset"])

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/time_budget_functions.py

@@ -260,7 +260,7 @@ def synthetic_time_budget_bin(pj: dict, selected_observations: list, parameters_
             max_time = dec(end_time)
 
         if time_interval == cfg.TIME_OBS_INTERVAL:
-            obs_interval = pj[cfg.OBSERVATIONS][obs_id][cfg.OBSERVATION_TIME_INTERVAL]
+            obs_interval = pj[cfg.OBSERVATIONS][obs_id].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])
             offset = pj[cfg.OBSERVATIONS][obs_id][cfg.TIME_OFFSET]
             min_time = dec(obs_interval[0]) + offset
             # Use max media duration for max time if no interval is defined (=0)

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/time_budget_widget.py

@@ -504,7 +504,7 @@ def time_budget(self, mode: str, mode2: str = "list"):
                     max_time = float(obs_length)
 
             if parameters[cfg.TIME_INTERVAL] == cfg.TIME_OBS_INTERVAL:
-                obs_interval = self.pj[cfg.OBSERVATIONS][obsId][cfg.OBSERVATION_TIME_INTERVAL]
+                obs_interval = self.pj[cfg.OBSERVATIONS][obsId].get(cfg.OBSERVATION_TIME_INTERVAL, [0, 0])
                 offset = float(self.pj[cfg.OBSERVATIONS][obsId][cfg.TIME_OFFSET])
                 min_time = float(obs_interval[0]) + offset
                 # Use max media duration for max time if no interval is defined (=0)

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/utilities.py

@@ -1456,8 +1456,6 @@ def accurate_media_analysis(ffmpeg_bin: str, file_name: str) -> dict:
 
     ffprobe_results = ffprobe_media_analysis(ffmpeg_bin, file_name)
 
-    print(f"{ffprobe_results=}")
-
     logging.debug(f"file_name: {file_name}")
     logging.debug(f"ffprobe_results: {ffprobe_results}")
 

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris/version.py

@@ -20,5 +20,5 @@ This file is part of BORIS.
 
 """
 
-__version__ = "9.2.1"
-__version_date__ = "2025-03-17"
+__version__ = "9.2.2"
+__version_date__ = "2025-03-28"

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris_behav_obs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: boris-behav-obs
-Version: 9.2.1
+Version: 9.2.2
 Summary: BORIS - Behavioral Observation Research Interactive Software
 Author-email: Olivier Friard <olivier.friard@unito.it>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -686,13 +686,10 @@ Project-URL: Issues, https://github.com/olivierfriard/BORIS/issues
 Classifier: Topic :: Scientific/Engineering
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Education
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.12
 Description-Content-Type: text/x-rst
 License-File: LICENSE.TXT
@@ -705,7 +702,7 @@ Requires-Dist: pyreadr
 Requires-Dist: pyside6==6.8.0.2
 Requires-Dist: hachoir>=3.3.0
 Provides-Extra: dev
-Requires-Dist: black; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris_behav_obs.egg-info/SOURCES.txt

@@ -114,4 +114,5 @@ tests/test_otx_parser.py
 tests/test_preferences_gui.py
 tests/test_project_functions.py
 tests/test_time_budget.py
-tests/test_utilities.py
+tests/test_utilities.py
+tests/test_utilities2.py

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/boris_behav_obs.egg-info/requires.txt

@@ -8,7 +8,6 @@ pyside6==6.8.0.2
 hachoir>=3.3.0
 
 [dev]
-black
 ruff
 pytest
 pytest-cov

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "boris-behav-obs"
-version = "9.2.1"
+version = "9.2.2"
 description = "BORIS - Behavioral Observation Research Interactive Software"
 authors = [{ name="Olivier Friard", email="olivier.friard@unito.it" }]
 readme = "README.rst"
@@ -10,13 +10,10 @@ classifiers=[
         "Topic :: Scientific/Engineering",
         "Intended Audience :: Science/Research",
         "Intended Audience :: Education",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",        
         "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
         "Operating System :: OS Independent",
+        "Topic :: Scientific/Engineering",
     ]
 dependencies = [
     "exifread>=3.0.0",
@@ -30,7 +27,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-dev = ["black", "ruff", "pytest", "pytest-cov"]
+dev = ["ruff", "pytest", "pytest-cov"]
 
 [project.urls]
 Homepage = "http://www.boris.unito.it"
@@ -42,10 +39,6 @@ Issues = "https://github.com/olivierfriard/BORIS/issues"
 [project.scripts]
 boris-behav-obs = "boris:main"
 
-[build-system]
-requires = ["setuptools", "wheel"]
-build-backend = "setuptools.build_meta"
-
 
 [tool.distutils.bdist_wheel]
 universal = true
@@ -55,7 +48,7 @@ line-length = 140
 exclude = ["*_ui.py", "mpv*"]
 
 [tool.bumpver]
-current_version = "9.2.1"
+current_version = "9.2.2"
 version_pattern = "MAJOR.MINOR.PATCH"
 
 

{boris_behav_obs-9.2.1 → boris_behav_obs-9.2.2}/tests/test_utilities.py

@@ -44,6 +44,8 @@ class Test_accurate_media_analysis(object):
             "resolution": "640x480",
         }
 
+
+"""
     def test_no_media(self):
         r = utilities.accurate_media_analysis("ffmpeg", "files/test.boris")
         assert "error" in r
@@ -358,10 +360,14 @@ class Test_get_current_states_by_subject(object):
 
 
 """
+
+
 class Test_get_ip_address(object):
     def test_1(self):
         print(utilities.get_ip_address())
         assert False
+
+
 """
 
 
@@ -587,3 +593,4 @@ class Test_versiontuple(object):
     def test_4(self):
         r = utilities.versiontuple("")
         assert r == ("00000000",)
+"""

boris_behav_obs-9.2.2/tests/test_utilities2.py

@@ -0,0 +1,124 @@
+import sys
+import os
+import pytest
+import subprocess
+from unittest.mock import patch, MagicMock
+import logging
+
+# Assuming the function is imported from a module named `media_analysis`
+# from media_analysis import accurate_media_analysis
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+
+from boris import utilities
+from boris import config
+
+
+# Mocking the ffprobe_media_analysis function
+def mock_ffprobe_media_analysis(ffmpeg_bin, file_name):
+    return {
+        "duration": 120,
+        "duration_ms": 120000,
+        "bitrate": 5000,
+        "frames_number": 3000,
+        "fps": 25,
+        "has_video": True,
+        "has_audio": True,
+    }
+
+
+# Mocking the time2seconds function
+def mock_time2seconds(time_str):
+    return 120
+
+
+# Mocking the dec function
+def mock_dec(value):
+    return float(value)
+
+
+@patch("utilities.ffprobe_media_analysis", side_effect=mock_ffprobe_media_analysis)
+@patch("utilities.time2seconds", side_effect=mock_time2seconds)
+@patch("utilities.dec", side_effect=mock_dec)
+def test_accurate_media_analysis_success(mock_dec, mock_time2seconds, mock_ffprobe_media_analysis):
+    ffmpeg_bin = "/path/to/ffmpeg"
+    file_name = "test_video.mp4"
+
+    result = utilities.accurate_media_analysis(ffmpeg_bin, file_name)
+
+    assert result["duration"] == 120
+    assert result["duration_ms"] == 120000
+    assert result["bitrate"] == 5000
+    assert result["frames_number"] == 3000
+    assert result["fps"] == 25
+    assert result["has_video"] is True
+    assert result["has_audio"] is True
+
+
+"""
+
+@patch("utilities.ffprobe_media_analysis", return_value={"error": "ffprobe failed"})
+@patch("utilities.time2seconds", side_effect=mock_time2seconds)
+@patch("utilities.dec", side_effect=mock_dec)
+@patch("subprocess.Popen")
+def test_accurate_media_analysis_fallback(mock_popen, mock_dec, mock_time2seconds, mock_ffprobe_media_analysis):
+    ffmpeg_bin = "/path/to/ffmpeg"
+    file_name = "test_video.mp4"
+
+    # Mocking the subprocess.Popen behavior
+    mock_process = MagicMock()
+    mock_process.communicate.return_value = (
+        b"",
+        b"Duration: 00:02:00.00, bitrate: 5000 kb/s\nStream #0:0: Video: h264, 1920x1080, 25 fps\nStream #0:1: Audio: aac",
+    )
+    mock_popen.return_value = mock_process
+
+    result = utilities.accurate_media_analysis(ffmpeg_bin, file_name)
+
+    assert result["duration"] == 120
+    assert result["duration_ms"] == 120000
+    assert result["bitrate"] == 5000000
+    assert result["frames_number"] == 3000
+    assert result["fps"] == 25
+    assert result["has_video"] is True
+    assert result["has_audio"] is True
+
+
+@patch("utilities.ffprobe_media_analysis", return_value={"error": "ffprobe failed"})
+@patch("utilities.time2seconds", side_effect=mock_time2seconds)
+@patch("utilities.dec", side_effect=mock_dec)
+@patch("subprocess.Popen")
+def test_accurate_media_analysis_file_not_found(mock_popen, mock_dec, mock_time2seconds, mock_ffprobe_media_analysis):
+    ffmpeg_bin = "/path/to/ffmpeg"
+    file_name = "nonexistent_video.mp4"
+
+    # Mocking the subprocess.Popen behavior
+    mock_process = MagicMock()
+    mock_process.communicate.return_value = (b"", b"No such file or directory")
+    mock_popen.return_value = mock_process
+
+    result = utilities.accurate_media_analysis(ffmpeg_bin, file_name)
+
+    assert result["error"] == "No such file or directory"
+
+
+@patch("utilities.ffprobe_media_analysis", return_value={"error": "ffprobe failed"})
+@patch("utilities.time2seconds", side_effect=mock_time2seconds)
+@patch("utilities.dec", side_effect=mock_dec)
+@patch("subprocess.Popen")
+def test_accurate_media_analysis_invalid_media(mock_popen, mock_dec, mock_time2seconds, mock_ffprobe_media_analysis):
+    ffmpeg_bin = "/path/to/ffmpeg"
+    file_name = "invalid_media.mp4"
+
+    # Mocking the subprocess.Popen behavior
+    mock_process = MagicMock()
+    mock_process.communicate.return_value = (b"", b"Invalid data found when processing input")
+    mock_popen.return_value = mock_process
+
+    result = utilities.accurate_media_analysis(ffmpeg_bin, file_name)
+
+    assert result["error"] == "This file does not seem to be a media file"
+
+
+"""