def _add_assertion_provenance(
self,
assoc_id,
evidence_line_bnode
):
"""
Add assertion level provenance, currently always IMPC
:param assoc_id:
:param evidence_line_bnode:
:return:
"""
provenance_model = Provenance(self.graph)
model = Model(self.graph)
assertion_bnode = self.make_id(
"assertion{0}{1}".format(assoc_id, self.localtt['IMPC']), '_')
model.addIndividualToGraph(assertion_bnode, None, self.globaltt['assertion'])
provenance_model.add_assertion(
assertion_bnode, self.localtt['IMPC'],
'International Mouse Phenotyping Consortium')
self.graph.addTriple(
assoc_id, self.globaltt['is_asserted_in'], assertion_bnode)
self.graph.addTriple(
assertion_bnode,
self.globaltt['is_assertion_supported_by_evidence'], # "SEPIO:0000111"
evidence_line_bnode)
def _add_assertion_provenance(self, assoc_id, evidence_line_bnode,
impc_map):
"""
Add assertion level provenance, currently always IMPC
:param assoc_id:
:param evidence_line_bnode:
:return:
"""
provenance_model = Provenance(self.graph)
model = Model(self.graph)
assertion_bnode = self.make_id(
"assertion{0}{1}".format(assoc_id,
impc_map['asserted_by']['IMPC']), '_')
model.addIndividualToGraph(
assertion_bnode, None,
provenance_model.provenance_types['assertion'])
provenance_model.add_assertion(
assertion_bnode, impc_map['asserted_by']['IMPC'],
'International Mouse Phenotyping Consortium')
self.graph.addTriple(
assoc_id, provenance_model.object_properties['is_asserted_in'],
assertion_bnode)
self.graph.addTriple(
assertion_bnode,
provenance_model.object_properties['is_assertion_supported_by'],
evidence_line_bnode)
return
def _add_assertion_provenance(
self,
assoc_id,
evidence_line_bnode
):
"""
Add assertion level provenance, currently always IMPC
:param assoc_id:
:param evidence_line_bnode:
:return:
"""
provenance_model = Provenance(self.graph)
model = Model(self.graph)
assertion_bnode = self.make_id(
"assertion{0}{1}".format(assoc_id, self.localtt['IMPC']), '_')
model.addIndividualToGraph(assertion_bnode, None, self.globaltt['assertion'])
provenance_model.add_assertion(
assertion_bnode, self.localtt['IMPC'],
'International Mouse Phenotyping Consortium')
self.graph.addTriple(
assoc_id, self.globaltt['proposition_asserted_in'], assertion_bnode)
self.graph.addTriple(
assertion_bnode,
self.resolve('is_assertion_supported_by_evidence'), # "SEPIO:0000111"
evidence_line_bnode)
return
def _add_assertion_provenance(
self, assoc_id, evidence_line_bnode, impc_map):
"""
Add assertion level provenance, currently always IMPC
:param assoc_id:
:param evidence_line_bnode:
:return:
"""
provenance_model = Provenance(self.graph)
model = Model(self.graph)
assertion_bnode = self.make_id("assertion{0}{1}".format(
assoc_id, impc_map['asserted_by']['IMPC']), '_')
model.addIndividualToGraph(
assertion_bnode, None,
provenance_model.provenance_types['assertion'])
provenance_model.add_assertion(
assertion_bnode, impc_map['asserted_by']['IMPC'],
'International Mouse Phenotyping Consortium')
self.graph.addTriple(
assoc_id, provenance_model.object_properties['is_asserted_in'],
assertion_bnode)
self.graph.addTriple(
assertion_bnode,
provenance_model.object_properties['is_assertion_supported_by'],
evidence_line_bnode)
return
def _add_outcome_provenance(self, association, outcome):
"""
:param association: str association curie
:param outcome: dict (json)
:return: None
"""
provenance = Provenance(self.graph)
base = self.curie_map.get_base()
provenance.add_agent_to_graph(base, 'Monarch Initiative')
self.graph.addTriple(association, self.globaltt['asserted_by'], base)
def _add_outcome_provenance(self, association, outcome):
"""
:param association: str association curie
:param outcome: dict (json)
:return: None
"""
provenance = Provenance(self.graph)
base = self.curie_map.get_base()
provenance.add_agent_to_graph(base, 'Monarch Initiative')
self.graph.addTriple(association, self.globaltt['asserted_by'], base)
def _fill_provenance_graph(self, limit):
logger.info("Building graph ...")
if self.testMode:
graph = self.testgraph
else:
graph = self.graph
model = Model(graph)
taxon_id = self.globaltt['Mus musculus']
model.addClassToGraph(taxon_id, None)
scores_passing_threshold_count = 0
scores_passing_threshold_with_ontologies_count = 0
scores_not_passing_threshold_count = 0
# loop through all the strains,
# and make G2P assoc for those with scores beyond threshold
for strain_num in self.strain_scores_by_measure:
if self.testMode and 'MPD:' + str(strain_num) not in self.test_ids:
continue
strain_id = 'MPD-strain:' + str(strain_num)
for sex in self.strain_scores_by_measure[strain_num]:
measures = self.strain_scores_by_measure[strain_num][sex]
for m in measures:
assay_id = 'MPD-assay:' + str(m)
# TODO consider using the means
# instead of precomputed zscores
if 'zscore' in measures[m]:
zscore = measures[m]['zscore']
if abs(zscore) >= self.stdevthreshold:
scores_passing_threshold_count += 1
# logger.info(
# "Score passing threshold: %s | %s | %s",
# strain_id, assay_id, zscore)
# add the G2P assoc
prov = Provenance(self.graph)
try:
assay_label = self.assayhash[m]['assay_label']
assay_description = self.assayhash[m][
'description']
ont_term_ids = self.assayhash[m].get(
'ont_terms')
comment = ' '.join(
(assay_label,
'(zscore=' + str(zscore) + ')'))
except KeyError:
assay_label = None
assay_description = None
ont_term_ids = None
if assay_label is not None:
assay_label += ' (' + str(m) + ')'
assay_type_id = self.globaltt['assay']
if ont_term_ids is not None:
scores_passing_threshold_with_ontologies_count += 1
prov.add_assay_to_graph(
assay_id, assay_label, assay_type_id,
assay_description)
self._add_g2p_assoc(graph, strain_id, sex,
assay_id, ont_term_ids,
comment)
else:
scores_not_passing_threshold_count += 1
logger.info("Scores passing threshold: %d",
scores_passing_threshold_count)
logger.info("Scores passing threshold with ontologies: %d",
scores_passing_threshold_with_ontologies_count)
logger.info("Scores not passing threshold: %d",
scores_not_passing_threshold_count)
return
def _add_evidence(
self,
assoc_id,
eco_id,
p_value,
percentage_change,
effect_size,
study_bnode
):
"""
:param assoc_id: assoc curie used to reify a
genotype to phenotype association, generated in _process_data()
:param eco_id: eco_id as curie, hardcoded in _process_data()
:param p_value: str, from self.files['all']
:param percentage_change: str, from self.files['all']
:param effect_size: str, from self.files['all']
:param study_bnode: str, from self.files['all']
:param phenotyping_center: str, from self.files['all']
:return: str, evidence_line_bnode as curie
"""
evidence_model = Evidence(self.graph, assoc_id)
provenance_model = Provenance(self.graph)
model = Model(self.graph)
# Add line of evidence
evidence_line_bnode = self.make_id(
"{0}{1}".format(assoc_id, study_bnode), '_')
evidence_model.add_supporting_evidence(evidence_line_bnode)
model.addIndividualToGraph(evidence_line_bnode, None, eco_id)
# Add supporting measurements to line of evidence
measurements = {}
if p_value is not None or p_value != "":
p_value_bnode = self.make_id(
"{0}{1}{2}".format(evidence_line_bnode, 'p_value', p_value), '_')
model.addIndividualToGraph(p_value_bnode, None, self.globaltt['p-value'])
try:
measurements[p_value_bnode] = float(p_value)
except ValueError:
measurements[p_value_bnode] = p_value
if percentage_change is not None and percentage_change != '':
fold_change_bnode = self.make_id(
"{0}{1}{2}".format(
evidence_line_bnode, 'percentage_change', percentage_change), '_')
model.addIndividualToGraph(
fold_change_bnode, None, self.resolve('percentage_change'))
measurements[fold_change_bnode] = percentage_change
if effect_size is not None or effect_size != "":
fold_change_bnode = self.make_id(
"{0}{1}{2}".format(
evidence_line_bnode, 'effect_size', effect_size), '_')
model.addIndividualToGraph(
fold_change_bnode, None, self.globaltt['effect size estimate'])
measurements[fold_change_bnode] = effect_size
evidence_model.add_supporting_data(evidence_line_bnode, measurements)
# Link evidence to provenance by connecting to study node
provenance_model.add_study_to_measurements(study_bnode, measurements.keys())
self.graph.addTriple(
evidence_line_bnode, self.globaltt['has_supporting_activity'],
study_bnode)
return evidence_line_bnode
def _add_study_provenance(
self,
phenotyping_center,
colony,
project_fullname,
pipeline_name,
pipeline_stable_id,
procedure_stable_id,
procedure_name,
parameter_stable_id,
parameter_name,
statistical_method,
resource_name
):
"""
:param phenotyping_center: str, from self.files['all']
:param colony: str, from self.files['all']
:param project_fullname: str, from self.files['all']
:param pipeline_name: str, from self.files['all']
:param pipeline_stable_id: str, from self.files['all']
:param procedure_stable_id: str, from self.files['all']
:param procedure_name: str, from self.files['all']
:param parameter_stable_id: str, from self.files['all']
:param parameter_name: str, from self.files['all']
:param statistical_method: str, from self.files['all']
:param resource_name: str, from self.files['all']
:return: study bnode
"""
provenance_model = Provenance(self.graph)
model = Model(self.graph)
# Add provenance
# A study is a blank node equal to its parts
study_bnode = self.make_id("{0}{1}{2}{3}{4}{5}{6}{7}".format(
phenotyping_center, colony, project_fullname, pipeline_stable_id,
procedure_stable_id, parameter_stable_id, statistical_method,
resource_name), '_')
model.addIndividualToGraph(
study_bnode, None, self.globaltt['study'])
# List of nodes linked to study with has_part property
study_parts = []
# Add study parts
if procedure_stable_id in self.localtt:
procedure_stable_id2 = self.localtt[procedure_stable_id]
else:
procedure_stable_id2 = self.resolve(procedure_stable_id)
model.addIndividualToGraph(procedure_stable_id2, procedure_name)
study_parts.append(procedure_stable_id2)
study_parts.append(self.resolve(statistical_method))
provenance_model.add_study_parts(study_bnode, study_parts)
# Add parameter/measure statement: study measures parameter
parameter_label = "{0} ({1})".format(parameter_name, procedure_name)
logging.info("Adding Provenance for %s", project_fullname)
pram_id = self.resolve(parameter_stable_id)
model.addIndividualToGraph(pram_id, parameter_label)
provenance_model.add_study_measure(study_bnode, pram_id)
# Add Colony
colony_bnode = self.make_id("{0}".format(colony), '_')
model.addIndividualToGraph(colony_bnode, colony)
# Add study agent
phenotyping_center_id = self.localtt[phenotyping_center]
model.addIndividualToGraph(
phenotyping_center_id,
phenotyping_center,
self.globaltt['organization'])
# self.graph
model.addTriple(
study_bnode, self.globaltt['has_agent'], phenotyping_center_id)
if pipeline_stable_id in self.localtt:
pipeline_stable_id2 = self.localtt[pipeline_stable_id]
else:
pipeline_stable_id2 = self.resolve(pipeline_stable_id)
# add pipeline and project
model.addIndividualToGraph(pipeline_stable_id2, pipeline_name)
# self.graph
model.addTriple(study_bnode, self.globaltt['part_of'], pipeline_stable_id2)
if project_fullname in self.localtt:
project_fullname_id = self.localtt[project_fullname]
else:
project_fullname_id = self.resolve(project_fullname)
model.addIndividualToGraph(
project_fullname_id, project_fullname, self.globaltt['project'])
# self.graph
model.addTriple(study_bnode, self.globaltt['part_of'], project_fullname_id)
return study_bnode
def _fill_provenance_graph(self, limit):
logger.info("Building graph ...")
if self.testMode:
g = self.testgraph
else:
g = self.graph
model = Model(g)
taxon_id = 'NCBITaxon:10090' # hardcode to Mus musculus
model.addClassToGraph(taxon_id, None)
scores_passing_threshold_count = 0
scores_passing_threshold_with_ontologies_count = 0
scores_not_passing_threshold_count = 0
# loop through all the strains,
# and make G2P assoc for those with scores beyond threshold
for strain_num in self.strain_scores_by_measure:
if self.testMode and 'MPD:'+str(strain_num) not in self.test_ids:
continue
strain_id = 'MPD-strain:'+str(strain_num)
for sex in self.strain_scores_by_measure[strain_num]:
measures = self.strain_scores_by_measure[strain_num][sex]
for m in measures:
assay_id = 'MPD-assay:'+str(m)
# TODO consider using the means
# instead of precomputed zscores
if 'zscore' in measures[m]:
zscore = measures[m]['zscore']
if abs(zscore) >= self.stdevthreshold:
scores_passing_threshold_count += 1
# logger.info(
# "Score passing threshold: %s | %s | %s",
# strain_id, assay_id, zscore)
# add the G2P assoc
prov = Provenance(self.graph)
try:
assay_label = self.assayhash[m]['assay_label']
assay_description = \
self.assayhash[m]['description']
ont_term_ids = self.assayhash[m].get('ont_terms')
comment = ' '.join((assay_label,
'(zscore='+str(zscore)+')'))
except KeyError:
assay_label = None
assay_description = None
ont_term_ids = None
if assay_label is not None:
assay_label += ' ('+str(m)+')'
# TODO unused
# assay_type = self.assayhash[m]['assay_type']
assay_type_id = Provenance.provenance_types['assay']
if ont_term_ids is not None:
scores_passing_threshold_with_ontologies_count += 1
prov.add_assay_to_graph(
assay_id, assay_label, assay_type_id,
assay_description)
self._add_g2p_assoc(
g, strain_id, sex, assay_id, ont_term_ids,
comment)
else:
scores_not_passing_threshold_count += 1
logger.info("Scores passing threshold: %d",
scores_passing_threshold_count)
logger.info("Scores passing threshold with ontologies: %d",
scores_passing_threshold_with_ontologies_count)
logger.info("Scores not passing threshold: %d",
scores_not_passing_threshold_count)
return
def _add_study_provenance(self, impc_map, impress_map, phenotyping_center,
colony, project_fullname, pipeline_name,
pipeline_stable_id, procedure_stable_id,
procedure_name, parameter_stable_id,
parameter_name, statistical_method,
resource_name):
"""
:param impc_map: dict, generated from map file
see self._get_impc_mappings() docstring
:param impress_map: dict, generated from map file
see _get_impress_mappings() docstring
:param phenotyping_center: str, from self.files['all']
:param colony: str, from self.files['all']
:param project_fullname: str, from self.files['all']
:param pipeline_name: str, from self.files['all']
:param pipeline_stable_id: str, from self.files['all']
:param procedure_stable_id: str, from self.files['all']
:param procedure_name: str, from self.files['all']
:param parameter_stable_id: str, from self.files['all']
:param parameter_name: str, from self.files['all']
:param statistical_method: str, from self.files['all']
:param resource_name: str, from self.files['all']
:return: study bnode
"""
provenance_model = Provenance(self.graph)
model = Model(self.graph)
# Add provenance
# A study is a blank node equal to its parts
study_bnode = self.make_id(
"{0}{1}{2}{3}{4}{5}{6}{7}".format(
phenotyping_center, colony, project_fullname,
pipeline_stable_id, procedure_stable_id, parameter_stable_id,
statistical_method, resource_name), '_')
model.addIndividualToGraph(study_bnode, None,
provenance_model.provenance_types['study'])
# List of nodes linked to study with has_part property
study_parts = []
# Add study parts
model.addIndividualToGraph(impress_map[procedure_stable_id],
procedure_name)
study_parts.append(impress_map[procedure_stable_id])
study_parts.append(impc_map['statistical_method'][statistical_method])
provenance_model.add_study_parts(study_bnode, study_parts)
# Add parameter/measure statement: study measures parameter
parameter_label = "{0} ({1})".format(parameter_name, procedure_name)
model.addIndividualToGraph(impress_map[parameter_stable_id],
parameter_label)
provenance_model.add_study_measure(study_bnode,
impress_map[parameter_stable_id])
# Add Colony
colony_bnode = self.make_id("{0}".format(colony), '_')
model.addIndividualToGraph(colony_bnode, colony)
# Add study agent
model.addIndividualToGraph(
impc_map['phenotyping_center'][phenotyping_center],
phenotyping_center,
provenance_model.provenance_types['organization'])
self.graph.addTriple(
study_bnode, provenance_model.object_properties['has_agent'],
impc_map['phenotyping_center'][phenotyping_center])
# add pipeline and project
model.addIndividualToGraph(impress_map[pipeline_stable_id],
pipeline_name)
self.graph.addTriple(study_bnode, model.object_properties['part_of'],
impress_map[pipeline_stable_id])
model.addIndividualToGraph(
impc_map['project'][project_fullname], project_fullname,
provenance_model.provenance_types['project'])
self.graph.addTriple(study_bnode, model.object_properties['part_of'],
impc_map['project'][project_fullname])
return study_bnode
def _add_study_provenance(
self,
phenotyping_center,
colony,
project_name,
pipeline_name,
pipeline_stable_id,
procedure_stable_id,
procedure_name,
parameter_stable_id,
parameter_name,
statistical_method,
resource_name
):
"""
:param phenotyping_center: str, from self.files['g2p_assertions']['columns']
:param colony: str, from self.files['g2p_assertions']
:param project_name: str, from self.files['g2p_assertions']
:param pipeline_name: str, from self.files['g2p_assertions']
:param pipeline_stable_id: str, from self.files['g2p_assertions']
:param procedure_stable_id: str, from self.files['g2p_assertions']
:param procedure_name: str, from self.files['g2p_assertions']
:param parameter_stable_id: str, from self.files['g2p_assertions']
:param parameter_name: str, from self.files['g2p_assertions']
:param statistical_method: str, from self.files['g2p_assertions']
:param resource_name: str, from self.files['g2p_assertions']
:return: study bnode
"""
provenance_model = Provenance(self.graph)
model = Model(self.graph)
# Add provenance
# A study is a blank node equal to its parts
study_bnode = self.make_id("{0}{1}{2}{3}{4}{5}{6}{7}".format(
phenotyping_center,
colony,
project_name, # switched to from 'project_fullname' 2020 V12
pipeline_stable_id,
procedure_stable_id,
parameter_stable_id,
statistical_method,
resource_name), '_')
model.addIndividualToGraph(study_bnode, None, self.globaltt['study'])
# List of nodes linked to study with has_part property
study_parts = []
pipeline_curie = 'IMPC-pipe:' + pipeline_stable_id
procedure_curie = 'IMPC-proc:' + procedure_stable_id
parameter_curie = 'IMPC-param:' + procedure_stable_id
parameter_curie += '#' + parameter_stable_id
# Add study parts
model.addIndividualToGraph(procedure_curie, procedure_name)
study_parts.append(procedure_curie) # ? stable or curie
study_parts.append(self.resolve(statistical_method))
provenance_model.add_study_parts(study_bnode, study_parts)
# Add parameter/measure statement: study measures parameter
parameter_label = "{0} ({1})".format(parameter_name, procedure_name)
# logging.info("Adding Provenance for %s", project_name)
model.addIndividualToGraph(parameter_curie, parameter_label)
provenance_model.add_study_measure(
study_bnode, parameter_curie, object_is_literal=False
)
# Add Colony
colony_bnode = self.make_id("{0}".format(colony), '_')
model.addIndividualToGraph(colony_bnode, colony)
# Add study agent
phenotyping_center_id = self.localtt[phenotyping_center]
model.addIndividualToGraph(
phenotyping_center_id,
phenotyping_center,
self.globaltt['organization']
)
# self.graph
model.addTriple(
study_bnode, self.globaltt['has_agent'], phenotyping_center_id
)
# add pipeline and project
model.addIndividualToGraph(pipeline_curie, pipeline_name)
# self.graph
model.addTriple(study_bnode, self.globaltt['part_of'], pipeline_curie)
# as of V12 col 'project_fullname' became empty switched to 'project_name'
if project_name is not None and project_name != '':
for prj_nm in project_name.split(','):
project_name_id = self.localtt[prj_nm]
model.addIndividualToGraph(
project_name_id, project_name, self.globaltt['project'])
model.addTriple(study_bnode, self.globaltt['part_of'], project_name_id)
return study_bnode
def _add_evidence(
self,
assoc_id,
eco_id,
p_value,
percentage_change,
effect_size,
study_bnode
):
"""
:param assoc_id: assoc curie used to reify a
genotype to phenotype association, generated in _process_data()
:param eco_id: eco_id as curie, hardcoded in _process_data()
:param p_value: str, from self.files['all']
:param percentage_change: str, from self.files['all']
:param effect_size: str, from self.files['all']
:param study_bnode: str, from self.files['all']
:param phenotyping_center: str, from self.files['all']
:return: str, evidence_line_bnode as curie
"""
evidence_model = Evidence(self.graph, assoc_id)
provenance_model = Provenance(self.graph)
model = Model(self.graph)
# Add line of evidence
evidence_line_bnode = self.make_id(
"{0}{1}".format(assoc_id, study_bnode), '_')
evidence_model.add_supporting_evidence(evidence_line_bnode)
model.addIndividualToGraph(evidence_line_bnode, None, eco_id)
# Add supporting measurements to line of evidence
measurements = {}
if p_value is not None or p_value != "":
p_value_bnode = self.make_id(
"{0}{1}{2}".format(evidence_line_bnode, 'p_value', p_value), '_')
model.addIndividualToGraph(p_value_bnode, None, self.globaltt['p-value'])
try:
measurements[p_value_bnode] = float(p_value)
except ValueError:
measurements[p_value_bnode] = p_value
if percentage_change is not None and percentage_change != '':
fold_change_bnode = self.make_id(
"{0}{1}{2}".format(
evidence_line_bnode, 'percentage_change', percentage_change), '_')
model.addIndividualToGraph(
fold_change_bnode, None, self.resolve('percentage_change'))
measurements[fold_change_bnode] = percentage_change
if effect_size is not None or effect_size != "":
fold_change_bnode = self.make_id(
"{0}{1}{2}".format(
evidence_line_bnode, 'effect_size', effect_size), '_')
model.addIndividualToGraph(
fold_change_bnode, None, self.globaltt['effect size estimate'])
measurements[fold_change_bnode] = effect_size
evidence_model.add_supporting_data(evidence_line_bnode, measurements)
# Link evidence to provenance by connecting to study node
provenance_model.add_study_to_measurements(study_bnode, measurements.keys())
self.graph.addTriple(
evidence_line_bnode, self.globaltt['has_evidence_item_output_from'], study_bnode)
return evidence_line_bnode
def _add_study_provenance(
self,
phenotyping_center,
colony,
project_fullname,
pipeline_name,
pipeline_stable_id,
procedure_stable_id,
procedure_name,
parameter_stable_id,
parameter_name,
statistical_method,
resource_name,
row_num
):
"""
:param phenotyping_center: str, from self.files['all']
:param colony: str, from self.files['all']
:param project_fullname: str, from self.files['all']
:param pipeline_name: str, from self.files['all']
:param pipeline_stable_id: str, from self.files['all']
:param procedure_stable_id: str, from self.files['all']
:param procedure_name: str, from self.files['all']
:param parameter_stable_id: str, from self.files['all']
:param parameter_name: str, from self.files['all']
:param statistical_method: str, from self.files['all']
:param resource_name: str, from self.files['all']
:return: study bnode
"""
provenance_model = Provenance(self.graph)
model = Model(self.graph)
# Add provenance
# A study is a blank node equal to its parts
study_bnode = self.make_id("{0}{1}{2}{3}{4}{5}{6}{7}".format(
phenotyping_center, colony, project_fullname, pipeline_stable_id,
procedure_stable_id, parameter_stable_id, statistical_method,
resource_name), '_')
model.addIndividualToGraph(
study_bnode, None, self.globaltt['study'])
# List of nodes linked to study with has_part property
study_parts = []
# Add study parts
model.addIndividualToGraph(self.resolve(procedure_stable_id), procedure_name)
study_parts.append(self.resolve(procedure_stable_id))
study_parts.append(self.resolve(statistical_method))
provenance_model.add_study_parts(study_bnode, study_parts)
# Add parameter/measure statement: study measures parameter
parameter_label = "{0} ({1})".format(parameter_name, procedure_name)
logging.info("Adding Provenance")
model.addIndividualToGraph(
self.resolve(parameter_stable_id), parameter_label)
provenance_model.add_study_measure(
study_bnode, self.resolve(parameter_stable_id))
# Add Colony
colony_bnode = self.make_id("{0}".format(colony), '_')
model.addIndividualToGraph(colony_bnode, colony)
# Add study agent
model.addIndividualToGraph(
self.resolve(phenotyping_center), phenotyping_center,
self.globaltt['organization'])
# self.graph
model.addTriple(
study_bnode, self.globaltt['has_agent'], self.resolve(phenotyping_center))
# add pipeline and project
model.addIndividualToGraph(
self.resolve(pipeline_stable_id), pipeline_name)
# self.graph
model.addTriple(
study_bnode, self.globaltt['part_of'], self.resolve(pipeline_stable_id))
model.addIndividualToGraph(
self.resolve(project_fullname), project_fullname, self.globaltt['project'])
# self.graph
model.addTriple(
study_bnode, self.globaltt['part_of'], self.resolve(project_fullname))
return study_bnode
def _add_study_provenance(self, impc_map, impress_map,
phenotyping_center, colony, project_fullname,
pipeline_name, pipeline_stable_id,
procedure_stable_id, procedure_name,
parameter_stable_id, parameter_name,
statistical_method, resource_name):
"""
:param impc_map: dict, generated from map file
see self._get_impc_mappings() docstring
:param impress_map: dict, generated from map file
see _get_impress_mappings() docstring
:param phenotyping_center: str, from self.files['all']
:param colony: str, from self.files['all']
:param project_fullname: str, from self.files['all']
:param pipeline_name: str, from self.files['all']
:param pipeline_stable_id: str, from self.files['all']
:param procedure_stable_id: str, from self.files['all']
:param procedure_name: str, from self.files['all']
:param parameter_stable_id: str, from self.files['all']
:param parameter_name: str, from self.files['all']
:param statistical_method: str, from self.files['all']
:param resource_name: str, from self.files['all']
:return: study bnode
"""
provenance_model = Provenance(self.graph)
model = Model(self.graph)
# Add provenance
# A study is a blank node equal to its parts
study_bnode = self.make_id("{0}{1}{2}{3}{4}{5}{6}{7}".format(
phenotyping_center, colony, project_fullname, pipeline_stable_id,
procedure_stable_id, parameter_stable_id, statistical_method,
resource_name), '_')
model.addIndividualToGraph(
study_bnode, None,
provenance_model.provenance_types['study'])
# List of nodes linked to study with has_part property
study_parts = []
# Add study parts
model.addIndividualToGraph(
impress_map[procedure_stable_id],
procedure_name)
study_parts.append(impress_map[procedure_stable_id])
study_parts.append(
impc_map['statistical_method'][statistical_method])
provenance_model.add_study_parts(study_bnode, study_parts)
# Add parameter/measure statement: study measures parameter
parameter_label = "{0} ({1})".format(parameter_name, procedure_name)
model.addIndividualToGraph(
impress_map[parameter_stable_id], parameter_label)
provenance_model.add_study_measure(
study_bnode, impress_map[parameter_stable_id])
# Add Colony
colony_bnode = self.make_id("{0}".format(colony), '_')
model.addIndividualToGraph(colony_bnode, colony)
# Add study agent
model.addIndividualToGraph(
impc_map['phenotyping_center'][phenotyping_center],
phenotyping_center,
provenance_model.provenance_types['organization'])
self.graph.addTriple(
study_bnode,
provenance_model.object_properties['has_agent'],
impc_map['phenotyping_center'][phenotyping_center])
# add pipeline and project
model.addIndividualToGraph(
impress_map[pipeline_stable_id],
pipeline_name)
self.graph.addTriple(
study_bnode, model.object_properties['part_of'],
impress_map[pipeline_stable_id])
model.addIndividualToGraph(
impc_map['project'][project_fullname],
project_fullname, provenance_model.provenance_types['project'])
self.graph.addTriple(
study_bnode, model.object_properties['part_of'],
impc_map['project'][project_fullname])
return study_bnode
