Merge branch 'main' into princeton

Author: mayofaulkner

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()

iblrig_custom_tasks/_sp_passiveVideo/test_sp_videoPassive.py

@@ -0,0 +1,99 @@
+"""
+This task inherits TrainingChoiceWorldSession with the addition of configurable, adaptive timeouts for incorrect
+choices depending on the stimulus contrast.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import yaml
+from pydantic import NonNegativeFloat
+
+from iblrig.misc import get_task_arguments
+from iblrig_tasks._iblrig_tasks_trainingChoiceWorld.task import Session as TrainingCWSession
+
+log = logging.getLogger('iblrig.task')
+
+
+# read defaults from task_parameters.yaml
+with open(Path(__file__).parent.joinpath('task_parameters.yaml')) as f:
+    DEFAULTS = yaml.safe_load(f)
+
+
+class AdaptiveTimeoutChoiceWorldTrialData(TrainingCWSession.TrialDataModel):
+    adaptive_delay_nogo: NonNegativeFloat
+    adaptive_delay_error: NonNegativeFloat
+
+
+class Session(TrainingCWSession):
+    protocol_name = 'nate_adaptiveTimeoutChoiceWorld'
+    TrialDataModel = AdaptiveTimeoutChoiceWorldTrialData
+
+    def __init__(
+        self,
+        *args,
+        adaptive_delay_nogo=DEFAULTS['ADAPTIVE_FEEDBACK_NOGO_DELAY_SECS'],
+        adaptive_delay_error=DEFAULTS['ADAPTIVE_FEEDBACK_ERROR_DELAY_SECS'],
+        **kwargs,
+    ):
+        self._adaptive_delay_nogo = adaptive_delay_nogo
+        self._adaptive_delay_error = adaptive_delay_error
+        super().__init__(*args, **kwargs)
+        assert len(self._adaptive_delay_nogo) == len(self.task_params.CONTRAST_SET)
+        assert len(self._adaptive_delay_error) == len(self.task_params.CONTRAST_SET)
+
+    def draw_next_trial_info(self, **kwargs):
+        super().draw_next_trial_info(**kwargs)
+        contrast = self.trials_table.at[self.trial_num, 'contrast']
+        index = np.flatnonzero(np.array(self.task_params['CONTRAST_SET']) == contrast)[0]
+        self.trials_table.at[self.trial_num, 'adaptive_delay_nogo'] = self._adaptive_delay_nogo[index]
+        self.trials_table.at[self.trial_num, 'adaptive_delay_error'] = self._adaptive_delay_error[index]
+
+    @property
+    def feedback_nogo_delay(self):
+        return self.trials_table.at[self.trial_num, 'adaptive_delay_nogo']
+
+    @property
+    def feedback_error_delay(self):
+        return self.trials_table.at[self.trial_num, 'adaptive_delay_error']
+
+    def show_trial_log(self, extra_info: dict[str, Any] | None = None, log_level: int = logging.INFO):
+        trial_info = self.trials_table.iloc[self.trial_num]
+        info_dict = {
+            'Adaptive no-go delay': f'{trial_info.adaptive_delay_nogo:.2f} s',
+            'Adaptive error delay': f'{trial_info.adaptive_delay_error:.2f} s',
+        }
+        if isinstance(extra_info, dict):
+            info_dict.update(extra_info)
+        super().show_trial_log(extra_info=info_dict, log_level=log_level)
+
+    @staticmethod
+    def extra_parser():
+        parser = super(Session, Session).extra_parser()
+        parser.add_argument(
+            '--adaptive_delay_nogo',
+            option_strings=['--adaptive_delay_nogo'],
+            dest='adaptive_delay_nogo',
+            default=DEFAULTS['ADAPTIVE_FEEDBACK_NOGO_DELAY_SECS'],
+            nargs='+',
+            type=float,
+            help='list of delays for no-go condition (contrasts: 1.0, 0.5, 0.25, 0.125, 0.0625, 0.0)',
+        )
+        parser.add_argument(
+            '--adaptive_delay_error',
+            option_strings=['--adaptive_delay_error'],
+            dest='adaptive_delay_error',
+            default=DEFAULTS['ADAPTIVE_FEEDBACK_ERROR_DELAY_SECS'],
+            nargs='+',
+            type=float,
+            help='list of delays for error condition (contrasts: 1.0, 0.5, 0.25, 0.125, 0.0625, 0.0)',
+        )
+        return parser
+
+
+if __name__ == '__main__':  # pragma: no cover
+    kwargs = get_task_arguments(parents=[Session.extra_parser()])
+    sess = Session(**kwargs)
+    sess.run()

iblrig_custom_tasks/nate_adaptiveTimeoutChoiceWorld/__init__.py

@@ -0,0 +1,10 @@
+'ADAPTIVE_GAIN': True
+'ADAPTIVE_REWARD': True
+'AG_INIT_VALUE': 8.0  # Adaptive Gain init value. Once the mouse completes 200 response trials whithin a session, this reverts to STIM_GAIN
+'CONTRAST_SET_PROBABILITY_TYPE': skew_zero  # uniform, skew_zero
+'DEBIAS': True  # Whether to use debiasing rule or not by repeating error trials
+'REWARD_AMOUNT_UL': 3.0  # Reward amount (uL), will oscillate between 1.5 and 3 uL depending on previous sessions if adaptive_reward is True
+
+'CONTRAST_SET': [1.0, 0.5, 0.25, 0.125, 0.0625, 0.0]
+'ADAPTIVE_FEEDBACK_NOGO_DELAY_SECS': [2.0, 2.0, 2.0, 2.0, 2.0, 2.0]
+'ADAPTIVE_FEEDBACK_ERROR_DELAY_SECS': [2.0, 2.0, 2.0, 2.0, 2.0, 2.0]