eegdash 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/intan/load_intan_rhs_format/load_intan_rhs_format.py

@@ -1,213 +0,0 @@
-#! /bin/env python
-#
-# Michael Gibson 17 July 2015
-# Modified Zeke Arneodo Dec 2017
-# Modified Adrian Foy January 2023
-
-import sys, struct, math, os, time
-import numpy as np
-
-from intanutil.read_header import read_header
-from intanutil.get_bytes_per_data_block import get_bytes_per_data_block
-from intanutil.read_one_data_block import read_one_data_block
-from intanutil.notch_filter import notch_filter
-from intanutil.data_to_result import data_to_result
-
-
-def read_data(filename):
-    """Reads Intan Technologies RHD2000 data file generated by evaluation board GUI.
-
-    Data are returned in a dictionary, for future extensibility.
-    """
-    tic = time.time()
-    with open(filename, 'rb') as fid:
-        filesize = os.path.getsize(filename)
-
-        header = read_header(fid)
-        # return header
-
-        print('Found {} amplifier channel{}.'.format(header['num_amplifier_channels'],
-                                                     plural(header['num_amplifier_channels'])))
-        print('Found {} board ADC channel{}.'.format(header['num_board_adc_channels'],
-                                                     plural(header['num_board_adc_channels'])))
-        print('Found {} board DAC channel{}.'.format(header['num_board_dac_channels'],
-                                                     plural(header['num_board_dac_channels'])))
-        print('Found {} board digital input channel{}.'.format(header['num_board_dig_in_channels'],
-                                                               plural(header['num_board_dig_in_channels'])))
-        print('Found {} board digital output channel{}.'.format(header['num_board_dig_out_channels'],
-                                                                plural(header['num_board_dig_out_channels'])))
-        print('')
-
-        # Determine how many samples the data file contains.
-        bytes_per_block = get_bytes_per_data_block(header)
-        print('{} bytes per data block'.format(bytes_per_block))
-        # How many data blocks remain in this file?
-        data_present = False
-        bytes_remaining = filesize - fid.tell()
-        if bytes_remaining > 0:
-            data_present = True
-
-        if bytes_remaining % bytes_per_block != 0:
-            raise Exception('Something is wrong with file size : should have a whole number of data blocks')
-
-        num_data_blocks = int(bytes_remaining / bytes_per_block)
-
-        num_amplifier_samples = 128 * num_data_blocks
-        num_board_adc_samples = 128 * num_data_blocks
-        num_board_dac_samples = 128 * num_data_blocks
-        num_board_dig_in_samples = 128 * num_data_blocks
-        num_board_dig_out_samples = 128 * num_data_blocks
-
-        record_time = num_amplifier_samples / header['sample_rate']
-
-        if data_present:
-            print('File contains {:0.3f} seconds of data.  Amplifiers were sampled at {:0.2f} kS/s.'.format(record_time,
-                                                                                                            header[
-                                                                                                                'sample_rate'] / 1000))
-        else:
-            print('Header file contains no data.  Amplifiers were sampled at {:0.2f} kS/s.'.format(
-                header['sample_rate'] / 1000))
-
-        if data_present:
-            # Pre-allocate memory for data.
-            print('')
-            print('Allocating memory for data...')
-
-            data = {}
-            data['t'] = np.zeros(num_amplifier_samples, dtype=np.int_)
-
-            data['amplifier_data'] = np.zeros([header['num_amplifier_channels'], num_amplifier_samples], dtype=np.uint)
-
-            if header['dc_amplifier_data_saved']:
-                data['dc_amplifier_data'] = np.zeros([header['num_amplifier_channels'], num_amplifier_samples], dtype=np.uint) * header['dc_amplifier_data_saved']
-
-            data['stim_data_raw'] = np.zeros([header['num_amplifier_channels'], num_amplifier_samples], dtype=np.int_)
-            data['stim_data'] = np.zeros([header['num_amplifier_channels'], num_amplifier_samples], dtype=np.int_)
-
-            data['board_adc_data'] = np.zeros([header['num_board_adc_channels'], num_board_adc_samples], dtype=np.uint)
-            data['board_dac_data'] = np.zeros([header['num_board_dac_channels'], num_board_dac_samples], dtype=np.uint)
-
-            # by default, this script interprets digital events (digital inputs, outputs, amp settle, compliance limit, and charge recovery) as booleans
-            # if unsigned int values are preferred (0 for False, 1 for True), replace the 'dtype=np.bool_' argument with 'dtype=np.uint' as shown
-            # the commented line below illustrates this for digital input data; the same can be done for the other digital data types
-
-            #data['board_dig_in_data'] = np.zeros([header['num_board_dig_in_channels'], num_board_dig_in_samples], dtype=np.uint)
-            data['board_dig_in_data'] = np.zeros([header['num_board_dig_in_channels'], num_board_dig_in_samples], dtype=np.bool_)
-            data['board_dig_in_raw'] = np.zeros(num_board_dig_in_samples, dtype=np.uint)
-            data['board_dig_out_data'] = np.zeros([header['num_board_dig_out_channels'], num_board_dig_out_samples], dtype=np.bool_)
-            data['board_dig_out_raw'] = np.zeros(num_board_dig_out_samples, dtype=np.uint)
-
-            # Read sampled data from file.
-            print('Reading data from file...')
-
-            # Initialize indices used in looping
-            indices = {}
-            indices['amplifier'] = 0
-            indices['aux_input'] = 0
-            indices['board_adc'] = 0
-            indices['board_dac'] = 0
-            indices['board_dig_in'] = 0
-            indices['board_dig_out'] = 0
-
-            print_increment = 10
-            percent_done = print_increment
-            for i in (range(num_data_blocks)):
-                read_one_data_block(data, header, indices, fid)
-                # Increment all indices indices in 128
-                indices = {k: v + 128 for k, v in indices.items()}
-
-                fraction_done = 100 * (1.0 * i / num_data_blocks)
-                if fraction_done >= percent_done:
-                    print('{}% done...'.format(percent_done))
-                    percent_done = percent_done + print_increment
-
-            # Make sure we have read exactly the right amount of data.
-            bytes_remaining = filesize - fid.tell()
-            if bytes_remaining != 0: raise Exception('Error: End of file not reached.')
-
-    # end of reading data file.
-    # return data
-
-    if (data_present):
-        print('Parsing data...')
-
-        # Extract digital input channels to separate variables.
-        for i in range(header['num_board_dig_in_channels']):
-            data['board_dig_in_data'][i, :] = np.not_equal(np.bitwise_and(data['board_dig_in_raw'],
-                                                                          (1 << header['board_dig_in_channels'][i][
-                                                                              'native_order'])), 0)
-
-        # Extract digital output channels to separate variables.
-        for i in range(header['num_board_dig_out_channels']):
-            data['board_dig_out_data'][i, :] = np.not_equal(np.bitwise_and(data['board_dig_out_raw'],
-                                                                           (1 << header['board_dig_out_channels'][i][
-                                                                               'native_order'])), 0)
-
-        # Extract stimulation data
-        data['compliance_limit_data'] = np.bitwise_and(data['stim_data_raw'], 32768) >= 1 # get 2^15 bit, interpret as True or False
-        data['charge_recovery_data'] = np.bitwise_and(data['stim_data_raw'], 16384) >= 1 # get 2^14 bit, interpret as True or False
-        data['amp_settle_data'] = np.bitwise_and(data['stim_data_raw'], 8192) >= 1 # get 2^13 bit, interpret as True or False
-        data['stim_polarity'] = 1 - (2*(np.bitwise_and(data['stim_data_raw'], 256) >> 8)) # get 2^8 bit, interpret as +1 for 0_bit or -1 for 1_bit
-
-        curr_amp = np.bitwise_and(data['stim_data_raw'], 255) # get least-significant 8 bits corresponding to the current amplitude
-        data['stim_data'] = curr_amp * data['stim_polarity'] # multiply current amplitude by the correct sign
-
-        # # Scale voltage levels appropriately.
-        data['amplifier_data'] = np.multiply(0.195,
-                                             (
-                                             data['amplifier_data'].astype(np.int32) - 32768))  # units = microvolts
-        data['stim_data'] = np.multiply(header['stim_step_size'], data['stim_data'] / 1.0e-6)
-
-        if header['dc_amplifier_data_saved']:
-            data['dc_amplifier_data'] = np.multiply(-0.01923,
-                                                    (data['dc_amplifier_data'].astype(
-                                                        np.int32) - 512))  # units = volts
-
-        data['board_adc_data'] = np.multiply(0.0003125, (data['board_adc_data'].astype(np.int32) - 32768)) # units = volts
-        data['board_dac_data'] = np.multiply(0.0003125, (data['board_dac_data'].astype(np.int32) - 32768)) # units = volts
-
-        # Check for gaps in timestamps.
-        num_gaps = np.sum(np.not_equal(data['t'][1:] - data['t'][:-1], 1))
-        if num_gaps == 0:
-            print('No missing timestamps in data.')
-        else:
-            print('Warning: {0} gaps in timestamp data found.  Time scale will not be uniform!'.format(num_gaps))
-
-        # Scale time steps (units = seconds).
-        data['t'] = data['t'] / header['sample_rate']
-
-        # If the software notch filter was selected during the recording, apply the
-        # same notch filter to amplifier data here.
-        if header['notch_filter_frequency'] > 0 and header['version']['major'] < 3:
-            print_increment = 10
-            percent_done = print_increment
-            for i in range(header['num_amplifier_channels']):
-                data['amplifier_data'][i, :] = notch_filter(data['amplifier_data'][i, :], header['sample_rate'],
-                                                            header['notch_filter_frequency'], 10)
-                if fraction_done >= percent_done:
-                    print('{}% done...'.format(percent_done))
-                    percent_done = percent_done + print_increment
-    else:
-        data = []
-
-    # Move variables to result struct.
-    result = data_to_result(header, data, data_present)
-
-    print('Done!  Elapsed time: {0:0.1f} seconds'.format(time.time() - tic))
-
-    return result
-
-
-def plural(n):
-    """Utility function to optionally pluralize words based on the value of n.
-    """
-
-    if n == 1:
-        return ''
-    else:
-        return 's'
-
-
-if __name__ == '__main__':
-    a = read_data(sys.argv[1])
-    #print(a)

