def test_evaluate_with_no_broken_rules(self): """Test evaluate with is_broken returning False, thus resulting in evaluate returning True""" when(self.evaluator.rules[0]).is_broken(any()).thenReturn(False) when(self.evaluator.rules[1]).is_broken(any()).thenReturn(False) data = gen_random_data(-1, 2, self.channels) self.assertTrue(self.evaluator.evaluate(data))
def random_data( encoder=_DefaultEncoder(), low=-1000, high=1000, channel_count=25): """Generates random EEG-like data encoded according to the provided encoder. Returns ------- packet of data, which decodes into a list of floats in the range low to high with channel_count number of items. """ while True: sensor_data = gen_random_data(low, high, channel_count) yield encoder.encode(sensor_data)
def sample_raw_data( trigger_seq: List[Tuple[str, str]] = [], first_trg_time: int = 100, trigger_interval: int = 10, daq_type: str = 'TestStream', sample_rate: int = 300, ch_names: List[str] = ['c1', 'c2', 'c3']) -> Tuple[str, List[float]]: """Helper function for creating mock data that looks like the raw_data.csv output. Adds trigger data to the TRG column at the specified interval. Parameters: ----------- trigger_seq: list of tuples with the stimulus, targetness. first_trg_time: first time in the data where a trigger should appear. trigger_interval: set interval at which subsequent triggers should be displayed daq_type - metadata written to the raw_data file. sample_rate - metadata written to the raw_data file for sample rate in hz. Returns: -------- content: str, trigger_times: list(float) """ # Set up the trigger times trigger_times = [] triggers_by_time = {} for i in range(len(trigger_seq)): ts = first_trg_time + (i * trigger_interval) trigger_times.append(ts) trg_val = trigger_seq[i][0] triggers_by_time[ts] = trg_val # Mock the raw_data file sep = '\r\n' meta = sep.join([f'daq_type,{daq_type}', 'sample_rate,{sample_rate}']) header = 'timestamp,' + ','.join(ch_names) + ',TRG' data = [] n_channels = len(ch_names) for i in range(1000): timestamp = i + 10.0 channel_data = list(map(str, gen_random_data(-1000, 1000, n_channels))) trg = triggers_by_time.get(timestamp, NONE_VALUES[0]) data.append(','.join([str(timestamp), *channel_data, trg])) content = sep.join([meta, header, *data]) return content, trigger_times
def sample_data(rows: int = 1000, ch_names: List[str] = None) -> str: """Creates sample data to be written as a raw_data.csv file rows - number of sample rows to generate ch_names - channel names """ if not ch_names: ch_names = ['c1', 'c2', 'c3'] # Mock the raw_data file sep = '\n' meta = sep.join([f'daq_type,LSL', 'sample_rate,256.0']) header = 'timestamp,' + ','.join(ch_names) + ',TRG' data = [] for i in range(rows): channel_data = gen_random_data(low=-1000, high=1000, channel_count=len(ch_names)) columns = chain([str(i)], map(str, channel_data), ['0.0']) data.append(','.join(columns)) return sep.join([meta, header, *data])
def test_high_voltage_passing_signal(self): """Test generated signal that is consistently below threshold""" data = gen_random_data(-0.5, 0.5, self.channels) self.assertFalse(self.highvoltage_rule.is_broken(data))
def test_high_voltage_failing_signal(self): """Test generated signal with one data point above threshold """ data = gen_random_data(-5, 0, self.channels) # ascertain that at least one random datapoint is above threshold to test np.amax edgecase data[np.random.randint(self.channels)] = 1.5 self.assertTrue(self.highvoltage_rule.is_broken(data))
def test_low_voltage_failing_signal(self): """Test generated sub threshold signal against low voltage""" data = gen_random_data(1, 5, self.channels) # ascertain that at least one random datapoint is below threshold to test np.amin edgecase data[np.random.randint(self.channels)] = -1.5 self.assertTrue(self.lowvoltage_rule.is_broken(data))