def render(self):
ret = vd.div(
vd.h2('Batch Monitor'),
vd.table(vd.tr(vd.td('Batch:'), vd.td(self._SEL_batch))),
vd.table(
vd.tr(
vd.td(ScrollArea(self._SEL_jobs, height=self._height),
style={
'vertical-align': 'top',
'min-width': '400px'
}),
vd.td(ScrollArea(self._job_status_widget,
height=self._height),
style={'vertical-align': 'top'}))))
return ret
def render(self):
# row info for the table
rr = []
sdkeys = self._context.sorterDefinitionKeys()
for sdkey in sdkeys:
sdef = self._context.sorterDefinition(sdkey)
rr.append(
dict(label=sdkey, value=vd.pre(json.dumps(sdef, indent=4))))
rows = []
for r in rr:
rows.append(vd.tr(vd.th(r['label']), vd.td(r['value'])))
table = vd.table(rows,
style={
'text-align': 'left',
'width': 'auto',
'font-size': '13px'
},
class_='table')
return vd.components.ScrollArea(
vd.div(vd.h2('Sorter definitions for analysis: {}'.format(
self._context.analysisName())),
table,
height=self._size[1]))
def render(self):
rows = [
vd.tr(vd.td('Select a group:'), vd.td(self._SEL_group)),
]
select_table = vd.table(
rows, style={'text-align': 'left', 'width': 'auto'}, class_='table')
return vd.div(
select_table
)
def render(self):
rec = self._context.recording
res = self._context.sorting_result
rows = []
rows.append(vd.tr(vd.th('Study'), vd.td(rec.study().name())))
rows.append(vd.tr(vd.th('Recording'), vd.td(rec.name())))
rows.append(vd.tr(vd.th('Directory'), vd.td(rec.directory())))
true_units = rec.trueUnitsInfo(format='json')
rows.append(
vd.tr(vd.th('Num. true units'),
vd.td('{}'.format(len(true_units)))))
RX = rec.recordingExtractor()
rows.append(
vd.tr(vd.th('Num. channels'),
vd.td('{}'.format(len(RX.getChannelIds())))))
rows.append(
vd.tr(vd.th('Samplerate'),
vd.td('{}'.format(RX.getSamplingFrequency()))))
recording_file_is_local = rec.recordingFileIsLocal()
if recording_file_is_local:
elmt = 'True'
else:
elmt = vd.span(
'False', ' ',
vd.a('(download)', onclick=self._on_download_recording_file))
rows.append(vd.tr(vd.th('raw.mda is downloaded'), vd.td(elmt)))
firings_true_file_is_local = rec.firingsTrueFileIsLocal()
if firings_true_file_is_local:
elmt = 'True'
else:
elmt = vd.span(
'False', ' ',
vd.a('(download)',
onclick=self._on_download_firings_true_file))
rows.append(vd.tr(vd.th('firings_true.mda is downloaded'),
vd.td(elmt)))
if res:
rows.append(vd.tr(vd.th('Sorting result'),
vd.td(res.sorterName())))
sorting = res.sorting()
rows.append(
vd.tr(vd.th('Num. sorted units'),
vd.td('{}'.format(len(sorting.getUnitIds())))))
table = vd.table(rows,
style={
'text-align': 'left',
'width': 'auto',
'font-size': '13px'
},
class_='table')
return ScrollArea(vd.div(table), size=self._size)
def render(self):
return vd.div(vd.table(vd.tr(vd.td('Accuracy threshold:'),
vd.td(self._accuracy_threshold_input),
vd.td(self._update_button)),
class_='table',
style={'max-width': '200px'}),
vd.components.ScrollArea(self._accuracy_table,
height=500),
self._study_sorter_fig,
style=dict(padding='15px'))
def render(self):
if self._list_mode:
refresh_list_button = vd.button('Refresh',
onclick=self._on_refresh_list)
return vd.div(vd.table(vd.tr(vd.td(refresh_list_button))),
vd.components.ScrollArea(self._batchlist_table,
height=500),
style=dict(padding='15px'))
else:
# back_button=vd.button('Back to list',onclick=self._on_back_to_list)
return vd.div(self._batch_view, style=dict(padding='15px'))
def render(self):
#return vd.tr(vd.td('Select an output ID:'), vd.td(self._SEL_output_id)),
rows = [
vd.tr(vd.td('Select an output ID:'), vd.td(self._SEL_output_id)),
]
select_table = vd.table(rows,
style={
'text-align': 'left',
'width': 'auto'
},
class_='table')
return vd.div(select_table)
def render(self):
rows = []
style_highlight = {'background-color': 'yellow'}
for option in self._options:
elmt = self._create_option_element(option)
if option == self._value:
rows.append(vd.tr(vd.td(elmt), style=style_highlight))
else:
rows.append(vd.tr(vd.td(elmt)))
X = vd.table(rows)
#X=vd.select(opts,onchange=self._on_change)
return X
def render(self):
rows = [
vd.tr(vd.td('Select a group:'), vd.td(self._SEL_group)),
vd.tr(vd.td('Select a study:'), vd.td(self._SEL_study)),
vd.tr(vd.td('Select a recording:'), vd.td(self._SEL_recording))
]
select_table = vd.table(
rows, style={'text-align': 'left', 'width': 'auto'}, class_='table')
return vd.div(
select_table,
self._recording_widget
)
def render(self):
if self._current_window:
return vd.div(vd.a('home', onclick=self._on_home),
self._current_window)
elmts = [
vd.a(item['label'],
onclick=lambda item=item: self._open_item(item))
for item in self._contents
]
rows = [vd.tr(vd.td(elmt)) for elmt in elmts]
table = vd.table(rows)
return vd.div(table, style=dict(padding='30px'))
def _make_button_table(buttons, num_columns):
rows = []
i = 0
while i < len(buttons):
row_buttons = buttons[i:i + num_columns]
while len(row_buttons) < num_columns:
row_buttons.append(vd.span())
rows.append(vd.tr([
vd.td(button)
for button in row_buttons
]))
i = i + num_columns
return vd.div(vd.table(*rows), style={'background-color': 'lightgray'})
def render(self):
rows = [
vd.tr(vd.td('Select an output id:'), vd.td(self._SEL_output_id)),
vd.tr(vd.td('Select a study:'), vd.td(self._SEL_study)),
vd.tr(vd.td('Select a recording:'), vd.td(self._SEL_recording)),
vd.tr(vd.td('Select a sorting result:'),
vd.td(self._SEL_sorting_result))
]
select_table = vd.table(
rows, style={'text-align': 'left', 'width': 'auto'}, class_='table')
return vd.div(
select_table
)
def render(self):
self._checkboxes = []
rows = []
elmts = [vd.th(val) for val in self._column_labels]
if self._selection_mode == 'multiple':
elmts = [vd.th('')] + elmts
rows.append(vd.tr(elmts))
for row in self._rows:
elmts = [vd.td(str(val)) for val in row['values']]
if self._selection_mode == 'multiple':
elmts = [vd.td(row['checkbox'])] + elmts
rows.append(vd.tr(elmts))
table = vd.table(rows, class_='table')
return ScrollArea(vd.div(table), size=self._size)
def render(self):
rows = []
rows.append(vd.tr(
*[vd.th(c['label']) for c in self._columns]
))
for index, record in enumerate(self._records):
rows.append(vd.tr(
*[vd.td(record.get(c['name'], '')) for c in self._columns],
class_='tablewidget_row', id='{}'.format(index)
))
table = vd.table(*rows, class_='table tablewidget', id='table-' + self.componentId())
if self._height:
return vd.div(ScrollArea(table, height=self._height))
else:
return table
def render(self):
return vd.div(vd.table(
vd.tr(
vd.td(
vd.div(self._snr_method_button,
style={'margin-bottom': '6px'})),
vd.td(vd.div(style={'width': '5px'})), vd.td('SNR threshold:'),
vd.td(self._snr_thr_select_box),
vd.td(vd.div(style={'width': '35px'})),
vd.td(
vd.div(self._acc_method_button,
style={'margin-bottom': '6px'})),
vd.td(vd.div(style={'width': '5px'})),
vd.td('Accuracy threshold:'),
vd.td(self._acc_thr_select_box))),
style={'font-size': '12px'})
def render(self):
rows = []
rows.append(
vd.tr(vd.th('Unit ID'), vd.th('SNR'), vd.th('Peak channel'),
vd.th('Num. events'), vd.th('Firing rate')))
if self._true_units_info:
for unit in self._true_units_info:
rows.append(
vd.tr(vd.td(str(unit['unit_id'])), vd.td(str(unit['snr'])),
vd.td(str(unit['peak_channel'])),
vd.td(str(unit['num_events'])),
vd.td(str(unit['firing_rate']))))
else:
print('WARNING: true units info not found.')
table = vd.table(rows, class_='table')
return vd.div(ScrollArea(vd.div(table), height=400))
def _to_table(X, column_names):
rows = []
rows.append(vd.tr([vd.th(cname) for cname in column_names]))
for x in X:
elmts = []
for cname in column_names:
tmp = x.get(cname)
if tmp:
if 'callback' in tmp:
elmt = vd.a(tmp['text'], onclick=tmp['callback'])
else:
elmt = vd.span(str(tmp.get('text')))
else:
elmt = vd.span('N/A')
elmts.append(elmt)
rows.append(vd.tr([vd.td(elmt) for elmt in elmts]))
return vd.table(rows, class_='table')
def render(self):
rows = []
rows.append(
vd.tr(vd.th('Unit ID'), vd.th('Accuracy'), vd.th('Best unit'),
vd.th('Matched unit'), vd.th('Num. matches'),
vd.th('False negative rate'), vd.th('False positive rate')))
for ii in self._comparison_info:
unit = self._comparison_info[ii]
rows.append(
vd.tr(vd.td(str(unit['unit_id'])),
vd.td(str(unit['accuracy'])),
vd.td(str(unit['best_unit'])),
vd.td(str(unit['matched_unit'])),
vd.td(str(unit['num_matches'])), vd.td(str(unit['f_n'])),
vd.td(str(unit['f_p']))))
table = vd.table(rows, class_='table')
return vd.div(ScrollArea(vd.div(table), height=400))
def render(self):
rows = []
rows.append(vd.tr(
vd.th('Study'), vd.td(self._context.studyName())
))
rows.append(vd.tr(
vd.th('Recording'), vd.td(self._context.recordingName())
))
rows.append(vd.tr(
vd.th('Directory'), vd.td(self._context.recordingDirectory())
))
RX = self._context.recordingExtractor()
rows.append(vd.tr(
vd.th('Num. channels'), vd.td('{}'.format(len(RX.get_channel_ids())))
))
rows.append(vd.tr(
vd.th('Samplerate'), vd.td('{}'.format(RX.get_sampling_frequency()))
))
a = RX.get_num_frames() / RX.get_sampling_frequency()
rows.append(vd.tr(
vd.th('Duration (s)'), vd.td('{}'.format(a))
))
a = ', '.join(self._context.sortingResultNames())
rows.append(vd.tr(
vd.th('Sorting results'), vd.td('{}'.format(a))
))
sc_true = self._context.trueSortingContext()
if sc_true:
SX_true = sc_true.sortingExtractor()
true_unit_ids = SX_true.get_unit_ids()
rows.append(vd.tr(
vd.th('Num. true units'), vd.td('{}'.format(len(true_unit_ids)))
))
table = vd.table(rows, style={
'text-align': 'left', 'width': 'auto', 'font-size': '13px'}, class_='table')
return vd.div(
vd.h2('{}/{}'.format(self._context.studyName(), self._context.recordingName())),
table
)
def render(self):
if not self._job:
return vd.div('none')
status = self._job_status.get('status')
if not status:
status = 'unknown'
if self._job_console_output is not None:
#contenteditable is used to enable ctrl+a select
console_output_elmt = vd.div(vd.pre(self._job_console_output),
style={
'background': 'black',
'color': 'white'
},
contenteditable="true")
else:
console_output_elmt = self._show_console_output_button
table = vd.table(vd.tr(vd.td('Status:'), vd.td(status)))
out = vd.div(console_output_elmt,
style=dict(overflow='auto', height='300px'))
ret = vd.div(vd.h3(self._job['label']), table, out)
return ret
def render(self):
self._study_box.setOptions(self._SF.studyNames())
study = self.study()
if study:
self._recording_box.setOptions(study.recordingNames())
recording = self.recording()
if recording:
self._sorting_result_box.setOptions(
recording.sortingResultNames())
else:
self._sorting_result_box.setOptions([])
else:
self._recording_box.setOptions([])
self._sorting_result_box.setOptions([])
study_row = vd.tr(vd.td('Study **: '), vd.td(self._study_box))
recording_row = vd.tr(vd.td('Recording: '), vd.td(self._recording_box))
sorting_result_row = vd.tr(vd.td('Sorting result: '),
vd.td(self._sorting_result_box))
rows = []
mode = self._mode
if mode == 'study':
rows = [study_row]
elif mode == 'recording':
rows = [study_row, recording_row]
elif mode == 'sorting_result':
rows = [study_row, recording_row, sorting_result_row]
else:
raise Exception('Invalid mode: ' + mode)
Table = vd.table(*rows)
div = vd.div(
vd.hr(),
Table,
vd.hr(),
)
return div
def render(self):
# row info for the table
rr = []
rr.append(
dict(label='Recording groups',
value=', '.join(self._context.recordingGroups())))
rr.append(
dict(label='Sorters to run',
value=', '.join(self._context.sorterKeys())))
rr.append(dict(label='Output path', value=self._context.outputPath()))
rr.append(
dict(label='Download from',
value=', '.join(self._context.downloadFrom())))
rr.append(
dict(label='Job timeout (sec)', value=self._context.jobTimeout()))
rr.append(
dict(label='Compute resources',
value=', '.join(self._context.computeResourceKeys())))
rr.append(
dict(label='Sorter definition keys',
value=', '.join(self._context.sorterDefinitionKeys())))
rows = []
for r in rr:
rows.append(vd.tr(vd.th(r['label']), vd.td(r['value'])))
table = vd.table(rows,
style={
'text-align': 'left',
'width': 'auto',
'font-size': '13px'
},
class_='table')
return vd.components.ScrollArea(
vd.div(vd.h2('Analysis: {}'.format(self._context.analysisName())),
table,
height=self._size[1]))
def render(self):
if not self._recording:
return vd.div('---')
rec = self._recording
rows = []
rows.append(vd.tr(vd.th('Study'), vd.td(rec.study().name())))
rows.append(vd.tr(vd.th('Recording'), vd.td(rec.name())))
rows.append(vd.tr(vd.th('Directory'), vd.td(rec.directory())))
true_units = rec.trueUnitsInfo(format='json')
if true_units:
rows.append(
vd.tr(vd.th('Num. true units'),
vd.td('{}'.format(len(true_units)))))
RX = rec.recordingExtractor()
rows.append(
vd.tr(vd.th('Num. channels'),
vd.td('{}'.format(len(RX.getChannelIds())))))
rows.append(
vd.tr(vd.th('Samplerate'),
vd.td('{}'.format(RX.getSamplingFrequency()))))
recording_file_is_local = self._recording.recordingFileIsLocal()
if recording_file_is_local:
elmt = 'True'
else:
elmt = vd.span(
'False', ' ',
vd.a('(download)', onclick=self._on_download_recording_file))
rows.append(vd.tr(vd.th('raw.mda is downloaded'), vd.td(elmt)))
firings_true_file_is_local = self._recording.firingsTrueFileIsLocal()
if firings_true_file_is_local:
elmt = 'True'
else:
elmt = vd.span(
'False', ' ',
vd.a('(download)',
onclick=self._on_download_firings_true_file))
rows.append(vd.tr(vd.th('firings_true.mda is downloaded'),
vd.td(elmt)))
res = None
if self._sorting_result_name:
res = self._recording.sortingResult(self._sorting_result_name)
if res:
rows.append(
vd.tr(vd.th('Sorting result'),
vd.td(self._sorting_result_name)))
sorting = res.sorting()
rows.append(
vd.tr(vd.th('Num. sorted units'),
vd.td('{}'.format(len(sorting.getUnitIds())))))
table = vd.table(rows,
style={
'text-align': 'left',
'width': 'auto',
'font-size': '13px'
},
class_='table')
button_bar = ButtonBar([
('View timeseries', self._on_view_timeseries),
('View electrode geometry', self._on_view_geometry),
('View true unit table', self._on_view_true_units),
('View true unit waveforms', self._on_view_true_unit_waveforms),
('View true unit autocorrelograms',
self._on_view_true_unit_autocorrelograms)
])
elmts = [table, button_bar]
if res:
button_bar_result = ButtonBar([
('View comparison with truth table',
self._on_view_comparison_with_truth_table),
('View sorted unit waveforms',
self._on_view_sorted_unit_waveforms)
])
elmts.append(button_bar_result)
if self._view:
elmts.append(self._view)
return vd.div(elmts)