eegdash/SignalStore/signalstore/adapters/read_adapters/recording_acquisitions/neurodata_without_borders/neurodata_without_borders_read_adapter.py

@@ -1,14 +0,0 @@
-from signalstore.operations.importers.adapters.abstract_read_adapter import AbstractReadAdapter
-
-#import pynwb
-
-class NeurodataWithoutBordersReadAdapter(AbstractReadAdapter):
-    def __init__(self, path):
-        self.path = path
-
-    def read(self):
-        """Reads a NWB file and converts each data object into an xarray.DataArray with
-        the appropriate dimensions, coordinates and metadata attributes for the
-        Neuroscikit data model.
-        """
-        pass

eegdash/SignalStore/signalstore/operations/__init__.py

@@ -1,4 +0,0 @@
-from eegdash.SignalStore.signalstore.operations.handler_executor import HandlerExecutor
-from eegdash.SignalStore.signalstore.operations.handler_factory import HandlerFactory
-
-__all__ = ["HandlerExecutor", "HandlerFactory"]

eegdash/SignalStore/signalstore/operations/handler_executor.py

@@ -1,22 +0,0 @@
-class BaseHandlerExecutor:
-    def __init__(self, handler_factory):
-        self.handler_factory = handler_factory
-    def list_handlers(self):
-        return self.handler_factory.list_handlers()
-
-    def help(self, handler_name):
-        return self.handler_factory.help(handler_name)
-
-    def help_all(self):
-        return self.handler_factory.help_all()
-
-    #def validate_request(self, request):
-    #    """Validate a request."""
-    #    pass
-
-class HandlerExecutor(BaseHandlerExecutor):
-    def __init__(self, handler_factory):
-        super().__init__(handler_factory)
-
-    def do(self, handler_name, **kwargs):
-        return self.handler_factory.create(handler_name).execute(**kwargs)

