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_strains_with_mix_string_and_uri(self):
input_table = {'tableRows': [
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'Strains\n' }}]}}]}]},
{'tableCells': [{'content': [
{'paragraph': {'elements': [{'textRun': {
'content': 'MG1655','textStyle': {'link': {'url': 'https://hub.sd2e.org/user/sd2e/design/MG1655/1'}
}}}]}},
{'paragraph': {'elements': [{'textRun': {
'content': ',\n'}}]}},
{'paragraph': {'elements': [{'textRun': {
'content': 'MG1655_RPU_Standard\n'}}]}},
{'paragraph': {'elements': [{'textRun': {
'content': ',\n'}}]}},
{'paragraph': {'elements': [{'textRun': {
'content': 'MG1655_LPV3','textStyle': {'link': {'url': 'https://hub.sd2e.org/user/sd2e/design/MG1655_LPV3/1'}
}}}]}} ]}]}]
}
ip_table = self.ip_table_factory.from_google_doc(input_table)
ip_table.set_header_row_index(0)
control_table_parser = ControlsTable(ip_table)
control_result = control_table_parser.process_table()
self.assertEquals(1, len(control_result))
exp_res = ['MG1655', 'MG1655_RPU_Standard', 'MG1655_LPV3']
self.assertListEqual(exp_res, control_result[0]['strains'])
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 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_table_with_multiple_channels(self):
input_table = {'tableRows': [
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'Channel\n' }}]}}]}]},
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'BL1-A, BL2-A\n'}}]}}]}]}]
}
ip_table = self.ip_table_factory.from_google_doc(input_table)
ip_table.set_header_row_index(0)
control_table_parser = ControlsTable(ip_table)
control_result = control_table_parser.process_table()
self.assertEqual(1, len(control_result))
self.assertEqual(control_result[0]['channel'], 'BL1-A')
def test_table_with_control_type(self):
input_table = {'tableRows': [
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'Control Type\n' }}]}}]}]},
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'HIGH_FITC\n'}}]}}]}]}]
}
ip_table = self.ip_table_factory.from_google_doc(input_table)
ip_table.set_header_row_index(0)
control_table_parser = ControlsTable(ip_table, control_types={'HIGH_FITC'})
control_result = control_table_parser.process_table()
self.assertEqual(1, len(control_result))
self.assertEqual(control_result[0]['type'], 'HIGH_FITC')
def test_strains_with_uris(self):
input_table = {'tableRows': [
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'Strains\n' }}]}}]}]},
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'UWBF_7376','textStyle': {'link': {'url': 'https://hub.sd2e.org/user/sd2e/design/UWBF_7376/1'}
}}}]}}]}]}]
}
ip_table = self.ip_table_factory.from_google_doc(input_table)
ip_table.set_header_row_index(0)
control_table_parser = ControlsTable(ip_table)
control_result = control_table_parser.process_table()
self.assertEquals(1, len(control_result))
self.assertEqual(1, len(control_result[0]['strains']))
self.assertEqual('UWBF_7376', control_result[0]['strains'][0])
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 test_table_with_1_strain(self):
input_table = {'tableRows': [
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'Strains\n' }}]}}]}]},
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'UWBF_25784\n'}}]}}]}]}]
}
ip_table = self.ip_table_factory.from_google_doc(input_table)
ip_table.set_header_row_index(0)
control_table_parser = ControlsTable(ip_table)
control_result = control_table_parser.process_table()
self.assertEqual(1, len(control_result))
actual_strains = control_result[0]['strains']
self.assertEqual(1, len(actual_strains))
self.assertEqual(actual_strains[0], 'UWBF_25784')
def test_table_with_1_timepoint(self):
input_table = {'tableRows': [
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'Timepoint\n' }}]}}]}]},
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': '8 hour\n'}}]}}]}]}]
}
ip_table = self.ip_table_factory.from_google_doc(input_table)
ip_table.set_header_row_index(0)
control_table_parser = ControlsTable(ip_table, timepoint_units={'hour'})
control_result = control_table_parser.process_table()
self.assertEqual(1, len(control_result))
timepoint_list = control_result[0]['timepoints']
self.assertEqual(1, len(timepoint_list))
expected_timepoint = {'value': 8.0, 'unit': 'hour'}
self.assertEqual(timepoint_list[0], expected_timepoint)
def test_table_with_contents(self):
input_table = {'tableRows': [
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'Contents\n' }}]}}]}]},
{'tableCells': [{'content': [{'paragraph': {'elements': [{'textRun': {
'content': 'beta_estradiol\n','textStyle': {'link': {'url': 'https://hub.sd2e.org/user/sd2e/design/beta_estradiol/1'}
} }}]}}]}]}]
}
ip_table = self.ip_table_factory.from_google_doc(input_table)
ip_table.set_header_row_index(0)
control_table_parser = ControlsTable(ip_table)
control_result = control_table_parser.process_table()
self.assertEqual(1, len(control_result))
self.assertEqual(1, len(control_result[0]['contents']))
content = control_result[0]['contents'][0]
self.assertEqual(2, len(content['name']))
self.assertEqual(content['name']['label'], 'beta_estradiol')
self.assertEqual(content['name']['sbh_uri'], 'https://hub.sd2e.org/user/sd2e/design/beta_estradiol/1')
def test_table_with_multiple_channels(self):
ip_table = test_utils.create_fake_controls_table(1)
control_type = IntentParserCell()
control_type.add_paragraph('HIGH_FITC')
channel = IntentParserCell()
channel.add_paragraph('BL1-A, BL2-A')
data_row = test_utils.create_control_table_row(
channel_cell=channel, 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()
expected_result = {
dc_constants.TYPE: 'HIGH_FITC',
dc_constants.CHANNEL: 'BL1-A'
}
self.assertEqual(expected_result,
control_result[0].to_structured_request())
def process_control_tables(self, control_tables):
if not control_tables:
self.validation_warnings.append('No measurement table to parse from document.')
return
strain_mapping = {}
try:
strain_mapping = self.sbol_dictionary.get_mapped_strain(self.processed_labs[dc_constants.LAB])
except (DictionaryMaintainerException, TableException) as err:
self.validation_errors.extend([err.get_message()])
for table in control_tables:
controls_table = ControlsTable(table,
control_types=self.catalog_accessor.get_control_type(),
fluid_units=self.catalog_accessor.get_fluid_units(),
timepoint_units=self.catalog_accessor.get_time_units(),
strain_mapping=strain_mapping)
controls_table.process_table()
control_intents = controls_table.get_intents()
table_caption = controls_table.get_table_caption()
if table_caption:
self.processed_controls[table_caption] = control_intents
self.validation_errors.extend(controls_table.get_validation_errors())
self.validation_warnings.extend(controls_table.get_validation_warnings())
def _process_control_tables(self, control_tables):
ref_controls = {}
if not control_tables:
return ref_controls
for table in control_tables:
controls_table = ControlsTable(table,
self.catalog_accessor.get_control_type(),
self.catalog_accessor.get_fluid_units(),
self.catalog_accessor.get_time_units())
controls_data = controls_table.process_table()
table_caption = controls_table.get_table_caption()
if table_caption:
ref_controls[table_caption] = controls_data
self.validation_errors.extend(controls_table.get_validation_errors())
self.validation_warnings.extend(controls_table.get_validation_warnings())
return ref_controls
def _process_control_tables(self, control_tables, strain_mapping):
if not control_tables:
self.validation_errors.append(
'No control tables to parse from document.')
return
try:
for table in control_tables:
controls_table = ControlsTable(
table,
control_types=self._CONTROL_TYPES,
fluid_units=self._FLUID_UNITS,
timepoint_units=self._TIME_UNITS,
strain_mapping=strain_mapping)
controls_table.process_table()
table_caption = controls_table.get_table_caption()
if table_caption:
self.processed_controls[table_caption] = controls_table
self.validation_errors.extend(
controls_table.get_validation_errors())
self.validation_warnings.extend(
controls_table.get_validation_warnings())
except IntentParserException as err:
self.validation_errors.extend([err.get_message()])
