def get_mr(
exposure_trait: Optional[str] = None,
outcome_trait: Optional[str] = None,
pval_threshold: float = Query(1e-5, ge=0.0, le=1.0),
):
"""
Return information related to Mendelian randomisation
Specify at least one of `exposure_trait` and `outcome_trait`
or both.
"""
log_args(api="/mr", kwargs=locals())
validate_at_least_one_not_none(
dict(exposure_trait=exposure_trait, outcome_trait=outcome_trait))
if exposure_trait is not None and outcome_trait is not None:
query = MRQueries.pair.format(
exposure_trait=exposure_trait,
outcome_trait=outcome_trait,
pval_threshold=pval_threshold,
)
res = epigraphdb.run_query(query)
elif exposure_trait is not None:
query = MRQueries.exp.format(exposure_trait=exposure_trait,
pval_threshold=pval_threshold)
res = epigraphdb.run_query(query)
elif outcome_trait is not None:
query = MRQueries.out.format(outcome_trait=outcome_trait,
pval_threshold=pval_threshold)
res = epigraphdb.run_query(query)
return res
def get_xqtl_list(
meta_node: XqtlListMetaNodeInput,
pval_threshold: float = Query(1e-5, ge=0.0, le=1.0),
qtl_type: QtlTypeInput = QtlTypeInput.eqtl,
):
log_args(api="/xqtl/single-snp-mr/list", kwargs=locals())
if meta_node.value == "GeneGwas":
query = xqtl_queries.XqtlSingleSnpMrList.gene_gwas.format(
qtl_type=qtl_type.value, pval_threshold=pval_threshold
)
elif meta_node.value == "Gwas":
query = xqtl_queries.XqtlSingleSnpMrList.gwas.format(
qtl_type=qtl_type.value, pval_threshold=pval_threshold
)
else:
query = xqtl_queries.XqtlSingleSnpMrList.gene.format(
qtl_type=qtl_type.value, pval_threshold=pval_threshold
)
response = epigraphdb.run_query(query)
res = (
pd.json_normalize(response["results"])
.drop_duplicates()
.to_dict(orient="records")
)
# TODO: formalise this
res = {"metadata": [], "results": res}
return res
def test_meta_node_name():
query = """
MATCH (n) RETURN DISTINCT labels(n)[0] as label
"""
res = set([_["label"] for _ in epigraphdb.run_query(query)["results"]])
expected_res = set([_ for _ in meta_node_schema.keys()])
assert res == expected_res
def test_meta_rel_schema(meta_rel_name):
schema_model = meta_rel_schema[meta_rel_name]
query = """
MATCH p=(n)-[r: {meta_rel_name}]-(m)
WITH n, r, m, rand() AS index
RETURN properties(r) AS r
ORDER BY index
LIMIT 1000
""".format(
meta_rel_name=meta_rel_name
)
res = epigraphdb.run_query(query)["results"]
logger.info(pformat(res)[:1_000])
for item in res:
rel_item = item["r"]
# assert meta props exist and not None
for prop in epigraphdb_rel_meta_props:
assert prop in rel_item.keys()
assert rel_item[prop] is not None
# assert schema conform
prop_items = {
key: value
for key, value in rel_item.items()
if key not in epigraphdb_rel_meta_props
}
rel = schema_model(**prop_items)
assert isinstance(rel, schema_model)
def test_meta_node_schema(meta_node_name):
schema_model = meta_node_schema[meta_node_name]
query = """
MATCH (n: {meta_node_name})
WITH n, rand() AS index
RETURN properties(n) AS n
ORDER BY index
LIMIT 1000
""".format(
meta_node_name=meta_node_name
)
res = epigraphdb.run_query(query)["results"]
logger.info(pformat(res)[:1_000])
for item in res:
# if None => black list
if schema_model is not None:
node_item = item["n"]
# assert meta props exist and not None
for prop in epigraphdb_node_meta_props:
assert prop in node_item.keys()
assert node_item[prop] is not None
# assert schema conform
prop_items = {
key: value
for key, value in node_item.items()
if key not in epigraphdb_node_meta_props
}
node = schema_model(**prop_items)
assert isinstance(node, schema_model)
def test_meta_rel_name():
query = """
MATCH (n)-[r]-(m) RETURN DISTINCT type(r) as label
"""
res = set([_["label"] for _ in epigraphdb.run_query(query)["results"]])
expected_res = set([_ for _ in meta_rel_schema.keys()])
assert res == expected_res
def test_meta_path_schema(meta_rel_name):
meta_path = meta_path_schema[meta_rel_name]
expected_source_node = meta_path[0]
expected_target_node = meta_path[1]
query = """
MATCH p=(source_node)-[r: {meta_rel_name}]->(target_node)
WITH
labels(source_node)[0] AS source_node,
labels(target_node)[0] AS target_node,
rand() AS index
RETURN
source_node, target_node
ORDER BY index
LIMIT 500
""".format(
meta_rel_name=meta_rel_name
)
res = epigraphdb.run_query(query)["results"]
source_nodes = list(set([_["source_node"] for _ in res]))
target_nodes = list(set([_["target_node"] for _ in res]))
logger.info([source_nodes, expected_source_node])
logger.info([target_nodes, expected_target_node])
assert len(source_nodes) == 1
assert len(target_nodes) == 1
assert source_nodes[0] == expected_source_node
assert target_nodes[0] == expected_target_node
def get_ontology_disease_efo(
disease_label: Optional[str] = None,
efo_term: Optional[str] = None,
fuzzy: bool = True,
):
"""
Map Disease label to EFO term, via `MONDO_MAP_EFO`
"""
log_args(api="/ontology/disease-efo", kwargs=locals())
validate_at_least_one_not_none(
dict(disease_label=disease_label, efo_term=efo_term))
validate_char_length(dict(disease_label=disease_label, efo_term=efo_term))
eq_symbol = "="
if fuzzy:
disease_label = cypher_fuzzify(disease_label)
efo_term = cypher_fuzzify(efo_term)
eq_symbol = "=~"
if disease_label is not None and efo_term is not None:
query = queries.DiseaseEfo.disease_efo.format(
disease_label=disease_label,
efo_term=efo_term,
eq_symbol=eq_symbol)
elif disease_label is not None:
query = queries.DiseaseEfo.disease.format(disease_label=disease_label,
eq_symbol=eq_symbol)
elif efo_term is not None:
query = queries.DiseaseEfo.efo.format(efo_term=efo_term,
eq_symbol=eq_symbol)
res = epigraphdb.run_query(query)
return res
def post_xqtl_gene_by_variant(data: GeneByVariantRequest):
"""Get the list of genes associated by an instrument SNP, nested per SNP"""
log_args(api="/xqtl/single-snp-mr/gene-by-variant", kwargs=locals())
query = xqtl_queries.GeneByVariant.query.format(
variant_list=str(data.variant_list), qtl_type=data.qtl_type
)
res = epigraphdb.run_query(query)
return res
def get_gene_drugs(gene_name: str):
"""
Get the aasociated drugs for a gene.
"""
log_args(api="/gene/drugs", kwargs=locals())
query = queries.Drugs.query.format(gene_name=gene_name)
res = epigraphdb.run_query(query)
return res
def get_gene_druggability_ppi(gene_name: str):
"""
For a gene, search for its associated druggable genes
via protein-protein-interaction (INTACT and STRING)
"""
log_args(api="/gene/druggability/ppi", kwargs=locals())
query = queries.Druggability.ppi.format(gene_name=gene_name)
res = epigraphdb.run_query(query)
return res
def get_gene_literature(gene_name: str, object_name: str):
"""
For a gene, search for its literature evidence
related to a SemMedDB term
"""
log_args(api="/gene/literature", kwargs=locals())
query = queries.Literature.query.format(gene_name=gene_name,
object_name=object_name)
res = epigraphdb.run_query(query)
return res
def get_pathway(trait: str,
pval_threshold: float = Query(1e-5, ge=0.0, le=1.0)):
"""
Pathway-based stratification of instruments
"""
log_args(api="/pathway", kwargs=locals())
query = PathwayQueries.pathway.format(trait=trait,
pval_threshold=pval_threshold)
response = epigraphdb.run_query(query)
return response
def get_drugs_risk_factors(trait: str = None,
pval_threshold: float = Query(1e-8, ge=0.0,
le=1.0)):
"""
Drugs for common risk factors of diseases
"""
log_args(api="/drugs/risk-factors", kwargs=locals())
query = DrugsQueries.risk_factors.format(trait=trait,
pval_threshold=pval_threshold)
response = epigraphdb.run_query(query)
return response
def nodes_search_neighbour(
meta_node: str, id: Optional[str], limit: int = Query(50, ge=1, le=200)
):
"""Search the neighbour nodes adjacent to the query node."""
log_args(api="/meta/nodes/{meta_node}/search-neighbour", kwargs=locals())
query = nodes_neighbour_query_builder(
meta_node=meta_node, id=id, limit=limit
)
logger.info(query)
response = epigraphdb.run_query(query)
return response
def rels_list(
meta_rel: EpigraphdbMetaRels,
limit: int = Query(10, ge=1, le=2000),
offset: int = 0,
):
"""List relationships under a meta relationship."""
log_args(api="/meta/rels/{meta_rel}/list", kwargs=locals())
query = MetaQueries.get_rels.format(
meta_rel=meta_rel.value, skip=offset, limit=limit
)
logger.info(query)
response = epigraphdb.run_query(query)
return response
def get_genetic_cor(trait: str,
cor_coef_threshold: float = Query(0.8, ge=-1.0, le=1.0)):
"""
Returns genetic correlates for a trait.
Args:
- `trait`: A trait name, e.g. Whole body fat mass
- `cor_coef_threshold`: correlation coefficient threshold
"""
log_args(api="/genetic-cor", kwargs=locals())
query = GeneticCorQueries.genetic_cor.format(
trait=trait, cor_coef_threshold=cor_coef_threshold)
response = epigraphdb.run_query(query)
return response
def get_obs_cor(
trait: str, cor_coef_threshold: float = Query(0.8, ge=-1.0, le=1.0)
):
"""
Returns observational correlates for a trait.
Args:
- `trait`: A trait name, e.g. "body mass index"
- `cor_coef_threshold`: Coefficient correlation threshold
"""
log_args(api="/obs-cor", kwargs=locals())
query = ObsCorQueries.gwas_obs_cor.format(
trait=trait, cor_coef_threshold=cor_coef_threshold
)
response = epigraphdb.run_query(query)
return response
def get_confounder(
exposure_trait: Optional[str] = None,
outcome_trait: Optional[str] = None,
type: ConfounderType = ConfounderType.confounder,
pval_threshold: float = Query(1e-5, ge=0.0, le=1.0),
):
"""
Get confounder / intermediate / collider evidence between traits:
`type` accepts 1 of the 4 options:
- confounder: confounder->exposure->outcome<-confounder
- intermediate: intermediate<-exposure->outcome<-confounder
- reverse_intermediate: intermediate->exposure->outcome->confounder
- collider: collider<-exposure->outcome->collider
"""
log_args(api="/confounder", kwargs=locals())
validate_at_least_one_not_none(
dict(exposure_trait=exposure_trait, outcome_trait=outcome_trait))
if type == "confounder":
query = ConfounderQueries.confounder.format(
exposure_trait=exposure_trait,
outcome_trait=outcome_trait,
pval_threshold=pval_threshold,
)
elif type == "intermediate":
query = ConfounderQueries.intermediate.format(
exposure_trait=exposure_trait,
outcome_trait=outcome_trait,
pval_threshold=pval_threshold,
)
elif type == "reverse_intermediate":
query = ConfounderQueries.reverse_intermediate.format(
exposure_trait=exposure_trait,
outcome_trait=outcome_trait,
pval_threshold=pval_threshold,
)
elif type == "collider":
query = ConfounderQueries.collider.format(
exposure_trait=exposure_trait,
outcome_trait=outcome_trait,
pval_threshold=pval_threshold,
)
response = epigraphdb.run_query(query)
return response
def nodes_search(
meta_node: str,
id: Optional[str] = None,
name: Optional[str] = None,
limit: int = Query(10, ge=1, le=200),
full_data: bool = True,
):
"""Use `id` for exact match, and use `name` for fuzzy match.
- full_data: If False, only returns basic info (id, name).
"""
log_args(api="/meta/nodes/{meta_node}/search", kwargs=locals())
validate_at_least_one_not_none(dict(id=id, name=name))
query = nodes_search_query_builder(
meta_node=meta_node, id=id, name=name, limit=limit, full_data=full_data
)
logger.info(query)
response = epigraphdb.run_query(query)
return response
def get_xqtl_multi_snp_mr(
exposure_gene: Optional[str] = None,
outcome_trait: Optional[str] = None,
mr_method: MrMethodInput = MrMethodInput.ivw,
qtl_type: QtlTypeInput = QtlTypeInput.eqtl,
pval_threshold: float = Query(1e-5, ge=0.0, le=1.0),
):
"""xQTL multi SNP MR results
Search by exposure_gene, outcome_trait, or both.
- qtl_type: eQTL, pQTL
"""
log_args(api="/xqtl/multi-snp-mr", kwargs=locals())
validate_at_least_one_not_none(
dict(exposure_gene=exposure_gene, outcome_trait=outcome_trait)
)
if exposure_gene is not None and outcome_trait is not None:
query = xqtl_queries.XqtlMultiSnpMr.exposure_outcome.format(
exposure=exposure_gene,
outcome=outcome_trait,
mr_method=mr_method.value,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
elif exposure_gene is not None:
query = xqtl_queries.XqtlMultiSnpMr.exposure.format(
exposure=exposure_gene,
mr_method=mr_method.value,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
elif outcome_trait is not None:
query = xqtl_queries.XqtlMultiSnpMr.outcome.format(
outcome=outcome_trait,
mr_method=mr_method.value,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
response = epigraphdb.run_query(query)
if qtl_type.value == "pQTL" and len(response["results"]) > 0:
response = mask_pqtl_snp(response=response, id_list=pqtl_gene_exclude)
return response
def get_paths_search(
meta_node_source: str,
id_source: str,
meta_node_target: str,
id_target: str,
max_path_length: int = Query(3, ge=1, le=5),
limit: int = Query(100, ge=1, le=500),
):
log_args(api="/meta/paths/search", kwargs=locals())
query = paths_search_query_builder(
meta_node_source=meta_node_source,
id_source=id_source,
meta_node_target=meta_node_target,
id_target=id_target,
max_path_length=max_path_length,
limit=limit,
)
logger.info(query)
response = epigraphdb.run_query(query)
return response
def post_gene_to_protein(data: models.GeneToProteinRequest):
"""
Return protein uniprot_id from associated genes.
- `gene_name_list`: List of HGNC symbols of the genes (default).
- `gene_id_list`: List of Ensembl gene IDs (when `by_gene_id == True`)
"""
log_args(api="/mappings/gene-to-protein", kwargs=locals())
if data.by_gene_id:
validate_at_least_one_not_none(dict(gene_id_list=data.gene_id_list))
query = queries.GeneToProtein.by_id.format(
gene_id_list=str(data.gene_id_list)
)
else:
validate_at_least_one_not_none(
dict(gene_name_list=data.gene_name_list)
)
query = queries.GeneToProtein.by_name.format(
gene_name_list=str(data.gene_name_list)
)
res = epigraphdb.run_query(query)
return res
def nodes_list(
meta_node: EpigraphdbMetaNodesFull,
full_data: bool = True,
limit: int = Query(10, ge=1, le=10_000),
offset: int = 0,
):
"""List nodes under a meta node.
- `limit`: If you supply full_data to be True, the limit is 500,
otherwise the limit is 10,000
- `full_data`: When False, only return the id and name fields for
a node.
For the specific id and name fields, refer to /meta/nodes/id-name-schema.
"""
log_args(api="/meta/nodes/{meta_node}/list", kwargs=locals())
if full_data:
full_data_limit = 500
if limit > full_data_limit:
raise HTTPException(
status_code=422,
detail=f"limit should be less equal than {full_data_limit}.",
)
query = MetaQueries.get_nodes.format(
meta_node=meta_node.value, skip=offset, limit=limit
)
else:
id_field = meta_node_id_name_mappings[meta_node.value]["id"]
name_field = meta_node_id_name_mappings[meta_node.value]["name"]
query = MetaQueries.get_node_id_and_name_fields.format(
meta_node=meta_node.value,
id_field=id_field,
name_field=name_field,
limit=limit,
offset=offset,
)
logger.info(query)
response = epigraphdb.run_query(query)
return response
def get_ontology_gwas_efo(
trait: Optional[str] = None,
efo_term: Optional[str] = None,
score_threshold: float = Query(0.75, ge=0.0, le=1.0),
fuzzy: bool = True,
):
"""
Map Gwas trait to EFO term, via `GWAS_NLP_EFO`
"""
log_args(api="/ontology/gwas-efo", kwargs=locals())
validate_at_least_one_not_none(dict(trait=trait, efo_term=efo_term))
validate_char_length(dict(trait=trait, efo_term=efo_term))
eq_symbol = "="
if fuzzy:
trait = cypher_fuzzify(trait)
efo_term = cypher_fuzzify(efo_term)
eq_symbol = "=~"
if trait is not None and efo_term is not None:
query = queries.GwasEfo.gwas_efo.format(
trait=trait,
efo_term=efo_term,
score_threshold=score_threshold,
eq_symbol=eq_symbol,
)
elif trait is not None:
query = queries.GwasEfo.gwas.format(trait=trait,
score_threshold=score_threshold,
eq_symbol=eq_symbol)
elif efo_term is not None:
query = queries.GwasEfo.efo.format(
efo_term=efo_term,
score_threshold=score_threshold,
eq_symbol=eq_symbol,
)
res = epigraphdb.run_query(query)
return res
def get_prs(trait: str, pval_threshold: float = Query(1e-5, ge=0.0, le=1.0)):
"""Polygenic risk scores between GWAS traits"""
log_args(api="/prs", kwargs=locals())
query = PrsQueries.prs.format(trait=trait, pval_threshold=pval_threshold)
response = epigraphdb.run_query(query)
return response
def get_literature_gwas_graph(
trait: Optional[str] = None,
assoc_trait: Optional[str] = None,
gwas_id: Optional[str] = None,
assoc_gwas_id: Optional[str] = None,
by_gwas_id: bool = False,
pval_threshold: float = Query(1e-3, ge=0, le=1e-1),
semmantic_types: List[str] = Query(["nusq"]),
blacklist: bool = True,
limit: int = Query(50, ge=1, le=2000),
skip: int = 0,
fuzzy: bool = True,
):
"""
Return information of traits in a Subject-Predicate-Object
association graph.
Args:
- `blacklist` (True) and `semmantic_types`: The list of
[semmantic types](https://mmtx.nlm.nih.gov/MMTx/semanticTypes.shtml) to exclude (`blacklist`=True) or include (`blacklist`=False).
Leave `semmantic_types` blank to disable this.
- `by_gwas_id` (False): If True search by Gwas.id
- `fuzzy` (True): By default fuzzy match trait name.
"""
log_args(api="/literature/gwas/pairwise", kwargs=locals())
if len(semmantic_types) > 0:
negative = "NOT" if blacklist else ""
types = ",".join([f"'{type}'" for type in semmantic_types])
semmantic_type_query = """
all(type in st.type where {negative} type IN [{types}])
""".format(negative=negative, types=types)
if by_gwas_id:
validate_at_least_one_not_none(dict(gwas_id=gwas_id))
if assoc_gwas_id is not None:
query = queries.GwasPairwise.id_assoc_id.format(
gwas_id=gwas_id,
assoc_gwas_id=assoc_gwas_id,
semmantic_type_query=semmantic_type_query,
pval_threshold=pval_threshold,
skip=skip,
limit=limit,
)
else:
query = queries.GwasPairwise.id.format(
gwas_id=gwas_id,
semmantic_type_query=semmantic_type_query,
pval_threshold=pval_threshold,
skip=skip,
limit=limit,
)
else:
validate_at_least_one_not_none(dict(trait=trait))
validate_char_length(dict(trait=trait, assoc_trait=assoc_trait))
eq_symbol = "="
if fuzzy:
trait = str(cypher_fuzzify(trait))
assoc_trait = cypher_fuzzify(assoc_trait)
eq_symbol = "=~"
if assoc_trait is not None:
query = queries.GwasPairwise.trait_assoc_trait.format(
trait=trait,
assoc_trait=assoc_trait,
semmantic_type_query=semmantic_type_query,
pval_threshold=pval_threshold,
eq_symbol=eq_symbol,
skip=skip,
limit=limit,
)
else:
query = queries.GwasPairwise.trait.format(
trait=trait,
semmantic_type_query=semmantic_type_query,
pval_threshold=pval_threshold,
eq_symbol=eq_symbol,
skip=skip,
limit=limit,
)
res = epigraphdb.run_query(query)
return res
def get_literature_gwas_semmed(
trait: Optional[str] = None,
gwas_id: Optional[str] = None,
semmed_triple_id: Optional[str] = None,
semmed_predicates: List[str] = Query([]),
by_gwas_id: bool = False,
pval_threshold: float = Query(1e-3, ge=0, le=1e-1),
limit: int = Query(50, ge=1, le=1000),
skip: int = 0,
fuzzy: bool = True,
):
"""
Search for literature evidence of a Gwas trait via semmed.
- `semmed_triple_id`: search for a specific semmed triple id
(see EpiGraphDB documentation)
- `semmed_predicates`: list of predicates for **whitelist**
- `by_gwas_id`: False. If True search by Gwas.id
- `fuzzy`: True. By default fuzzy match trait name.
- `skip`: pagination
"""
log_args(api="/literature/gwas", kwargs=locals())
semmed_predicates_clause = ""
if len(semmed_predicates) > 0:
semmed_predicates_clause = "AND triple.predicate IN [{clause}]".format(
clause=",".join(
[f"'{predicate}'" for predicate in semmed_predicates]))
if by_gwas_id:
validate_at_least_one_not_none(dict(gwas_id=gwas_id))
if semmed_triple_id is not None:
query = queries.Gwas.id_triple.format(
gwas_id=gwas_id,
semmed_triple_id=semmed_triple_id,
semmed_predicates_clause=semmed_predicates_clause,
pval_threshold=pval_threshold,
skip=skip,
limit=limit,
)
else:
query = queries.Gwas.id.format(
gwas_id=gwas_id,
semmed_predicates_clause=semmed_predicates_clause,
pval_threshold=pval_threshold,
limit=limit,
skip=skip,
)
else:
validate_at_least_one_not_none(dict(trait=trait))
validate_char_length(dict(trait=trait))
eq_symbol = "="
if fuzzy:
trait = str(cypher_fuzzify(trait))
eq_symbol = "=~"
if semmed_triple_id is not None:
query = queries.Gwas.trait_triple.format(
trait=trait,
semmed_triple_id=semmed_triple_id,
semmed_predicates_clause=semmed_predicates_clause,
pval_threshold=pval_threshold,
eq_symbol=eq_symbol,
limit=limit,
skip=skip,
)
else:
query = queries.Gwas.trait.format(
trait=trait,
semmed_predicates_clause=semmed_predicates_clause,
pval_threshold=pval_threshold,
eq_symbol=eq_symbol,
limit=limit,
skip=skip,
)
res = epigraphdb.run_query(query)
return res
def get_xqtl_single_snp_mr(
exposure_gene: str = None,
outcome_trait: str = None,
variant: str = None,
qtl_type: QtlTypeInput = QtlTypeInput.eqtl,
pval_threshold: float = 1e-5,
):
"""xQTL single SNP MR results
Search by exposure_gene, outcome_trait, variant, or all of them.
- qtl_type: eQTL, pQTL
"""
log_args(api="/xqtl/single-snp-mr", kwargs=locals())
validate_at_least_one_not_none(
dict(
exposure_gene=exposure_gene,
outcome_trait=outcome_trait,
variant=variant,
)
)
if (
exposure_gene is not None
and outcome_trait is not None
and variant is not None
):
query = xqtl_queries.XqtlSingleSnpMr.exposure_outcome_snp.format(
exposure=exposure_gene,
outcome=outcome_trait,
variant=variant,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
elif exposure_gene is not None and outcome_trait is not None:
query = xqtl_queries.XqtlSingleSnpMr.exposure_outcome.format(
exposure=exposure_gene,
outcome=outcome_trait,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
elif exposure_gene is not None and variant is not None:
query = xqtl_queries.XqtlSingleSnpMr.exposure_snp.format(
exposure=exposure_gene,
variant=variant,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
elif outcome_trait is not None and variant is not None:
query = xqtl_queries.XqtlSingleSnpMr.outcome_snp.format(
outcome=outcome_trait,
variant=variant,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
elif exposure_gene is not None:
query = xqtl_queries.XqtlSingleSnpMr.exposure.format(
exposure=exposure_gene,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
elif outcome_trait is not None:
query = xqtl_queries.XqtlSingleSnpMr.outcome.format(
outcome=outcome_trait,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
elif variant is not None:
query = xqtl_queries.XqtlSingleSnpMr.variant.format(
variant=variant,
qtl_type=qtl_type.value,
pval_threshold=pval_threshold,
)
response = epigraphdb.run_query(query)
if qtl_type.value == "pQTL" and len(response["results"]) > 0:
response = mask_pqtl_snp(response=response, id_list=pqtl_gene_exclude)
return response
def get_ontology_gwas_efo_disease(
trait: Optional[str] = None,
efo_term: Optional[str] = None,
disease_label: Optional[str] = None,
score_threshold: float = Query(0.75, ge=0.0, le=1.0),
fuzzy: bool = True,
):
"""
Map Gwas trait to Disease label, via Efo term.
"""
log_args(api="/ontology/gwas-efo-disease", kwargs=locals())
validate_at_least_one_not_none(
dict(trait=trait, disease_label=disease_label, efo_term=efo_term))
validate_char_length(
dict(trait=trait, disease_label=disease_label, efo_term=efo_term))
eq_symbol = "="
if fuzzy:
trait = cypher_fuzzify(trait)
efo_term = cypher_fuzzify(efo_term)
disease_label = cypher_fuzzify(disease_label)
eq_symbol = "=~"
if (trait is not None and disease_label is not None
and efo_term is not None):
query = queries.GwasEfoDisease.gwas_efo_disease.format(
trait=trait,
efo_term=efo_term,
disease_label=disease_label,
score_threshold=score_threshold,
eq_symbol=eq_symbol,
)
elif trait is not None and efo_term is not None:
query = queries.GwasEfoDisease.gwas_efo.format(
trait=trait,
efo_term=efo_term,
score_threshold=score_threshold,
eq_symbol=eq_symbol,
)
elif efo_term is not None and disease_label is not None:
query = queries.GwasEfoDisease.efo_disease.format(
efo_term=efo_term,
disease_label=disease_label,
score_threshold=score_threshold,
eq_symbol=eq_symbol,
)
elif trait is not None and disease_label is not None:
query = queries.GwasEfoDisease.gwas_disease.format(
trait=trait,
disease_label=disease_label,
score_threshold=score_threshold,
eq_symbol=eq_symbol,
)
elif trait is not None:
query = queries.GwasEfoDisease.gwas.format(
trait=trait, score_threshold=score_threshold, eq_symbol=eq_symbol)
elif efo_term is not None:
query = queries.GwasEfoDisease.efo.format(
efo_term=efo_term,
score_threshold=score_threshold,
eq_symbol=eq_symbol,
)
elif disease_label is not None:
query = queries.GwasEfoDisease.disease.format(
disease_label=disease_label,
score_threshold=score_threshold,
eq_symbol=eq_symbol,
)
res = epigraphdb.run_query(query)
return res