eegdash/SignalStore/signalstore/operations/handler_factory.py

@@ -1,41 +0,0 @@
-import os
-import importlib.util
-
-from eegdash.SignalStore.signalstore.operations.handlers.base_handler import BaseHandler
-
-class HandlerFactory:
-    def __init__(self, uow_provider, base_path='signalstore.operations.handlers', base_dir='src/operations/handlers'):
-        self._uow_provider = uow_provider
-        self.base_path = base_path
-        self.base_dir = base_dir
-        self._handlers = self._discover_handlers()
-
-    def _discover_handlers(self):
-        """Recursively search for handler classes and return a dict of {handler_name: handler_class}."""
-        handlers = {}
-        for root, dirs, files in os.walk(self.base_dir):
-            for file in files:
-                if file.endswith('_handler.py') or file.endswith('_handlers.py'):
-                    module_path = os.path.join(root, file).replace("/", ".")[:-3]  # Convert UPath to module notation and remove .py
-                    for name, obj in vars(importlib.import_module(module_path)).items():
-                        if isinstance(obj, type) and issubclass(obj, BaseHandler) and obj != BaseHandler:
-                            handlers[name] = obj
-        return handlers
-
-    def create(self, handler_name):
-        handler_class = self._handlers.get(handler_name)
-        if not handler_class:
-            raise Exception(f"Handler {handler_name} not found.")
-        return handler_class(self._uow_provider)
-
-    def list_handlers(self):
-        """List available handlers."""
-        return list(self._handlers.keys())
-
-    def get_handler_help(self, handler_name):
-        """Get documentation for a specific handler."""
-        handler_class = self._handlers.get(handler_name)
-        if handler_class:
-            return handler_class.__doc__ or f"No documentation available for {handler_name}"
-        else:
-            raise Exception(f"Handler {handler_name} not found.")

