def testCreateDataTable(self):
request = data_pb2.DataRequest()
request.chunk_duration_secs = 4
request.chunk_start = 0
channel_data_id = request.channel_data_ids.add()
channel_data_id.bipolar_channel.index = 0
channel_data_id.bipolar_channel.referential_index = 1
request.low_cut = 0
request.high_cut = 0
request.notch = 0
datatable, freq = waveform_data_service._CreateChunkDataTableJSon(
self.waveform_data_source, request, 10)
json_data = json.loads(datatable)
self.assertEqual([
{'id': 'seconds', 'label': 'seconds', 'type': 'number'},
{'id': 'TEST_MIN-TEST_SUB', 'label': 'TEST_MIN-TEST_SUB',
'type': 'number'}], json_data['cols'])
self.assertEqual([
{'c': [{'v': 0}, {'v': 0}]},
{'c': [{'v': 1}, {'v': 1}]},
{'c': [{'v': 2}, {'v': 2}]},
{'c': [{'v': 3}, {'v': 3}]}], json_data['rows'])
self.assertEqual(1.0, freq)
def testGetChunkReturns_IndexRaisesValueError(self, mock_create):
with self.assertRaises(ValueError):
request = data_pb2.DataRequest()
request.chunk_duration_secs = 10
request.chunk_start = 21
channel_data_id = request.channel_data_ids.add()
channel_data_id.single_channel.index = 0
request.low_cut = 1.0
request.high_cut = 70.0
request.notch = 60.0
waveform_data_service.GetChunk(self.waveform_data_source, request, 10)
mock_create.assert_not_called()
def testGetChunk(self, mock_threshold, mock_downsample):
label = self._pred._prediction_outputs.prediction_output[0].label[0]
label.attribution_map.attribution.extend([0, 2, 5, 6, 6, 3, 10, 9])
label.attribution_map.width = 4
label.attribution_map.height = 2
label.attribution_map.feature_names.extend([
('eeg_channel/EEG test_sub-REF/samples#'
'eeg_channel/EEG test_min-REF/samples'),
('eeg_channel/EEG test_min-REF/samples#'
'eeg_channel/EEG test_sub-REF/samples'),
])
label = self._pred._prediction_outputs.prediction_output[1].label[0]
label.attribution_map.attribution.extend([9, 10, 5, 6, 5, 8, 9, 2])
label.attribution_map.width = 4
label.attribution_map.height = 2
label.attribution_map.feature_names.extend([
('eeg_channel/EEG test_sub-REF/samples#'
'eeg_channel/EEG test_min-REF/samples'),
('eeg_channel/EEG test_min-REF/samples#'
'eeg_channel/EEG test_sub-REF/samples'),
])
mock_threshold.side_effect = lambda x: x
mock_downsample.side_effect = lambda x, ratio=1: np.array(x)
request = data_pb2.DataRequest()
request.chunk_start = 2
request.chunk_duration_secs = 2
channel_id = request.channel_data_ids.add()
channel_id.bipolar_channel.index = 0
channel_id.bipolar_channel.referential_index = 1
channel_id = request.channel_data_ids.add()
channel_id.single_channel.index = 0
response = self._pred.GetChunk(request)
self.assertIn('test label', response.attribution_data)
attribution_map = response.attribution_data[
'test label'].attribution_map
self.assertIn('0-1', attribution_map)
self.assertIn('0', attribution_map)
attribution_values = attribution_map['0-1'].attribution
self.assertAlmostEqual(0.5, attribution_values[0])
self.assertAlmostEqual(0.8, attribution_values[1])
self.assertAlmostEqual(0.9, attribution_values[2])
self.assertAlmostEqual(0.2, attribution_values[3])
self.assertLen(attribution_values, 4)
self.assertEqual([0, 0, 0, 0], attribution_map['0'].attribution)
self.assertEqual(2, response.chunk_start)
self.assertEqual(2, response.chunk_duration)
def testGetChunk(self, mock_create):
mock_create.return_value = ('test data', 1)
request = data_pb2.DataRequest()
request.chunk_duration_secs = 10
request.chunk_start = 0
channel_data_id = request.channel_data_ids.add()
channel_data_id.single_channel.index = 0
request.low_cut = 1.0
request.high_cut = 70.0
request.notch = 60.0
response = waveform_data_service.GetChunk(self.waveform_data_source,
request, 10)
mock_create.assert_called_with(self.waveform_data_source, request, 10)
self.assertEqual('test data', response.waveform_datatable)
self.assertEqual(0, response.channel_data_ids[0].single_channel.index)
def testRequestData(self, mock_tf_ex, mock_pred, mock_threshold,
mock_downsample):
mock_tf_ex.return_value = TEST_TF_EX
mock_pred.return_value = TEST_PRED
mock_threshold.side_effect = lambda x: x
mock_downsample.side_effect = lambda x, ratio=1: np.array(x)
request = data_pb2.DataRequest()
request.tf_ex_file_path = TEST_TFEX_PATH
request.prediction_file_path = TEST_PRED_PATH
request.chunk_duration_secs = 1
request.chunk_start = 0
channel_data_id = request.channel_data_ids.add()
channel_data_id.bipolar_channel.index = 0
channel_data_id.bipolar_channel.referential_index = 1
request.low_cut = 0
request.high_cut = 0
request.notch = 0
request = request.SerializeToString()
request_path = '/waveform_data/chunk'
with server.flask_app.test_request_context(request_path,
method='POST',
data=request):
rv = server.flask_app.dispatch_request()
response = data_pb2.DataResponse.FromString(rv.data)
self.assertEqual(
{
'cols': [
{
'id': 'seconds',
'type': 'number',
'label': 'seconds'
},
{
'id': 'TEST_MIN-TEST_SUB',
'type': 'number',
'label': 'TEST_MIN-TEST_SUB'
},
],
'rows': [
{
'c': [{
'v': 0.0
}, {
'v': 0.0
}]
},
]
}, json.loads(response.waveform_chunk.waveform_datatable))
channel_id = response.waveform_chunk.channel_data_ids[0]
self.assertEqual(0, channel_id.bipolar_channel.index)
self.assertEqual(1, channel_id.bipolar_channel.referential_index)
self.assertEqual(10.8, response.waveform_metadata.abs_start)
self.assertEqual(1, response.waveform_metadata.labels[0].start_time)
self.assertEqual('test annotation',
response.waveform_metadata.labels[0].label_text)
self.assertEqual('TEST_MIN',
response.waveform_metadata.channel_dict['0'])
self.assertEqual('TEST_SUB',
response.waveform_metadata.channel_dict['1'])
self.assertEqual('EEG', response.waveform_metadata.file_type)
self.assertEqual(4, response.waveform_metadata.num_secs)
self.assertEqual('test id', response.waveform_metadata.patient_id)
self.assertIn('test label', response.prediction_chunk.attribution_data)
attribution_data = response.prediction_chunk.attribution_data[
'test label']
self.assertIn('0-1', attribution_data.attribution_map)
attribution = attribution_data.attribution_map['0-1'].attribution
self.assertEqual([0.625, 0.75, 0.875, 1.0], attribution)
chunk_score_data = response.prediction_metadata.chunk_scores[0]
self.assertEqual(2.0, chunk_score_data.duration)
self.assertEqual(0.0, chunk_score_data.start_time)
self.assertIn('test label', chunk_score_data.score_data)
score_data = chunk_score_data.score_data['test label']
self.assertEqual(3.0, score_data.predicted_value)
self.assertEqual(1.0, score_data.actual_value)
