def create_fake_measurement_table(table_index=None, reagent_media_cells=None):
ip_table = IntentParserTable()
curr_table_index = 0
if table_index is not None:
ip_cell = IntentParserCell()
ip_cell.add_paragraph('Table %d: Measurements' % table_index)
ip_table.add_row([ip_cell])
ip_table.set_caption_row_index(curr_table_index)
curr_table_index += 1
header_names = [
ip_constants.HEADER_MEASUREMENT_TYPE_VALUE,
ip_constants.HEADER_FILE_TYPE_VALUE,
ip_constants.HEADER_REPLICATE_VALUE, ip_constants.HEADER_STRAINS_VALUE,
ip_constants.HEADER_ODS_VALUE, ip_constants.HEADER_TEMPERATURE_VALUE,
ip_constants.HEADER_TIMEPOINT_VALUE, ip_constants.HEADER_BATCH_VALUE,
ip_constants.HEADER_CONTROL_VALUE, ip_constants.HEADER_SAMPLES_VALUE,
ip_constants.HEADER_NOTES_VALUE, ip_constants.HEADER_COLUMN_ID_VALUE,
ip_constants.HEADER_LAB_ID_VALUE, ip_constants.HEADER_ROW_ID_VALUE,
ip_constants.HEADER_NUMBER_OF_NEGATIVE_CONTROLS_VALUE,
ip_constants.HEADER_USE_RNA_INHIBITOR_IN_REACTION_VALUE,
ip_constants.HEADER_DNA_REACTION_CONCENTRATION_VALUE,
ip_constants.HEADER_TEMPLATE_DNA_VALUE
]
header_row = _create_table_headers(header_names)
if reagent_media_cells:
header_row.extend(reagent_media_cells)
ip_table.add_row(header_row)
ip_table.set_header_row_index(curr_table_index)
return ip_table
def test_reagent_header_without_timepoint(self):
cell = IntentParserCell()
cell.add_paragraph('name1')
name, _ = self.parser.process_reagent_header(cell,
units={'hour'},
unit_type='timepoints')
self.assertEqual('name1', name['label'])
def _parse_row(self, row):
columns = row['tableCells']
for cell in columns:
ip_cell = IntentParserCell()
for content, link, bookmark_id in self._parse_cell(cell):
ip_cell.add_paragraph(content, link, bookmark_id)
yield ip_cell
def test_strains_with_uri_and_trailing_strings(self):
ip_table = test_utils.create_fake_controls_table(1)
control_type = IntentParserCell()
control_type.add_paragraph('HIGH_FITC')
strains = IntentParserCell()
strains.add_paragraph(
'MG1655', link='https://hub.sd2e.org/user/sd2e/design/MG1655/1')
strains.add_paragraph(', MG1655_LPV3,MG1655_RPU_Standard')
data_row = test_utils.create_control_table_row(
strains_cell=strains, control_type_cell=control_type)
ip_table.add_row(data_row)
control_table_parser = ControlsTable(
ip_table,
strain_mapping=self.strain_mappings,
control_types={'HIGH_FITC'})
control_table_parser.process_table()
control_result = control_table_parser.get_intents()
self.assertEquals(1, len(control_result))
exp_res = {
'sbh_uri': 'https://hub.sd2e.org/user/sd2e/design/MG1655/1',
'label': 'strain1',
'lab_id': 'name.ip_admin.MG1655'
}
expected_result = {
dc_constants.TYPE: 'HIGH_FITC',
dc_constants.STRAINS: [exp_res]
}
self.assertEqual(expected_result,
control_result[0].to_structured_request())
def _create_table_headers(header_names):
header_row = []
for name in header_names:
ip_cell = IntentParserCell()
ip_cell.add_paragraph(name)
header_row.append(ip_cell)
return header_row
def test_value_unit(self):
cell = IntentParserCell()
cell.add_paragraph('3 hour')
result = self.parser.process_values_unit(cell,
units={'hour'},
unit_type='timepoints')
self.assertEqual(1, len(result))
self.assertEqual({'value': 3.0, 'unit': 'hour'}, result[0])
def create_fake_lab_table(table_index=None):
ip_table = IntentParserTable()
if table_index is not None:
ip_cell = IntentParserCell()
ip_cell.add_paragraph('Table %d: Lab' % table_index)
ip_table.add_row([ip_cell])
ip_table.set_header_row_index(0)
return ip_table
def test_reagent_header_with_timepoint(self):
cell = IntentParserCell()
cell.add_paragraph('name @ 15 hours')
name, timepoint = self.parser.process_reagent_header(
cell, units={'hour'}, unit_type='timepoints')
self.assertEqual('name', name['label'])
self.assertEqual('NO PROGRAM DICTIONARY ENTRY', name['sbh_uri'])
self.assertEqual(timepoint['value'], 15.0)
self.assertEqual(timepoint['unit'], 'hour')
def test_value_unit_pairs(self):
cell = IntentParserCell()
cell.add_paragraph('1 X, 2 mM ,3 micromole')
result = self.parser.process_values_unit(
cell, units={'X', 'mM', 'micromole'}, unit_type='fluid')
self.assertEqual(3, len(result))
self.assertEqual({'value': 1.0, 'unit': 'X'}, result[0])
self.assertEqual({'value': 2.0, 'unit': 'mM'}, result[1])
self.assertEqual({'value': 3.0, 'unit': 'micromole'}, result[2])
def test_parse_content_item_with_name(self):
cell = IntentParserCell()
cell.add_paragraph('name')
results = self.parser.parse_content_item(cell)
self.assertEqual(len(results), 1)
result = results[0]
name = result['name']
self.assertEqual(2, len(name))
self.assertEqual('name', name['label'])
self.assertEqual('NO PROGRAM DICTIONARY ENTRY', name['sbh_uri'])
def test_table_with_experiment_id_spacing(self):
ip_table = test_utils.create_fake_lab_table()
experiment_id_cell = IntentParserCell()
experiment_id_cell.add_paragraph('experiment_id:29422')
ip_table.add_row([experiment_id_cell])
table_parser = LabTable(ip_table)
table_parser.process_table()
table_content = table_parser.get_structured_request()
self.assertEqual(table_content[dc_constants.LAB],
ip_constants.TACC_SERVER)
self.assertEqual(table_content[dc_constants.EXPERIMENT_ID],
'experiment.tacc.29422')
def test_parameter_field_with_empty_value(self):
ip_table = test_utils.create_fake_parameter()
parameter = IntentParserCell()
parameter.add_paragraph('Inoculation volume')
data_row = test_utils.create_parameter_table_row(
parameter_cell=parameter)
ip_table.add_row(data_row)
param_table = ParameterTable(ip_table,
parameter_fields=self.parameter_fields)
param_table.process_table()
param_result = param_table.get_structured_request()
self.assertEqual(0, len(param_result))
def test_parse_content_item_with_name_value_unit(self):
cell = IntentParserCell()
cell.add_paragraph('name1 123 unit')
results = self.parser.parse_content_item(
cell, timepoint_units={'unit', 'timeunit'})
self.assertEqual(len(results), 1)
result = results[0]
name = result['name']
self.assertEqual(2, len(name))
self.assertEqual('name1', name['label'])
self.assertEqual('NO PROGRAM DICTIONARY ENTRY', name['sbh_uri'])
self.assertEqual('123', result['value'])
self.assertEqual('unit', result['unit'])
def test_table_with_contents(self):
ip_table = test_utils.create_fake_controls_table(1)
control_type = IntentParserCell()
control_type.add_paragraph('HIGH_FITC')
content = IntentParserCell()
content.add_paragraph(
'beta_estradiol',
link='https://hub.sd2e.org/user/sd2e/design/beta_estradiol/1')
data_row = test_utils.create_control_table_row(
contents_cell=content, control_type_cell=control_type)
ip_table.add_row(data_row)
control_table_parser = ControlsTable(ip_table,
control_types={'HIGH_FITC'})
control_table_parser.process_table()
control_result = control_table_parser.get_intents()
content = {
dc_constants.NAME: {
dc_constants.LABEL:
'beta_estradiol',
dc_constants.SBH_URI:
'https://hub.sd2e.org/user/sd2e/design/beta_estradiol/1'
}
}
expected_result = {
dc_constants.TYPE: 'HIGH_FITC',
dc_constants.CONTENTS: [content]
}
self.assertEqual(expected_result,
control_result[0].to_structured_request())
def test_table_with_1_timepoint(self):
ip_table = test_utils.create_fake_controls_table(1)
content = IntentParserCell()
content.add_paragraph('8 hour')
control_type = IntentParserCell()
control_type.add_paragraph('HIGH_FITC')
data_row = test_utils.create_control_table_row(
timepoint_cell=content, control_type_cell=control_type)
ip_table.add_row(data_row)
control_table_parser = ControlsTable(ip_table,
timepoint_units={'hour'},
control_types={'HIGH_FITC'})
control_table_parser.process_table()
control_result = control_table_parser.get_intents()
self.assertEqual(1, len(control_result))
expected_timepoint = {
dc_constants.VALUE: 8.0,
dc_constants.UNIT: 'hour'
}
expected_result = {
dc_constants.TYPE: 'HIGH_FITC',
dc_constants.TIMEPOINTS: [expected_timepoint]
}
self.assertEqual(expected_result,
control_result[0].to_structured_request())
def test_container_search_string_with_default_value(self):
ip_table = test_utils.create_fake_parameter()
container_search_string = IntentParserCell()
container_search_string.add_paragraph('Container Search String')
parameter_value = IntentParserCell()
parameter_value.add_paragraph('\n')
data_row = test_utils.create_parameter_table_row(
parameter_cell=container_search_string,
parameter_value_cell=parameter_value)
ip_table.add_row(data_row)
param_table = ParameterTable(ip_table,
parameter_fields=self.parameter_fields)
param_table.process_table()
expected_experiment_result = {
ip_constants.PARAMETER_BASE_DIR: None,
ip_constants.PARAMETER_XPLAN_REACTOR: 'xplan',
ip_constants.PARAMETER_PLATE_SIZE: None,
ip_constants.PARAMETER_PROTOCOL_NAME: None,
ip_constants.PARAMETER_PLATE_NUMBER: None,
ip_constants.PARAMETER_CONTAINER_SEARCH_STRING:
dc_constants.GENERATE,
ip_constants.PARAMETER_STRAIN_PROPERTY: None,
ip_constants.PARAMETER_XPLAN_PATH: None,
ip_constants.PARAMETER_SUBMIT: True,
ip_constants.PARAMETER_PROTOCOL_ID: None,
ip_constants.PARAMETER_TEST_MODE: False,
ip_constants.PARAMETER_EXPERIMENT_REFERENCE_URL_FOR_XPLAN: None,
ip_constants.DEFAULT_PARAMETERS: {}
}
self.assertEqual(13, len(param_table.get_experiment()))
self.assertDictEqual(expected_experiment_result,
param_table.get_experiment())
def test_parameter_string_for_hardcoded_measurement_info_flow_info_json_values(
self):
ip_table = test_utils.create_fake_parameter()
parameter = IntentParserCell()
parameter.add_paragraph('Flow cytometer configuration')
parameter_value = IntentParserCell()
parameter_value.add_paragraph(
'{"do_flow": {"value": "every-sampling","inputs": {"every-sampling": {"flow_params" : "yeast"}}}}'
)
data_row = test_utils.create_parameter_table_row(
parameter_cell=parameter, parameter_value_cell=parameter_value)
ip_table.add_row(data_row)
param_table = ParameterTable(ip_table,
parameter_fields=self.parameter_fields)
param_table.process_table()
param_result = param_table.get_structured_request()
self.assertEqual(1, len(param_result))
expected_output = {
"do_flow": {
"value": "every-sampling",
"inputs": {
"every-sampling": {
"flow_params": "yeast"
}
}
}
}
self.assertEqual(expected_output,
param_result['measurement_info.flow_info'])
def create_fake_controls_table(table_index=None):
ip_table = IntentParserTable()
curr_table_index = 0
if table_index is not None:
ip_cell = IntentParserCell()
ip_cell.add_paragraph('Table %d: Controls' % table_index)
ip_table.add_row([ip_cell])
ip_table.set_caption_row_index(curr_table_index)
curr_table_index += 1
header_row = _create_table_headers(
['Control Type', 'Strains', 'Channel', 'Contents', 'Timepoint'])
ip_table.add_row(header_row)
ip_table.set_header_row_index(curr_table_index)
return ip_table
def create_parameter_table_row(parameter_cell=None, parameter_value_cell=None):
if parameter_cell is None:
parameter_cell = IntentParserCell()
parameter_cell.add_paragraph('')
if parameter_value_cell is None:
parameter_value_cell = IntentParserCell()
parameter_value_cell.add_paragraph('')
return [parameter_cell, parameter_value_cell]
def test_table_with_control_type(self):
ip_table = test_utils.create_fake_controls_table(1)
control_type = IntentParserCell()
control_type.add_paragraph('HIGH_FITC')
data_row = test_utils.create_control_table_row(
control_type_cell=control_type)
ip_table.add_row(data_row)
control_table_parser = ControlsTable(ip_table,
control_types={'HIGH_FITC'})
control_table_parser.process_table()
control_result = control_table_parser.get_intents()
self.assertEqual(1, len(control_result))
expected_result = {dc_constants.TYPE: 'HIGH_FITC'}
self.assertEqual(expected_result,
control_result[0].to_structured_request())
def create_fake_experiment_specification_table(table_index=None):
ip_table = IntentParserTable()
curr_table_index = 0
if table_index is not None:
ip_cell = IntentParserCell()
ip_cell.add_paragraph('Table %d: Experiment Specification' %
table_index)
ip_table.add_row([ip_cell])
ip_table.set_caption_row_index(curr_table_index)
curr_table_index += 1
header_names = [
'Experiment Id', ip_constants.HEADER_EXPERIMENT_STATUS_VALUE
]
header_row = _create_table_headers(header_names)
ip_table.add_row(header_row)
ip_table.set_header_row_index(curr_table_index)
return ip_table
def create_experiment_specification_table_row(experiment_id_cell=None,
experiment_status_cell=None):
if experiment_id_cell is None:
experiment_id_cell = IntentParserCell()
experiment_id_cell.add_paragraph('')
if experiment_status_cell is None:
experiment_status_cell = IntentParserCell()
experiment_status_cell.add_paragraph('')
return [experiment_id_cell, experiment_status_cell]
def create_fake_parameter(table_index=None):
ip_table = IntentParserTable()
curr_table_index = 0
if table_index is not None:
ip_cell = IntentParserCell()
ip_cell.add_paragraph('Table %d: Parameter' % table_index)
ip_table.add_row([ip_cell])
ip_table.set_caption_row_index(curr_table_index)
curr_table_index += 1
header_names = [
ip_constants.HEADER_PARAMETER_VALUE,
ip_constants.HEADER_PARAMETER_VALUE_VALUE
]
header_row = _create_table_headers(header_names)
ip_table.add_row(header_row)
ip_table.set_header_row_index(curr_table_index)
return ip_table
def create_fake_experiment_status_table(table_index=None):
ip_table = IntentParserTable()
curr_table_index = 0
if table_index is not None:
ip_cell = IntentParserCell()
ip_cell.add_paragraph('Table %d: Experiment Status' % table_index)
ip_table.add_row([ip_cell])
ip_table.set_caption_row_index(curr_table_index)
curr_table_index += 1
header_names = [
ip_constants.HEADER_PIPELINE_STATUS_VALUE,
ip_constants.HEADER_LAST_UPDATED_VALUE, ip_constants.HEADER_PATH_VALUE,
ip_constants.HEADER_STATE_VALUE
]
header_row = _create_table_headers(header_names)
ip_table.add_row(header_row)
ip_table.set_header_row_index(curr_table_index)
return ip_table
def test_parse_content_item_with_list_of_names(self):
cell = IntentParserCell()
cell.add_paragraph('name1, name2, name3')
results = self.parser.parse_content_item(cell)
self.assertEqual(len(results), 3)
name1 = results[0]['name']
name2 = results[1]['name']
name3 = results[2]['name']
self.assertEqual(name1, {
'label': 'name1',
'sbh_uri': 'NO PROGRAM DICTIONARY ENTRY'
})
self.assertEqual(name2, {
'label': 'name2',
'sbh_uri': 'NO PROGRAM DICTIONARY ENTRY'
})
self.assertEqual(name3, {
'label': 'name3',
'sbh_uri': 'NO PROGRAM DICTIONARY ENTRY'
})
def test_parse_content_item_with_name(self):
cell = IntentParserCell()
cell.add_paragraph('name')
results = self.parser.parse_content_item(cell.get_text(),
cell.get_text_with_url())
self.assertEqual(len(results), 1)
self.assertEqual('name', results[0].get_named_link().get_name())
self.assertIsNone(results[0].get_named_link().get_link())
def _parse_row(self, row):
columns = row[doc_constants.TABLE_CELLS]
for cell in columns:
ip_cell = IntentParserCell()
if doc_constants.START_INDEX in cell:
start_index = cell[doc_constants.START_INDEX]
ip_cell.set_start_index(start_index)
if doc_constants.END_INDEX in cell:
end_index = cell[doc_constants.END_INDEX]
ip_cell.set_end_index(end_index)
for content, link, bookmark_id in self._parse_cell(cell):
ip_cell.add_paragraph(content, link, bookmark_id)
yield ip_cell
def test_parameter_with_non_boolean_value(self):
ip_table = test_utils.create_fake_parameter()
parameter = IntentParserCell()
parameter.add_paragraph('Sample has sbh_uri as an aliquot property')
parameter_value = IntentParserCell()
parameter_value.add_paragraph('neither')
data_row = test_utils.create_parameter_table_row(
parameter_cell=parameter, parameter_value_cell=parameter_value)
ip_table.add_row(data_row)
param_table = ParameterTable(ip_table,
parameter_fields=self.parameter_fields)
param_table.process_table()
param_result = param_table.get_structured_request()
self.assertEqual(0, len(param_result))
def test_parameter_string_value_with_colon_separator(self):
ip_table = test_utils.create_fake_parameter()
parameter = IntentParserCell()
parameter.add_paragraph('Inoculation volume')
parameter_value = IntentParserCell()
parameter_value.add_paragraph('5 microliter')
data_row = test_utils.create_parameter_table_row(
parameter_cell=parameter, parameter_value_cell=parameter_value)
ip_table.add_row(data_row)
param_table = ParameterTable(ip_table,
parameter_fields=self.parameter_fields)
param_table.process_table()
param_result = param_table.get_structured_request()
self.assertEqual(1, len(param_result))
self.assertEqual('5:microliter', param_result['inoc_info.inoc_vol'])
def test_parameter_string_value_with_list_of_numbers(self):
ip_table = test_utils.create_fake_parameter()
parameter = IntentParserCell()
parameter.add_paragraph('Media well ids')
parameter_value = IntentParserCell()
parameter_value.add_paragraph('94,95')
data_row = test_utils.create_parameter_table_row(
parameter_cell=parameter, parameter_value_cell=parameter_value)
ip_table.add_row(data_row)
param_table = ParameterTable(ip_table,
parameter_fields=self.parameter_fields)
param_table.process_table()
param_result = param_table.get_structured_request()
self.assertEqual(1, len(param_result))
self.assertEqual('94,95', param_result['exp_info.media_well_strings'])