eegdash/SignalStore/signalstore/operations/handlers/base_handler.py

@@ -1,44 +0,0 @@
-from abc import ABC, abstractmethod
-from pydantic import BaseModel
-
-class BaseHandler(ABC):
-    def __init__(self, unit_of_work_provider, project_name):
-        self._uow_provider = unit_of_work_provider
-        self._project_name = project_name
-
-    @property
-    def unit_of_work(self):
-        return self._uow_provider(self._project_name)
-
-    @abstractmethod
-    def execute(self):
-        # use with self.unit_of_work() as uow:
-        pass
-
-class BaseHandlerResponse(BaseModel):
-    status: str
-    result: dict
-    effects: dict
-    error: str
-
-class SmallHandlerResponse(BaseHandlerResponse):
-    __slots__ = ["status", "result", "effects", "error"]
-    def __init__(self, status, result, effects, error):
-        self.status = status
-        self.result = result # Note that this is a dictionary and the structure of the result must be included in the docstrings of each handler
-        self.effects = effects
-        self.error = error
-
-    def __repr__(self):
-        return f"HandlerResponse(status={self.status}, result={self.result}, effects={self.effects}, error={self.error})"
-
-    def __str__(self):
-        return f"HandlerResponse(status={self.status} result={self.result} effects={self.effects} error={self.error})"
-
-class SmallHandlerSuccessResponse(SmallHandlerResponse):
-    def __init__(self, result, effects):
-        super().__init__("SUCCESS", result, effects, None)
-
-class SmallHandlerFailureResponse(SmallHandlerResponse):
-    def __init__(self, error):
-        super().__init__("FAILURE", None, None, error)

eegdash/SignalStore/signalstore/operations/handlers/domain/property_model_handlers.py

