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