Merge branch 'main' into main

Author: k1o0

README.md

@@ -14,3 +14,12 @@ pip install -e .
 - `projects/task_type_procedures.json` - Associate Alyx procedures to a custom task protocol
 - `projects/_template.py` - Example for creating a custom Bpod extractor, QC or DAQ sync task
 - `projects/extraction_tasks.py` - Where to import pipeline tasks so they are readable by ibllib
+
+## Contributing
+
+To contribute to this repository you must create a pull request into main. Before merging you must increase the version number in the [pyproject.toml](./pyproject.toml) file (see [this guide](https://packaging.python.org/en/latest/specifications/version-specifiers/#version-specifiers) for versioning scheme).
+A GitHub check will ensure that the repository version is valid and greater than the version on the main branch. This is essential as we currently do not publish to PyPi.
+The pull request may be merged only when this check passes.  Bypassing this check is not permitted, nor are direct pushes to main. Once merged, a version tag is automatically generated.
+
+> [!IMPORTANT]
+> Tests in this repository are run by both the [iblrig](https://github.com/int-brain-lab/iblrig) and [ibllib](https://github.com/int-brain-lab/ibllib) CI.

iblrig_custom_tasks/_sp_passiveVideo/__init__.py

@@ -4,8 +4,10 @@
 TODO Add custom task list to Session class
 """
 import time
+import shutil
 from pathlib import Path
 from collections import defaultdict
+from functools import partial
 import logging
 import warnings
 
@@ -15,7 +17,7 @@
 import iblrig.misc
 from iblrig.base_tasks import BpodMixin
 
-_logger = logging.getLogger(__name__)
+_logger = logging.getLogger(f'iblrig.{__name__}')
 
 # this allows the CI and automated tests to import the file and make sure it is valid without having vlc
 try:
@@ -27,26 +29,60 @@
         'git+https://github.com/int-brain-lab/project_extraction.git"', RuntimeWarning)
 
 
+class MediaStats(vlc.MediaStats):
+    """A class to store media stats."""
+
+    def fieldnames(self):
+        """Return the field names."""
+        return zip(*self._fields_)[0]
+
+    def as_tuple(self):
+        """Return all attribute values as a tuple."""
+        return tuple(map(partial(getattr, self), self.fieldnames()))
+
+
 class Player:
     """A VLC player."""
-    def __init__(self, rate=1, logger=None):
+    def __init__(self, rate=1):
         self._instance = vlc.Instance(['--video-on-top'])
         self._player = self._instance.media_player_new()
         self._player.set_fullscreen(True)
         self._player.set_rate(rate)
         self._media = None
+        self._media_stats = MediaStats()
+        self._stats = []
         self.events = defaultdict(list)
-        self.logger = logger or _logger
         em = self._player.event_manager()
         for event in (vlc.EventType.MediaPlayerPlaying, vlc.EventType.MediaPlayerEndReached):
             em.event_attach(event, self._record_event)
 
     def _record_event(self, event):
         """VLC event callback."""
-        self.logger.debug('%s', event.type)
+        _logger.debug('%s', event.type)
         # Have to convert to str as object pointer may change
         self.events[str(event.type).split('.')[-1]].append(time.time())
 
+    def update_media_stats(self):
+        """Update media stats.
+
+        Returns
+        -------
+        bool
+            True if the stats have changed since the last update.
+        """
+        if not vlc.libvlc_media_get_stats(self._player.get_media(), self._media_stats):
+            return False
+        stats = tuple((time.time(), *self._media_stats.as_tuple()))
+        if not any(self._stats) or stats[1:] != self._stats[-1][1:]:
+            self._stats.append(stats)
+            return True
+        return False
+
+    @property
+    def stats(self):
+        """Return media stats."""
+        return pd.DataFrame(self._stats, columns=['time', *self._media_stats.fieldnames()])
+
     def play(self, path):
         """Play a video.
 
@@ -102,69 +138,102 @@ def get_ended_time(self, repeat=-1):
         elif repeat == -1 or len(ends) > repeat:
             return ends[repeat]
 
+    def get_media_length(self):
+        """
+        Return length of the video in seconds.
+
+        Returns
+        -------
+        float, None
+            The length of the video in seconds when played at the provided frame rate.
+            None is returned when no video is loaded.
+        """
+        if self._media:
+            length = self._media.get_length()
+            if length > -1:
+                return length / 1e3
+
 
 class Session(BpodMixin):
     """Play a single video."""
 
     protocol_name = '_sp_passiveVideo'
+    extractor_tasks = ['PassiveVideoTimeline']
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         if self.hardware_settings.get('MAIN_SYNC', False):
             raise NotImplementedError('Recording frame2ttl on Bpod not yet implemented')
         self.paths.DATA_FILE_PATH = self.paths.DATA_FILE_PATH.with_name('_sp_taskData.raw.pqt')
+        self.paths.STATS_FILE_PATH = self.paths.DATA_FILE_PATH.with_name('_sp_videoData.stats.pqt')
         self.video = None
         self.trial_num = -1
+        # For py3.11 use logging.getLevelNamesMapping instead
+        self._log_level = logging.getLevelName(kwargs.get('log_level', 'INFO'))
         columns = ['intervals_0', 'intervals_1']
         self.data = pd.DataFrame(pd.NA, index=range(self.task_params.NREPEATS), columns=columns)
 
     def save(self):
-        self.logger.info('Saving data')
+        _logger.info('Saving data')
         if self.video:
             data = pd.concat([self.data, pd.DataFrame.from_dict(self.video.events)], axis=1)
             data.to_parquet(self.paths.DATA_FILE_PATH)
+            if 20 > self._log_level > 0:
+                stats = self.video.stats
+                stats.to_parquet(self.paths.STATS_FILE_PATH)
+            if self.video._media and self.video._media.get_mrl().endswith(str(self.task_params.VIDEO)):
+                ext = Path(self.task_params.VIDEO).suffix
+                video_file_path = self.paths.DATA_FILE_PATH.with_name(f'_sp_video.raw{ext}')
+                _logger.info('Copying %s -> %s', self.task_params.VIDEO, video_file_path)
+                shutil.copy(self.task_params.VIDEO, video_file_path)
+            else:
+                _logger.warning('Video not copied (video most likely was not played)')
+            self. self.video._media.get_mrl()
         self.paths.SESSION_FOLDER.joinpath('transfer_me.flag').touch()
 
     def start_hardware(self):
-        self.start_mixin_bpod()  # used for protocol spacer only
-        self.video = Player(logger=self.logger)
+        self.start_mixin_bpod()
+        self.video = Player()
 
     def next_trial(self):
         """Start the next trial."""
         self.trial_num += 1
         self.data.at[self.trial_num, 'intervals_0'] = time.time()
         if self.trial_num == 0:
-            self.logger.info('Starting video %s', self.task_params.VIDEO)
+            _logger.info('Starting video %s', self.task_params.VIDEO)
             self.video.play(self.task_params.VIDEO)
         else:
-            self.logger.debug('Trial #%i: Replaying video', self.trial_num + 1)
+            _logger.debug('Trial #%i: Replaying video', self.trial_num + 1)
             assert self.video
             self.video.replay()
 
     def _set_bpod_out(self, val):
         """Set Bpod BNC1 output state."""
+        BNC_HIGH = 255
+        BNC_LOW = 0
         if isinstance(val, bool):
-            val = 255 if val else 128
+            val = BNC_HIGH if val else BNC_LOW
         self.bpod.manual_override(Bpod.ChannelTypes.OUTPUT, Bpod.ChannelNames.BNC, channel_number=1, value=val)
 
     def _run(self):
         """This is the method that runs the video."""
-        # make the bpod send spacer signals to the main sync clock for protocol discovery
-        self.send_spacers()
         for rep in range(self.task_params.NREPEATS):  # Main loop
             self.next_trial()
             self._set_bpod_out(True)
             # TODO c.f. MediaListPlayerPlayed event
             while not self.video.is_started:
                 ...  # takes time to actually start playback
             while self.video.is_playing or (end_time := self.video.get_ended_time(rep)) is None:
+                if 20 > self._log_level > 0:
+                    self.video.update_media_stats()
                 time.sleep(0.05)
             # trial finishes when playback finishes
             self._set_bpod_out(False)
             self.session_info.NTRIALS += 1
             self.data.at[self.trial_num, 'intervals_1'] = time.time()
+            self.data.at[self.trial_num, 'video_runtime'] = self.video.get_media_length()
             dt = self.task_params.ITI_DELAY_SECS - (time.time() - end_time)
-            self.logger.debug(f'dt = {dt}')
+            _logger.debug(f'dt = {dt}')
             # wait to achieve the desired ITI duration
             if dt > 0:
                 time.sleep(dt)

iblrig_custom_tasks/_sp_passiveVideo/task.py

@@ -0,0 +1,31 @@
+import unittest
+from unittest.mock import Mock
+from iblrig_custom_tasks._sp_passiveVideo.task import Session, Player
+from iblrig.test.base import TaskArgsMixin
+
+
+class TestPassiveVideo(TaskArgsMixin, unittest.TestCase):
+
+    def setUp(self):
+        self.get_task_kwargs()
+
+    def test_next_trial(self):
+        self.assertRaises(NotImplementedError, Session, **self.task_kwargs)
+        self.task_kwargs['hardware_settings']['MAIN_SYNC'] = False
+        task = Session(log_level='DEBUG', **self.task_kwargs)
+        task.video = Mock(auto_spec=Player)
+        task.task_params.VIDEO = r'C:\Users\Work\Downloads\ONE\perlin-xyscale2-tscale50-comb08-5min.mp4'
+        task.task_params.VIDEO = r'C:\Users\Work\Downloads\SampleVideo_1280x720_1mb.mp4'
+        task.next_trial()
+        task.video.play.assert_called_once_with(task.task_params.VIDEO)
+        task.video.replay.assert_not_called()
+        task.video.reset_mock()
+        task.next_trial()
+        task.video.replay.assert_called_once()
+        # task.bpod = MagicMock()
+        # with patch.object(task, 'start_mixin_bpod'):
+        #     task.run()
+
+
+if __name__ == '__main__':
+    unittest.main()