@@ -1,79 +0,0 @@
-from signalstore.operations.handlers.base_handler import BaseHandler, HandlerSuccessResponse, HandlerFailureResponse
-
-import json
-
-class AddPropertyModelFromJSONHandler(BaseHandler):
-    """Add a term to the database."""
-
-    def execute(self, term_path):
-        with self.uow_provider() as uow:
-            try:
-                with open(term_path) as f:
-                    term = json.load(f)
-                    uow.domain_models.add(term)
-                effects = uow.commit()
-                return HandlerSuccessResponse(None, effects)
-            except Exception as e:
-                return HandlerFailureResponse(e)
-
-class AddPropertyModelDictHandler(BaseHandler):
-    """Add a term to the database."""
-
-    def execute(self, term):
-        with self.uow_provider() as uow:
-            try:
-                uow.domain_models.add(term)
-                effects = uow.commit()
-                return HandlerSuccessResponse(None, effects)
-            except Exception as e:
-                return HandlerFailureResponse(e)
-
-class DeletePropertyModelHandler(BaseHandler):
-    """Delete a term from the database."""
-
-    def execute(self, name):
-        with self.uow_provider() as uow:
-            try:
-                uow.domain_models.delete(name=name)
-                effects = uow.commit()
-                return HandlerSuccessResponse(None, effects)
-            except Exception as e:
-                return HandlerFailureResponse(e)
-
-
-class GetPropertyModelHandler(BaseHandler):
-    """Get a term from the database."""
-
-    def execute(self, name):
-        with self.uow_provider() as uow:
-            try:
-                term = uow.domain_models.get(schema_name=name)
-                # check that term is a property model
-                if term["schema_type"] != "property_model":
-                    term = None
-                return HandlerSuccessResponse(term, None)
-            except Exception as e:
-                return HandlerFailureResponse(e)
-
-class ListPropertyModelsHandler(BaseHandler):
-    """List all domain_models in the database."""
-
-    def execute(self):
-        with self.uow_provider() as uow:
-            try:
-                terms = uow.domain_models.query({"schema_type": "property_model"})
-                return HandlerSuccessResponse(terms, None)
-            except Exception as e:
-                return HandlerFailureResponse(e)
-
-class ListPropertyModelsHandler(BaseHandler):
-    """List all term names in the database."""
-
-    def execute(self):
-        with self.uow_provider() as uow:
-            try:
-                terms = uow.domain_models.query({"schema_type": "property_model"})
-                names = [term["name"] for term in terms]
-                return HandlerSuccessResponse(names, None)
-            except Exception as e:
-                return HandlerFailureResponse(e)

eegdash/SignalStore/signalstore/operations/handlers/domain/schema_handlers.py

@@ -1,3 +0,0 @@
-from signalstore.operations.handlers.base_handler import BaseHandler, HandlerException
-import json
-

eegdash/SignalStore/signalstore/operations/helpers/abstract_helper.py

@@ -1,17 +0,0 @@
-from abc import ABC, abstractmethod
-from datetime import datetime, timezone
-
-class AbstractFunctionalHelper:
-    pass
-
-class AbstractMutableHelper:
-    def __init__(self, attrs, state):
-        if not isinstance(attrs, dict):
-            raise TypeError("attrs must be a dictionary")
-        if isinstance(state, type(None)):
-            raise TypeError("state cannot be None")
-        self.attrs = attrs
-        self.state = state
-
-    def __copy__(self):
-        return self.__class__(**self.__dict__)

eegdash/SignalStore/signalstore/operations/helpers/neuroscikit_extractor.py

@@ -1,33 +0,0 @@
-from spikeinterface.extractors.neoextractors.neobaseextractor import NeoBaseRecordingExtractor, NeoBaseSortingExtractor
-from neo import rawio
-from signalstore.operations.helpers.neuroscikit_rawio import NeuroSciKitRawIO
-from signalstorestore.data_access_objects import DataArrayDAO, RecordDAO
-
-
-# Because of how the NeoBaseRecordingExtractor works, our rawio class needs to be a member of the
-# neo.rawio module.
-rawio.NeuroSciKitRawIO = NeuroSciKitRawIO
-
-
-class NeuroSciKitExtractor(NeoBaseRecordingExtractor):
-    mode = 'folder' # Not sure what, if anything, this does.
-    NeoRawIOClass = 'NeuroSciKitRawIO'
-    name = "neuroscikit"
-
-    def __init__(self, data_dao: DataArrayDAO, record_dao: RecordDAO, dataarray_hrid: str, stream_id=None, stream_name=None, all_annotations=False):
-        neo_kwargs = self.map_to_neo_kwargs(data_dao, record_dao, dataarray_hrid)
-        NeoBaseRecordingExtractor.__init__(self, stream_id=stream_id,
-                                           stream_name=stream_name,
-                                           all_annotations=all_annotations,
-                                           **neo_kwargs)
-        self._kwargs.update(dict(data_dao=data_dao, record_dao=record_dao, dataarray_hrid=dataarray_hrid))
-
-    @classmethod
-    def map_to_neo_kwargs(cls, data_dao, record_dao, dataarray_hrid):
-        neo_kwargs = {
-                'data_dao': data_dao,
-                'record_dao': record_dao,
-                'dataarray_hrid': dataarray_hrid,
-                }
-        return neo_kwargs
-

