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']