def _process_sample_set(self, samplesets):
uris_to_components = {}
# collect components
for component in self._opil_document_template.get_components():
if component.identity not in uris_to_components:
uris_to_components[component.identity] = component
else:
if uris_to_components[component.identity]:
raise IntentParserException('conflict mapping Components with same identity.')
if len(samplesets) > len(self._measurement_intents):
raise IntentParserException('Number of SampleSets must be less than or equal to number of '
'IP measurement-intent: %d > %d'
% (len(samplesets), len(self._measurement_intents)))
uris_to_local_and_subcomponents = self._process_sampleset_templates(samplesets, uris_to_components)
for index in range(len(samplesets)):
sample = samplesets[index]
measurement_intent = self._measurement_intents[index]
# todo: replicate not supported in opil
# if sample.replicates:
# measurement_intent.add_replicate(int(sample.replicates[0]))
self._process_variable_features(sample.variable_features,
uris_to_local_and_subcomponents,
uris_to_components,
measurement_intent)
def get_experimental_protocol(self, experimental_request_name):
if experimental_request_name not in self._name_to_json:
raise IntentParserException(
'Protocol not supported by Strateos: %s' %
experimental_request_name)
protocol = self._name_to_json[experimental_request_name]
return self._convert_protocol_to_opil(protocol)
def create_parameter_value_from_parameter(opil_parameter, parameter_value):
if isinstance(opil_parameter, opil.BooleanParameter):
return create_opil_boolean_parameter_value(bool(parameter_value))
elif isinstance(opil_parameter, opil.EnumeratedParameter):
return create_opil_enumerated_parameter_value(str(parameter_value))
elif isinstance(opil_parameter, opil.IntegerParameter):
return create_opil_integer_parameter_value(int(parameter_value))
elif isinstance(opil_parameter, opil.MeasureParameter):
if cell_parser.PARSER.is_number(str(parameter_value)):
return create_opil_measurement_parameter_value(
parameter_value, tyto.OM.number)
possible_units = list(ip_constants.FLUID_UNIT_MAP.keys()) + list(
ip_constants.TIME_UNIT_MAP.keys())
measured_units = cell_parser.PARSER.process_values_unit(
parameter_value, units=possible_units, unit_type='fluid')
if len(measured_units) != 1:
raise IntentParserException(
'Expecting one Measurement Parameter value but %d were found.'
% len(measured_units))
return create_opil_measurement_parameter_value(
float(measured_units[0].get_value()), measured_units[0].get_unit())
elif isinstance(opil_parameter, opil.StringParameter):
return create_opil_string_parameter_value(str(parameter_value))
elif isinstance(opil_parameter, opil.URIParameter):
return create_opil_URI_parameter_value(str(parameter_value))
def process_dictionary_terms(self, document_id, ip_document, user_id, doc_location, dictionary_terms={}):
if not self._started:
raise IntentParserException('AnalyzeDocumentController was not initialized to load ignored terms from file.')
filtered_dictionary = self._filter_dictionary_terms(user_id, dictionary_terms)
analyze_document = self._get_or_create_analyze_document(document_id, ip_document, filtered_dictionary)
analyze_document.analyze(doc_location)
def load_opil_xml_file(file_path):
opil_doc = opil.Document()
try:
opil_doc.read(file_path, sbol3.RDF_XML)
except ValueError:
raise IntentParserException('Unable to load sbol file.')
return opil_doc
def measurement_type_to_opil_measurement_type(self):
measurement_type = opil.MeasurementType()
measurement_type.required = True
if self._measurement_type == ip_constants.MEASUREMENT_TYPE_FLOW:
measurement_type.type = ip_constants.NCIT_FLOW_URI
elif self._measurement_type == ip_constants.MEASUREMENT_TYPE_RNA_SEQ:
measurement_type.type = ip_constants.NCIT_RNA_SEQ_URI
elif self._measurement_type == ip_constants.MEASUREMENT_TYPE_DNA_SEQ:
measurement_type.type = ip_constants.NCIT_DNA_SEQ_URI
elif self._measurement_type == ip_constants.MEASUREMENT_TYPE_PROTEOMICS:
measurement_type.type = ip_constants.NCIT_PROTEOMICS_URI
elif self._measurement_type == ip_constants.MEASUREMENT_TYPE_SEQUENCING_CHROMATOGRAM:
measurement_type.type = ip_constants.NCIT_SEQUENCING_CHROMATOGRAM_URI
elif self._measurement_type == ip_constants.MEASUREMENT_TYPE_AUTOMATED_TEST:
measurement_type.type = ip_constants.SD2_AUTOMATED_TEST_URI
elif self._measurement_type == ip_constants.MEASUREMENT_TYPE_CFU:
measurement_type.type = ip_constants.NCIT_CFU_URI
elif self._measurement_type == ip_constants.MEASUREMENT_TYPE_PLATE_READER:
measurement_type.type = ip_constants.NCIT_PLATE_READER_URI
elif self._measurement_type == ip_constants.MEASUREMENT_TYPE_CONDITION_SPACE:
measurement_type.type = ip_constants.SD2_CONDITION_SPACE_URI
elif self._measurement_type == ip_constants.MEASUREMENT_TYPE_EXPERIMENTAL_DESIGN:
measurement_type.type = ip_constants.SD2_EXPERIMENTAL_DESIGN_URI
else:
raise IntentParserException(
'Unable to create an opil measurement-type: %s not supported' %
self._measurement_type)
return measurement_type
def _get_or_create_display_id(self, item_name, item_display_id):
if len(item_display_id) == 0:
return self.generate_display_id(item_name)
display_id = self.generate_display_id(item_display_id)
if display_id != item_display_id:
raise IntentParserException('Illegal display_id')
return display_id
def _process_sampleset_templates(self, samplesets, uris_to_components):
uris_to_template = {}
for sample in samplesets:
str_template = str(sample.template)
if not sample.template:
raise IntentParserException('A SampleSet must have a template but none was set: %s' % sample.identity)
if str_template not in uris_to_components:
raise IntentParserException('No Component found for SampleSet.template: %s' % str_template)
uris_to_template[str_template] = uris_to_components[str_template]
if len(uris_to_template) != 1:
raise IntentParserException('Expecting one unique SampleSet.template but found %d.' % len(uris_to_template))
uris_to_local_and_subcomponents = {}
for template in uris_to_template.values():
for feature in template.features:
uris_to_local_and_subcomponents[feature.identity] = feature
return uris_to_local_and_subcomponents
def map_name_to_parameters(self, protocol_name, lab_name):
"""
Get parameters from a lab protocol.
Args:
protocol_name: name of protocol
lab_name: name of lab
Returns:
a dictionary mapping name to its parameter
"""
lab_accessor = self._get_lab_accessor(lab_name)
opil_document_template = lab_accessor.get_experimental_protocol(protocol_name)
protocol_interfaces = opil_document_template.get_protocol_interfaces()
if not protocol_interfaces:
raise IntentParserException('No lab ProtocolInterface found with protocol name: %s' % protocol_name)
if len(protocol_interfaces) > 1:
raise IntentParserException('Expecting 1 ProtocolInterface but %d were found' % len(protocol_interfaces))
parameters = {}
protocol_interface = protocol_interfaces[0]
for opil_parameter in protocol_interface.has_parameter:
parameter_name = opil_parameter.name
possible_values = []
if opil_parameter.default_value:
possible_values.append(opil_parameter.default_value)
if type(opil_parameter) is opil.EnumeratedParameter and opil_parameter.allowed_value:
possible_values.extend(opil_parameter.allowed_value)
if not opil_parameter.required:
ip_parameter_field = ParameterField(parameter_name,
opil_parameter,
valid_values=possible_values)
parameters[parameter_name] = ip_parameter_field
if opil_parameter.description:
ip_parameter_field.set_description(opil_parameter.description)
else:
ip_parameter_field = ParameterField(parameter_name,
opil_parameter,
required=True,
valid_values=possible_values)
parameters[parameter_name] = ip_parameter_field
if opil_parameter.description:
ip_parameter_field.set_description(opil_parameter.description)
return parameters
def set_timepoint(self, timepoint: TimepointIntent):
if self._timepoint is not None:
new_value = '%d %s' % (timepoint.get_value(), timepoint.get_unit())
curr_value = '%d %s' % (self._timepoint.get_value(),
self._timepoint.get_unit())
raise IntentParserException(
'Unable to assign reagent timepoint value %s when it currently has %s assigned.'
% (new_value, curr_value))
self._timepoint = timepoint
def to_structured_request(self):
if self._measurement_type is None:
raise IntentParserException(
"A structured request must have a measurement-type but none is set."
)
if len(self._file_types) == 0:
raise IntentParserException(
"A structured request must have a file-type but file-type is empty."
)
structure_request = {
dc_constants.MEASUREMENT_TYPE: self._measurement_type,
dc_constants.FILE_TYPE: self._file_types
}
if len(self._replicates) > 0:
structure_request[dc_constants.REPLICATES] = self._replicates
if self._strains:
structure_request[dc_constants.STRAINS] = [
strain.to_structured_request() for strain in self._strains
]
if len(self._optical_densities) > 0:
structure_request[dc_constants.ODS] = self._optical_densities
if len(self._temperatures) > 0:
structure_request[dc_constants.TEMPERATURES] = [
temperature.to_structured_request()
for temperature in self._temperatures
]
if len(self._timepoints) > 0:
structure_request[dc_constants.TIMEPOINTS] = [
timepoint.to_structured_request()
for timepoint in self._timepoints
]
if len(self._batches) > 0:
structure_request[dc_constants.BATCH] = self._batches
if len(self._controls) > 0:
structure_request[dc_constants.CONTROLS] = [
control.to_structured_request() for control in self._controls
]
if not self._contents.is_empty():
structure_request.update(self._contents.to_structured_request())
return structure_request
def get_protocol_id(self, protocol_name, lab_name):
"""
Get id for a lab protocol.
Args:
protocol_name: name of protocol
lab_name: name of lab
Returns:
A string representing a protocol ID. An empty string is returned if no protocol ID is assigned.
"""
lab_accessor = self._get_lab_accessor(lab_name)
opil_document_template = lab_accessor.get_experimental_protocol(protocol_name)
protocol_interfaces = opil_document_template.get_protocol_interfaces()
if not protocol_interfaces:
raise IntentParserException('No lab ProtocolInterface found with protocol name: %s' % protocol_name)
if len(protocol_interfaces) > 1:
raise IntentParserException('Expecting 1 ProtocolInterface but %d were found' % len(protocol_interfaces))
protocol_interface = protocol_interfaces[0]
if lab_name == ip_constants.LAB_TRANSCRIPTIC:
return protocol_interface.strateos_id
return ''
def create_synbiohub_entry(self, sbol_type, sbol_type_map, display_id,
item_type, item_name, item_definition_uri,
item_lab_ids, item_lab_id_tag):
document = sbol.Document()
document.addNamespace('http://sd2e.org#', 'sd2')
document.addNamespace('http://purl.org/dc/terms/', 'dcterms')
document.addNamespace('http://www.w3.org/ns/prov#', 'prov')
document.displayId = 'foo'
document.version = '1'
if sbol_type == 'component':
if item_type == 'CHEBI':
item_sbol_type = item_definition_uri
else:
item_sbol_type = sbol_type_map[item_type]
component = sbol.ComponentDefinition(display_id, item_sbol_type)
sbol.TextProperty(component, 'http://sd2e.org#stub_object', '0',
'1', 'true')
self.set_item_properties(component, item_type, item_name,
item_definition_uri, item_lab_ids,
item_lab_id_tag)
document.addComponentDefinition(component)
elif sbol_type == 'module':
module = sbol.ModuleDefinition(display_id)
sbol.TextProperty(module, 'http://sd2e.org#stub_object', '0', '1',
'true')
module.roles = sbol_type_map[item_type]
self.set_item_properties(module, item_type, item_name,
item_definition_uri, item_lab_ids,
item_lab_id_tag)
document.addModuleDefinition(module)
elif sbol_type == 'external':
top_level = sbol.TopLevel('http://sd2e.org/types/#attribute',
display_id)
self.set_item_properties(top_level, item_type, item_name,
item_definition_uri, item_lab_ids,
item_lab_id_tag)
document.add(top_level)
elif sbol_type == 'collection':
collection = sbol.Collection(display_id)
self.set_item_properties(collection, item_type, item_name,
item_definition_uri, item_lab_ids,
item_lab_id_tag)
document.addCollection(collection)
else:
raise IntentParserException(
'Failed to create a SynBioHub entry: %s as a supported sbol type in Intent Parser'
% sbol_type)
return document
def _get_sbol_type_from_item_type(self, item_type):
sbol_type = None
for key, value_dict in intent_parser_constants.ITEM_TYPES.items():
for value_type, value_uri in value_dict.items():
if item_type == value_type:
sbol_type = key
if sbol_type is None:
err = '%s does not match one of the following sbol types: \n %s' % (
item_type, ' ,'.join(
(map(str, intent_parser_constants.ITEM_TYPES.keys()))))
raise IntentParserException(err)
return sbol_type
def get_experimental_protocol(self, experimental_request_name):
if experimental_request_name in self._SUPPORTED_PROTOCOLS:
if experimental_request_name not in self.cached_protocols:
file_name = self._SUPPORTED_PROTOCOLS[
experimental_request_name]
curr_path = os.path.dirname(os.path.abspath(__file__))
file_path = os.path.join(curr_path, file_name)
opil_doc = ip_utils.load_opil_xml_file(file_path)
template = OpilDocumentTemplate()
template.load_from_template(opil_doc)
self.cached_protocols[experimental_request_name] = template
return self.cached_protocols[experimental_request_name]
raise IntentParserException(
'Aquarium does not support %s as an experimental request' %
experimental_request_name)
def _process_opil(self):
if not self.processed_protocol_name:
raise IntentParserException(
'Name of lab must be provided for describing an experimental request but'
'none was given.')
opil_lab_template = self._lab_protocol_accessor.load_protocol_interface_from_lab(
self.processed_protocol_name, self.processed_lab_name)
experiment_id = self.processed_lab.to_structured_request()[
dc_constants.EXPERIMENT_ID]
experimental_request = ExperimentalRequest(
self._get_namespace_from_lab(), opil_lab_template, experiment_id,
self._experiment_ref, self._experiment_ref_url)
experimental_request.load_experimental_request()
# add control table info
if self.processed_controls:
for control_table in self.processed_controls.values():
experimental_request.load_from_control_table(control_table)
# add measurement table info
if self.measurement_table:
experimental_request.load_from_measurement_table(
self.measurement_table)
experimental_request.load_sample_template_from_protocol_interface()
experimental_request.create_subcomponents_from_template()
experimental_request.load_sample_set(
len(self.measurement_table.get_intents()))
experimental_request.add_variable_features_from_measurement_intents(
self.measurement_table.get_intents())
experimental_request.load_and_update_measurement(
self.measurement_table.get_intents())
# add parameter table info
if self.processed_parameter:
experimental_request.load_lab_parameters()
experimental_request.update_parameter_values(
self.processed_parameter.get_default_parameters())
experimental_request.add_run_parameters(self.processed_parameter)
experimental_request.connect_properties()
self.opil_document = experimental_request.to_opil()
def to_structured_request(self):
if self._control_type is None:
raise IntentParserException('control-type is not set.')
structure_request = {dc_constants.TYPE: self._control_type}
if len(self._strains) > 0:
structure_request[dc_constants.STRAINS] = [
strain.to_structured_request() for strain in self._strains
]
if self._channel:
structure_request[dc_constants.CHANNEL] = self._channel
if len(self._contents) > 0:
structure_request[dc_constants.CONTENTS] = [
content.to_structured_request() for content in self._contents
]
if len(self._timepoints) > 0:
structure_request[dc_constants.TIMEPOINTS] = [
timepoint.to_structured_request()
for timepoint in self._timepoints
]
return structure_request
def create_sbh_stub(self, item_type, item_name, item_definition_uri,
item_display_id, item_lab_ids, item_lab_id_tag):
sbol_type_map = self.get_item_type_mapping()
sbol_type = self._get_sbol_type_from_item_type(item_type)
new_item_definition_uri = self.get_or_create_new_item_definition_uri(
item_type, item_definition_uri, sbol_type_map)
display_id = self._get_or_create_display_id(item_name, item_display_id)
sbh_document = self.create_synbiohub_entry(
sbol_type, sbol_type_map, display_id, item_type, item_name,
new_item_definition_uri, item_lab_ids, item_lab_id_tag)
# Derive document URL
document_url = self.sbh_uri_prefix + display_id + '/1'
if self.sbh.exists(sbh_document, document_url):
message = '%s already exists in SynBioHub' % document_url
raise IntentParserException(message)
sbh_merge_collection_flag = 2
self.sbh.submit(sbh_document, self.sbh_collection_uri,
sbh_merge_collection_flag)
self.create_dictionary_entry(item_type, item_name, item_lab_ids,
item_lab_id_tag, document_url,
new_item_definition_uri)
return document_url
def set_control_type(self, value: str):
if self._control_type:
raise IntentParserException('Conflict setting control type %s. '
'Current set value %s' %
(value, self._control_type))
self._control_type = value
def _get_lab_accessor(self, lab_name):
if lab_name not in self._lab_accessors:
raise IntentParserException(
'Lab not supported: %s' % lab_name)
lab_accessor = self._lab_accessors[lab_name]
return lab_accessor
def query(self, query):
response = self.sbh.sparqlQuery(query)
if response.status_code != HTTPStatus.OK:
raise IntentParserException('SBH response failed: %s' %
str(response.status_code))
return response.json()
def set_strain_common_name(self, common_name):
if self._strain_commmon_name:
raise IntentParserException('conflict setting strain common name: '
'Current common name set to %s' % self._strain_commmon_name)
self._strain_commmon_name = common_name
def set_strain_lab_name(self, lab_name):
if self._lab_name:
raise IntentParserException('conflict setting stran lab name: Current lab set to %s' % self._lab_name)
self._lab_name = lab_name
def get_experiment_id_from_protocol(self, protocol_name):
if protocol_name not in self._SUPPORTED_PROTOCOLS:
raise IntentParserException(
'Protocol not supported by Aquarium: %s' % protocol_name)
return 'TBA'
def get_experiment_id_from_protocol(self, protocol_name):
if protocol_name not in self._name_to_json:
raise IntentParserException(
'Protocol not supported by Strateos: %s' % protocol_name)
protocol = self._name_to_json[protocol_name]
return protocol['id']