eegdash/SignalStore/signalstore/operations/helpers/neuroscikit_rawio.py

@@ -1,165 +0,0 @@
-from neo.rawio.baserawio import (BaseRawIO, _signal_channel_dtype, _signal_stream_dtype,
-                _spike_channel_dtype, _event_channel_dtype)
-
-import numpy as np
-from copy import deepcopy
-
-import pickle
-import neo
-import re
-
-
-class NeuroSciKitRawIO(BaseRawIO):
-    """
-    Class for "reading" fake data from the neuroscikit repos, meant to provide data equivalent to
-    that provided by MEArecRawIO for h5 files.
-    """
-    extensions = ['h5']
-    rawmode = 'one-file'
-
-    def __init__(self, unit_of_work, dataarray_hrid: str):
-        BaseRawIO.__init__(self)
-        self._uow = unit_of_work
-        # check that the uow is open (i.e. has been called using with UnitOfWork(project) as uow:)
-        
-        self._dataarray_hrid = dataarray_hrid
-
-    def _source_name(self):
-        return self._dataarray_hrid
-
-    def _parse_header(self):
-        self._sampling_rate = self._data_dao.get('spikeinterface_sampling_rate', self._dataarray_hrid).data
-        self._recordings = self._data_dao.get('spikeinterface_recordings', self._dataarray_hrid).data
-
-        self._num_frames, self._num_channels = self._recordings.shape
-
-        signal_streams = np.array([('Signals', '0')], dtype=_signal_stream_dtype)
-
-        sig_channels = []
-        for c in range(self._num_channels):
-            ch_name = 'ch{}'.format(c)
-            chan_id = str(c + 1)
-            sr = self._sampling_rate  # Hz
-            dtype = self._recordings.dtype
-            units = 'uV'
-            gain = 1.
-            offset = 0.
-            stream_id = '0'
-            sig_channels.append((ch_name, chan_id, sr, dtype, units, gain, offset, stream_id))
-        sig_channels = np.array(sig_channels, dtype=_signal_channel_dtype)
-
-        # creating units channels
-        spike_channels = []
-
-        hrid_pat = re.compile(fr'{self._dataarray_hrid}-[0-9]+')
-        spiketrain_records = self._record_dao.find({'schema_name': 'spikeinterface_spiketrain', 'hrid': {'$regex': hrid_pat}, 'time_of_removal': None})
-        self._spiketrains = [
-                neo.SpikeTrain(
-                    pickle.loads(spiketrain_record["times"]),
-                    pickle.loads(spiketrain_record["t_stop"]),
-                    units=pickle.loads(spiketrain_record["units"]),
-                    dtype=pickle.loads(spiketrain_record["dtype"]),
-                    copy=spiketrain_record["copy"],
-                    sampling_rate=pickle.loads(spiketrain_record["sampling_rate"]),
-                    t_start=pickle.loads(spiketrain_record["t_start"]),
-                    waveforms=pickle.loads(spiketrain_record["waveforms"]),
-                    left_sweep=spiketrain_record["left_sweep"],
-                    name=spiketrain_record["name"],
-                    file_origin=spiketrain_record["file_origin"],
-                    description=spiketrain_record["description"],
-                    array_annotations=spiketrain_record["array_annotations"],
-                    **pickle.loads(spiketrain_record["annotations_pickle"]),
-                    )
-                for spiketrain_record in spiketrain_records]
-
-        for c in range(len(self._spiketrains)):
-            unit_name = 'unit{}'.format(c)
-            unit_id = '#{}'.format(c)
-            # if spiketrains[c].waveforms is not None:
-            wf_units = ''
-            wf_gain = 1.
-            wf_offset = 0.
-            wf_left_sweep = 0
-            wf_sampling_rate = self._sampling_rate
-            spike_channels.append((unit_name, unit_id, wf_units, wf_gain,
-                                  wf_offset, wf_left_sweep, wf_sampling_rate))
-        spike_channels = np.array(spike_channels, dtype=_spike_channel_dtype)
-
-        event_channels = []
-        event_channels = np.array(event_channels, dtype=_event_channel_dtype)
-
-        self.header = {}
-        self.header['nb_block'] = 1
-        self.header['nb_segment'] = [1]
-        self.header['signal_streams'] = signal_streams
-        self.header['signal_channels'] = sig_channels
-        self.header['spike_channels'] = spike_channels
-        self.header['event_channels'] = event_channels
-
-        info_record = self._record_dao.get('spikeinterface_recording_info', self._dataarray_hrid)
-        self._info = pickle.loads(info_record['info_pickle'])
-
-        self._generate_minimal_annotations()
-        for block_index in range(1):
-            bl_ann = self.raw_annotations['blocks'][block_index]
-            bl_ann['mearec_info'] = deepcopy(self._info)
-
-    def _segment_t_start(self, block_index, seg_index):
-        all_starts = [[0.]]
-        return all_starts[block_index][seg_index]
-
-    def _segment_t_stop(self, block_index, seg_index):
-        t_stop = self._num_frames / self._sampling_rate
-        all_stops = [[t_stop]]
-        return all_stops[block_index][seg_index]
-
-    def _get_signal_size(self, block_index, seg_index, stream_index):
-        assert stream_index == 0
-        return self._num_frames
-
-    def _get_signal_t_start(self, block_index, seg_index, stream_index):
-        assert stream_index == 0
-        return self._segment_t_start(block_index, seg_index)
-
-    def _get_analogsignal_chunk(self, block_index, seg_index, i_start, i_stop,
-                                stream_index, channel_indexes):
-        if i_start is None:
-            i_start = 0
-        if i_stop is None:
-            i_stop = self._num_frames
-
-        if channel_indexes is None:
-            channel_indexes = slice(self._num_channels)
-        if isinstance(channel_indexes, slice):
-            raw_signals = self._recordings[i_start:i_stop, channel_indexes]
-        else:
-            # sort channels because h5py neeeds sorted indexes
-            if np.any(np.diff(channel_indexes) < 0):
-                sorted_channel_indexes = np.sort(channel_indexes)
-                sorted_idx = np.array([list(sorted_channel_indexes).index(ch)
-                                       for ch in channel_indexes])
-                raw_signals = self._recordings[i_start:i_stop, sorted_channel_indexes]
-                raw_signals = raw_signals[:, sorted_idx]
-            else:
-                raw_signals = self._recordings[i_start:i_stop, channel_indexes]
-        return raw_signals
-
-    def _spike_count(self, block_index, seg_index, unit_index):
-        return len(self._spiketrains[unit_index])
-
-    def _get_spike_timestamps(self, block_index, seg_index, unit_index, t_start, t_stop):
-        spike_timestamps = self._spiketrains[unit_index].times.magnitude
-        if t_start is None:
-            t_start = self._segment_t_start(block_index, seg_index)
-        if t_stop is None:
-            t_stop = self._segment_t_stop(block_index, seg_index)
-        timestamp_idxs = np.where((spike_timestamps >= t_start) & (spike_timestamps < t_stop))
-
-        return spike_timestamps[timestamp_idxs]
-
-    def _rescale_spike_timestamp(self, spike_timestamps, dtype):
-        return spike_timestamps.astype(dtype)
-
-    def _get_spike_raw_waveforms(self, block_index, seg_index,
-                                 spike_channel_index, t_start, t_stop):
-        return None