def _process_variable_features(self, variable_features, uris_to_localsubcomponents, uris_to_components, measurement_intent):
for variable_feature in variable_features:
if not variable_feature.variable:
message = 'No variable set to VariableFeature %s' % variable_feature.identity
self.validation_errors.append(message)
return
str_variable = str(variable_feature.variable)
if str_variable not in uris_to_localsubcomponents:
message = 'No LocalSubComponent found with id: %s' % str_variable
self.validation_errors.append(message)
return
content_intent = ContentIntent()
local_or_subcomponent_template = uris_to_localsubcomponents[str_variable]
if ip_constants.NCIT_STRAIN_URI in local_or_subcomponent_template.roles:
self._process_variants_as_strain_values(variable_feature.variants,
measurement_intent,
uris_to_components)
else:
# process unidentified opil.LocalSubComponent as reagent or media using value encoding
if variable_feature.variant_measures:
reagent_name = NamedLink(local_or_subcomponent_template.name)
reagent_intent = ReagentIntent(reagent_name)
self._add_reagent_values_from_variant_measures(variable_feature.variant_measures,
reagent_intent)
content_intent.add_reagent(reagent_intent)
measurement_intent.add_content(content_intent)
elif variable_feature.variants:
media_name = NamedLink(local_or_subcomponent_template.name)
media_intent = MediaIntent(media_name)
self._add_media_values_from_variants(variable_feature.variants,
media_intent,
uris_to_components)
content_intent.add_media(media_intent)
measurement_intent.add_content(content_intent)
def create_name_with_uri(self, label, uri_dictionary):
stripped_label = label.strip()
if stripped_label in uri_dictionary and uri_dictionary[stripped_label]:
name = NamedLink(stripped_label,
link=uri_dictionary[stripped_label])
return name
name = NamedLink(stripped_label)
return name
def test_measurement_with_neg_control_content_size_1(self):
measurement_intent = MeasurementIntent()
measurement_intent.set_measurement_type(
ip_constants.MEASUREMENT_TYPE_CONDITION_SPACE)
measurement_intent.add_file_type('SPREADSHEET')
content = ContentIntent()
num_neg_control = NamedIntegerValue(
NamedLink(ip_constants.HEADER_NUMBER_OF_NEGATIVE_CONTROLS_VALUE),
2)
content.set_numbers_of_negative_controls([num_neg_control])
measurement_intent.add_content(content)
content_structure_request = [{
dc_constants.NAME: {
dc_constants.LABEL:
ip_constants.HEADER_NUMBER_OF_NEGATIVE_CONTROLS_VALUE,
dc_constants.SBH_URI: dc_constants.NO_PROGRAM_DICTIONARY
},
dc_constants.VALUE: 2
}]
self.assertDictEqual(
{
dc_constants.CONTENTS: [content_structure_request],
dc_constants.FILE_TYPE: ['SPREADSHEET'],
dc_constants.MEASUREMENT_TYPE:
ip_constants.MEASUREMENT_TYPE_CONDITION_SPACE
}, measurement_intent.to_structured_request())
def test_measurement_with_strain_size_1(self):
measurement_intent = MeasurementIntent()
measurement_intent.set_measurement_type(
ip_constants.MEASUREMENT_TYPE_CONDITION_SPACE)
measurement_intent.add_file_type('SPREADSHEET')
strain_name = NamedLink('and_00',
link='www.synbiohub.org/example/strain')
strain = StrainIntent(strain_name)
strain.set_strain_lab_name('my_lab')
strain.set_strain_common_name('my_strain')
measurement_intent.add_strain(strain)
strain_structure_request = {
dc_constants.SBH_URI: 'www.synbiohub.org/example/strain',
dc_constants.LABEL: 'my_strain',
dc_constants.LAB_ID: 'name.my_lab.and_00'
}
self.assertEqual(
{
dc_constants.MEASUREMENT_TYPE:
ip_constants.MEASUREMENT_TYPE_CONDITION_SPACE,
dc_constants.FILE_TYPE: ['SPREADSHEET'],
dc_constants.STRAINS: [strain_structure_request]
}, measurement_intent.to_structured_request())
def _process_variants_as_strain_values(self, variants, measurement_intent, uris_to_components):
# no default values provided for strains
if not variants:
strain_name = NamedLink(' ')
strain_intent = StrainIntent(strain_name)
measurement_intent.add_strain(strain_intent)
return
# strains were provided in template
for variant in variants:
if variant not in uris_to_components:
message = 'Strain variant not found: %s' % variant
self.validation_errors.append(message)
continue
strain_component = uris_to_components[variant]
strain_name = NamedLink(strain_component.name)
strain_intent = StrainIntent(strain_name)
measurement_intent.add_strain(strain_intent)
def test_reagent_to_opil_without_timepoint(self):
reagent_name = NamedLink('M9',
'https://hub.sd2e.org/user/sd2e/design/M9/1')
reagent = ReagentIntent(reagent_name)
reagent_value = MeasuredUnit(10.0, 'uM')
reagent.add_reagent_value(reagent_value)
#TODO:
reagent_component = reagent.reagent_values_to_opil_measures()
def _add_media_values_from_variants(self, variants, media_intent, uris_to_components):
for variant in variants:
if variant not in uris_to_components:
message = 'No Component found for Media variant: %s' % variant
self.validation_errors.append(message)
continue
media_component = uris_to_components[variant]
media_value = NamedLink(media_component.name)
media_intent.add_media_value(media_value)
def _process_row_id(self, cell, row_index, column_index):
row_ids = []
try:
for value in cell_parser.PARSER.process_numbers(cell.get_text()):
name = NamedLink('row_id')
row_id = NamedIntegerValue(name, int(value))
row_ids.append(row_id)
except TableException as err:
message = 'Measurement table at row %d column %d has invalid %s value: %s' % (
row_index, column_index, ip_constants.HEADER_ROW_ID_VALUE, err)
self._validation_errors.append(message)
self._has_row_id = True
return row_ids
def _process_reagent_or_media(self, cell, header_cell, row_index,
column_index):
result = []
text = cell.get_text()
try:
named_link, timepoint = cell_parser.PARSER.process_reagent_or_media_header(
header_cell.get_text(),
header_cell.get_text_with_url(),
units=self._timepoint_units,
unit_type=ip_constants.UNIT_TYPE_TIMEPOINTS)
except TableException as err:
message = err.get_message()
self._validation_errors.append(message)
return []
if cell_parser.PARSER.is_valued_cell(text):
# content is of type reagent if cell contains value with units
try:
measured_units = cell_parser.PARSER.process_values_unit(
text,
units=self._fluid_units,
unit_type=ip_constants.UNIT_TYPE_FLUID)
reagent = ReagentIntent(named_link)
for measured_unit in measured_units:
reagent.add_reagent_value(measured_unit)
if timepoint is not None:
reagent.set_timepoint(timepoint)
result.append(reagent)
except TableException as err:
message = err.get_message()
self._validation_errors.append(message)
elif cell_parser.PARSER.is_number(text):
err = '%s is missing a unit' % text
message = (
'Measurement table at row %d column %d has invalid reagent/media value: %s'
% (row_index, column_index, err))
self._validation_errors.append(message)
else:
# content must be of type media if cell contains list of string
media = MediaIntent(named_link)
for name, media_link in cell_parser.PARSER.process_names_with_uri(
cell.get_text(), text_with_uri=cell.get_text_with_url()):
media_value = NamedLink(name, link=media_link)
media.add_media_value(media_value)
if timepoint is not None:
media.set_timepoint(timepoint)
result.append(media)
return result
def _process_num_neg_controls(self, cell, row_index, column_index):
num_neg_controls = []
try:
for value in cell_parser.PARSER.process_numbers(cell.get_text()):
name = NamedLink(
ip_constants.HEADER_NUMBER_OF_NEGATIVE_CONTROLS_VALUE)
num_neg_control = NamedIntegerValue(name, int(value))
num_neg_controls.append(num_neg_control)
except TableException as err:
message = 'Measurement table at row %d column %d has invalid %s value: %s' % (
row_index, column_index,
ip_constants.HEADER_NUMBER_OF_NEGATIVE_CONTROLS_VALUE, err)
self._validation_errors.append(message)
self._has_number_of_negative_controls = True
return num_neg_controls
def _process_template_dna(self, cell, row_index, column_index):
dna_templates = []
try:
for value in cell_parser.PARSER.extract_name_value(
cell.get_text()):
name = NamedLink(ip_constants.HEADER_TEMPLATE_DNA_VALUE)
dna_template = NamedStringValue(name, value)
dna_templates.append(dna_template)
except TableException as err:
message = 'Measurement table at row %d column %d has invalid %s value: %s' % (
row_index, column_index,
ip_constants.HEADER_TEMPLATE_DNA_VALUE, err)
self._validation_errors.append(message)
self._has_template_dna = True
return dna_templates
def test_measurement_with_strain_size_2(self):
measurement_intent = MeasurementIntent()
measurement_intent.set_measurement_type(
ip_constants.MEASUREMENT_TYPE_CONDITION_SPACE)
measurement_intent.add_file_type('SPREADSHEET')
strain_value1 = NamedLink('and_00',
link='www.synbiohub.org/example/and_strain')
strain1 = StrainIntent(strain_value1)
strain1.set_strain_lab_name('my_lab')
strain1.set_strain_common_name('and_strain')
measurement_intent.add_strain(strain1)
strain_value2 = NamedLink('or_gate',
link='www.synbiohub.org/example/or_strain')
strain2 = StrainIntent(strain_value2)
strain2.set_strain_lab_name('my_lab')
strain2.set_strain_common_name('or_strain')
measurement_intent.add_strain(strain2)
strain_structure_request = [{
dc_constants.SBH_URI: 'www.synbiohub.org/example/and_strain',
dc_constants.LABEL: 'and_strain',
dc_constants.LAB_ID: 'name.my_lab.and_00'
}, {
dc_constants.SBH_URI: 'www.synbiohub.org/example/or_strain',
dc_constants.LABEL: 'or_strain',
dc_constants.LAB_ID: 'name.my_lab.or_gate'
}]
self.assertEqual(
{
dc_constants.MEASUREMENT_TYPE:
ip_constants.MEASUREMENT_TYPE_CONDITION_SPACE,
dc_constants.FILE_TYPE: ['SPREADSHEET'],
dc_constants.STRAINS: strain_structure_request
}, measurement_intent.to_structured_request())
def _process_lab_id(self, cell, row_index, column_index):
lab_ids = []
try:
for value in cell_parser.PARSER.extract_name_value(
cell.get_text()):
name = NamedLink('lab_id')
lab_id = NamedStringValue(name, value)
lab_ids.append(lab_id)
except TableException as err:
message = (
'Measurement table at row %d column %d has invalid %s value: %s'
) % (row_index, column_index, ip_constants.HEADER_LAB_ID_VALUE,
err.get_message())
self._validation_errors.append(message)
return lab_ids
def _process_rna_inhibitor_reaction(self, cell, row_index, column_index):
rna_inhibitor_reactions = []
try:
for boolean_value in cell_parser.PARSER.process_boolean_flag(
cell.get_text()):
name = NamedLink(
ip_constants.HEADER_USE_RNA_INHIBITOR_IN_REACTION_VALUE)
rna_inhibitor_reaction = NamedBooleanValue(name, boolean_value)
rna_inhibitor_reactions.append(rna_inhibitor_reaction)
except TableException as err:
message = 'Measurement table at row %d column %d has invalid %s value: %s' % (
row_index, column_index,
ip_constants.HEADER_USE_RNA_INHIBITOR_IN_REACTION_VALUE, err)
self._validation_errors.append(message)
self._has_rna_inhibitor_reaction = True
return rna_inhibitor_reactions
def _process_dna_reaction_concentration(self, cell, row_index,
column_index):
dna_reaction_concentrations = []
try:
for value in cell_parser.PARSER.process_numbers(cell.get_text()):
name = NamedLink(
ip_constants.HEADER_DNA_REACTION_CONCENTRATION_VALUE)
dna_reaction_concentration = NamedIntegerValue(
name, int(value))
dna_reaction_concentrations.append(dna_reaction_concentration)
except TableException as err:
message = 'Measurement table at row %d column %d has invalid %s value: %s' % (
row_index, column_index,
ip_constants.HEADER_DNA_REACTION_CONCENTRATION_VALUE, err)
self._validation_errors.append(message)
self._has_dna_reaction_concentration = True
return dna_reaction_concentrations
def _process_strains(self, cell, measurement, row_index, column_index):
for input_strain, link in cell_parser.PARSER.process_names_with_uri(
cell.get_text(), text_with_uri=cell.get_text_with_url()):
parsed_strain = input_strain.strip()
if link is None:
message = (
'Measurement table at row %d column %d has invalid %s value: %s is missing a SBH URI.'
% (row_index, column_index,
ip_constants.HEADER_STRAINS_VALUE, parsed_strain))
self._validation_errors.append(message)
continue
if link not in self._strain_mapping:
message = (
'Measurement table at row %d column %d has invalid %s value: '
'%s is an invalid link not supported in the SBOL Dictionary Strains tab.'
% (row_index, column_index,
ip_constants.HEADER_STRAINS_VALUE, link))
self._validation_errors.append(message)
continue
dictionary_strain_intent = self._strain_mapping[link]
if not dictionary_strain_intent.has_lab_strain_name(parsed_strain):
lab_name = dictionary_constants.MAPPED_LAB_UID[
dictionary_strain_intent.get_lab_id()]
message = (
'Measurement table at row %d column %d has invalid %s value: '
'%s is not listed under %s in the SBOL Dictionary.' %
(row_index, column_index,
ip_constants.HEADER_STRAINS_VALUE, parsed_strain,
lab_name))
self._validation_errors.append(message)
continue
strain_name = NamedLink(parsed_strain, link)
strain_intent = StrainIntent(strain_name)
strain_intent.set_strain_lab_name(
dictionary_strain_intent.get_lab_id())
strain_intent.set_strain_common_name(
dictionary_strain_intent.get_strain_common_name())
measurement.add_strain(strain_intent)
self._has_strains = True
def test_control_with_strains_size_1(self):
control_intent = ControlIntent()
control_intent.set_control_type('EMPTY_VECTOR')
strain_name = NamedLink('and_00',
link='www.synbiohub.org/example/strain')
strain = StrainIntent(strain_name)
strain.set_strain_lab_name('my_lab')
strain.set_strain_common_name('my_strain')
control_intent.add_strain(strain)
strain_structure_request = {
dc_constants.SBH_URI: 'www.synbiohub.org/example/strain',
dc_constants.LABEL: 'my_strain',
dc_constants.LAB_ID: 'name.my_lab.and_00'
}
self.assertEqual(
{
dc_constants.TYPE: 'EMPTY_VECTOR',
dc_constants.STRAINS: [strain_structure_request]
}, control_intent.to_structured_request())
def test_control_with_content_size_1(self):
control_intent = ControlIntent()
control_intent.set_control_type('EMPTY_VECTOR')
content = ReagentIntent(NamedLink('beta_estradiol'))
reagent_value = MeasuredUnit(0.05, 'micromole')
content.add_reagent_value(reagent_value)
control_intent.add_content(content)
content_structure_request = [{
dc_constants.NAME: {
dc_constants.LABEL: 'beta_estradiol',
dc_constants.SBH_URI: dc_constants.NO_PROGRAM_DICTIONARY
},
dc_constants.VALUE: '0.05',
dc_constants.UNIT: 'micromole'
}]
self.assertEqual(
{
dc_constants.TYPE: 'EMPTY_VECTOR',
dc_constants.CONTENTS: [content_structure_request]
}, control_intent.to_structured_request())
