shell: "curl -L {BGEE} -o {output}"

shell: "python scripts/bgee_to_kgx.py -i {input}  -o {output}"

shell: "curl -L {CL} -o {output}"

shell: "kgx transform -i obojson -o ../data/processed/intermediary/cl -f tsv {input} "

shell: "curl -L {PRMAPPING} -o {output}"

shell: "python scripts/cl_kgx_process.py -i {input.nodes} {input.edges} -m {input.mapping} -o {output}"

shell: "curl -L {DISGENET} -o {output}"

shell: "curl -L {MAPPING} -o {output}"

shell: "curl -L {DISGENET_VERSION} -o {output}"

shell: "python scripts/disgenet_to_kgx.py -i {input} -v {input.version}  -o {output}"

shell: "curl -L {ENSEMBLPROTEINS} -o {output}"

shell: "curl -L {ENSEMBLGENES}  -o {output}"

shell: "curl -L {ENSEMBLENTREZ}  -o {output}"

shell: "python scripts/ensembl_to_entrez.py -i {input} -o {output}"

shell: "zcat {input}| awk -F \"\t\" '$3 == \"gene\" {{ print $9 }}' | awk -F \"; \" 'BEGIN {{OFS=\"\t\"}} {{ print > \"{output}\" }}'"

shell: "python scripts/ensembl_to_kgx.py -i {input.ensembl} -u {input.uniprot} -g {input.genes}  -o {output}"

shell: "curl -L {GOAP} -o {output}"

shell: "curl -L {GOAC} -o {output}"

shell: "curl -L {GOAR} -o {output}"

shell: "curl -L {GOAI} -o {output}"

shell: "curl -L {GOAVERSION} -o {output}"

shell: "python scripts/goa_to_kgx.py -i {input.rna} {input.protein} {input.complex} {input.isoform} -r {input.ro} -g {input.go}  -c {input.cfg} -v {input.version} -o {output}"

shell: "curl {GO} -o {output}"

shell: "curl -L {GOVERSION} -o {output}"

shell: "kgx transform -i obojson -o ../data/processed/intermediary/go -f tsv {input} "

shell: "python scripts/go_kgx_process.py -i {input} -v {input.version} -o {output}"

shell: "curl -L {HPOA} -o {output}"

shell: "python scripts/hpoa_to_kgx.py -i {input.hpoa} -m {input.mondo_map} -n {input.hpo} -o {output}"

shell: "curl -L {HPO} -o {output}"

shell: "kgx transform -i obojson -o ../data/processed/intermediary/hpo -f tsv {input} "

shell: "python scripts/hpo_kgx_process.py -i {input} -o {output}"

shell: "curl -L {MIRTARBASE} -o {output}"

shell: "python scripts/mirtarbase_to_csv.py -i {input} -o {output}"

shell: "python scripts/mirtarbase_to_kgx.py -i {input.mirtarbase} -r {input.rnamapping} -g {input.genemapping} -o {output}"

shell: "curl -L {MONDO} -o {output}"

shell: "python scripts/mondo_mapping.py -i {input}  -o {output}"

shell: "kgx transform -i obojson -o ../data/processed/intermediary/mondo -f tsv {input} "

shell: "python scripts/mondo_kgx_process.py -i {input} -o {output}"

shell: "curl -L {NPINTER} -o {output}"

shell: "zcat {input} | awk -F \"\t\"  'BEGIN {{OFS=\"\t\"}} {{ if ($1 == \"interID\" || $11 == \"Homo sapiens\") print $0}}' > {output}"

shell: "python scripts/npinter_to_kgx.py -i {input.npinter} -r {input.noncoddingmapping} {input.tarbasemapping} {input.ensemblmapping} -p {input.proteinmapping} -g {input.genemapping} -o {output}"

shell: "curl -L {RNACENTRALENSEMBLMAPPING} -o {output}"

shell: "curl -L {RNACENTRALTARBASEMAPPING} -o {output}"

shell: "curl -L {RNANONCODINGMAPPING} -o {output}"

shell: "curl -L {RNACENTRAL} -o {output}"

shell: "curl -L {RNAVERSION} -o {output}"

shell: "awk 'BEGIN {{OFS=\"\t\"}} {{ if ($4 == 9606) print $0}}' {input} > {output}"

shell: "awk 'BEGIN {{OFS=\"\t\"}} {{ if ($4 == 9606) print $0}}' {input} > {output}"

shell: "awk 'BEGIN {{OFS=\"\t\"}} {{ if ($4 == 9606) print $0}}' {input} > {output}"

shell: "zcat {input} | awk -F \"\t\"  'BEGIN {{OFS=\"\t\"}} {{ if ($1!~/^!/ && $7 == \"taxon:9606\") print $1,$2,$4,$6}}' > {output}"

shell: "python scripts/rnacentral_to_kgx.py -i {input.rnacentral} -m {input.mapping} -g {input.genes} -v {input.version} -o {output}"

shell: "curl -L {RO} -o {output}"

shell: "curl -L {STRING} -o {output}"

shell: "python scripts/stringdb_to_kgx.py -i {input.string} -p {input.proteinmapping} -o {output}"

shell: "curl -L {UBERON} -o {output}"

shell: "kgx transform -i obojson -o ../data/processed/intermediary/uberon -f tsv {input}"

shell: "python scripts/uberon_kgx_process.py -i {input} -o {output}"

shell: "curl -L {UNIPROT} -o {output}"

import argparse
import pandas as pd
import uuid


def read_files(fname):
    df = pd.read_csv(fname, sep="\t", low_memory=False)
    return df

def get_version(fname):
    with open(fname) as f:
        for line in f:
            if "version" in line:
                version = line.split("version ")[1].split(").")[0]
    return version

def get_parser():
    parser = argparse.ArgumentParser(
        prog="disgenet_to_kgx.py",
        description=(
            "disgenet_to_csv: convert an disgenet file to CSVs with nodes and edges."
        ),
    )
    parser.add_argument("-i", "--input", nargs="+", help="Input files")
    parser.add_argument("-v", "--version", help="Input version file")
    parser.add_argument(
        "-o",
        "--output",
        nargs="+",
        default="disgenet",
        help="Output prefix. Default: out",
    )
    return parser


def main():
    parser = get_parser()
    args = parser.parse_args()
    disgenet = read_files(args.input[0])
    disgenet_mapping = read_files(args.input[1])
    entrez_to_ensembl = (
        read_files(args.input[2]).drop_duplicates().set_index("Entrez Gene ID")
    )

    entrez_to_ensembl = entrez_to_ensembl[
        ~entrez_to_ensembl.index.duplicated(keep="first")
    ].iloc[:, 0]

    # Transform nodes
    disgenet_mapping = disgenet_mapping[
        disgenet_mapping["vocabulary"].isin(["HPO", "MONDO"])
    ]

    disgenet_mapping["code"] = (
        disgenet_mapping["vocabulary"] + ":" + disgenet_mapping["code"]
    ).str.replace("HPO:", "")
    disgenet_mapping = (
        disgenet_mapping[["diseaseId", "code"]].drop_duplicates().set_index("diseaseId")
    )
    disgenet_mapping = disgenet_mapping[
        ~disgenet_mapping.index.duplicated(keep="first")
    ].iloc[:, 0]

    disgenet["geneId"] = disgenet["geneId"].map(str)

    disgenet["object"] = disgenet["diseaseId"].map(disgenet_mapping)
    disgenet["subject"] = "ENSEMBL:" + disgenet["geneId"].map(entrez_to_ensembl)
    disgenet["provided_by"] = "Disgenet"
    disgenet["source"] = "Disgenet"
    disgenet["source version"] = get_version(args.version)

    disgenet = disgenet.dropna(subset=["object", "subject"])

    gene_to_phenotype = disgenet[disgenet.object.str.startswith("HP")]
    gene_to_phenotype["category"] = "biolink:GeneToPhenotypicFeatureAssociation"
    gene_to_phenotype["predicate"] = "biolink:associated_with"
    gene_to_phenotype["relation"] = "RO:0016001"
    gene_to_phenotype["knowledge_source"] = "Disgenet"

    gene_to_phenotype = gene_to_phenotype[
        [
            "subject",
            "predicate",
            "object",
            "category",
            "relation",
            "knowledge_source",
            "provided_by",
            "diseaseName",
            "source",
            "source version"
        ]
    ].drop_duplicates()
    gene_to_phenotype["id"] = gene_to_phenotype["subject"].apply(lambda x: uuid.uuid4())

    gene_to_disease = disgenet[disgenet.object.str.startswith("MONDO")]
    gene_to_disease["category"] = "biolink:GeneToDiseaseAssociation"
    gene_to_disease["predicate"] = "biolink:associated_with"
    gene_to_disease["relation"] = "RO:0016001"
    gene_to_disease["knowledge_source"] = "Disgenet"
    gene_to_disease = gene_to_disease[
        [
            "subject",
            "predicate",
            "object",
            "category",
            "relation",
            "knowledge_source",
            "provided_by",
            "diseaseName",
            "source",
            "source version"
        ]
    ].drop_duplicates()
    gene_to_disease["id"] = gene_to_disease["subject"].apply(lambda x: uuid.uuid4())

    edges = pd.concat([gene_to_phenotype, gene_to_disease])
    edges[
        [
            "id",
            "subject",
            "predicate",
            "object",
            "category",
            "relation",
            "knowledge_source",
            "source",
            "source version"
        ]
    ].drop_duplicates().to_csv(f"{args.output[1]}", sep="\t", index=False)

    phenotypes = gene_to_phenotype
    phenotypes["id"] = gene_to_phenotype["object"]
    phenotypes["category"] = "biolink:PhenotypicFeature"
    phenotypes["name"] = gene_to_phenotype["diseaseName"]
    phenotypes = phenotypes[["id", "category", "name", "provided_by", "source", "source version"]]

    diseases = gene_to_disease
    diseases["id"] = diseases["object"]
    diseases["category"] = "biolink:Disease"
    diseases["name"] = gene_to_disease["diseaseName"]
    diseases = diseases[["id", "category", "name", "provided_by", "source", "source version"]]

    nodes = disgenet
    nodes["id"] = disgenet["subject"]
    nodes["category"] = "biolink:Gene"
    nodes["name"] = disgenet["geneSymbol"]
    nodes = nodes[["id", "category", "name", "provided_by", "source", "source version"]]

    nodes = pd.concat([nodes, phenotypes, diseases]).drop_duplicates()

    nodes[["id", "name", "category", "provided_by", "source", "source version"]].to_csv(
        f"{args.output[0]}", sep="\t", index=False
    )


if __name__ == "__main__":
    main()

import argparse
import pandas as pd

ENSEMBL_COLUMNS = ["Ensembl ID", "Entrez Gene ID"]


def read_file(fname):
    df = pd.read_csv(fname, sep="\t", low_memory=False)
    df = df[["gene_stable_id", "xref"]].drop_duplicates()
    df.columns = ENSEMBL_COLUMNS
    return df


def get_parser():
    parser = argparse.ArgumentParser(
        prog="ensembl_to_entrez.py",
        description="ensembl_to_entrez: download ensembl and entrez ids to csv file",
    )
    parser.add_argument("-i", "--input", help="Input files")
    parser.add_argument(
        "-o", "--output", default="ensembl to entrez", help="Output ensembl data."
    )
    return parser


def main():
    parser = get_parser()
    args = parser.parse_args()
    ensemblf = read_file(args.input)
    ensemblf[["Entrez Gene ID", "Ensembl ID"]].to_csv(
        f"{args.output}", sep="\t", index=False
    )


if __name__ == "__main__":
    main()

import uuid
import argparse
import pandas as pd

GENES = ["Gene Id", "Gene Version", "Gene Name"]


def read_id_mapping_uniprot(fname):
    df = pd.read_csv(fname, sep="\t", header=None, low_memory=False)
    df.columns = ["ID", "Database", "Database ID"]
    df = df[df["Database"] == "UniProtKB-ID"]
    df["Database ID"] = df["Database ID"].str.split("_").str[0]
    df = df[["ID", "Database ID"]].drop_duplicates().set_index("ID")
    df = df[~df.index.duplicated(keep="first")].iloc[:, 0]
    return df


def read_genes(fname):
    df = pd.read_csv(fname, sep=";", low_memory=False, header=None)
    df = df.iloc[:, :3]
    df.columns = GENES
    df = df[df["Gene Name"].str.contains("gene_name")]
    df["Gene Id"] = "ENSEMBL:" + df["Gene Id"].str.split(" ").str[-1].str.replace(
        '"', ""
    )
    df["Gene Name"] = df["Gene Name"].str.split(" ").str[-1].str.replace('"', "")
    df = df[["Gene Id", "Gene Name"]].drop_duplicates().set_index("Gene Id")
    df = df[~df.index.duplicated(keep="first")].iloc[:, 0]
    return df


def get_parser():
    parser = argparse.ArgumentParser(
        prog="ensembl_to_kgx.py",
        description=(
            "ensembl_to_csv: convert an ensembl file to CSVs with nodes and edges."
        ),
    )
    parser.add_argument("-i", "--input", help="Input files")
    parser.add_argument("-u", "--uniprot", help="Input files")
    parser.add_argument("-g", "--genes", help="Input files")
    parser.add_argument(
        "-o",
        "--output",
        nargs="+",
        default="ensembl",
        help="Output prefix. Default: out",
    )
    return parser


def main():
    parser = get_parser()
    args = parser.parse_args()
    uniprotf = read_id_mapping_uniprot(args.uniprot)
    ensemblf = pd.read_csv(args.input, sep="\t", comment="!", low_memory=False)
    genesf = read_genes(args.genes)

    ensemblf["protein name"] = ensemblf["xref"].map(uniprotf)
    ensemblf["provided_by"] = "ENSEMBL"
    ensemblf["knowledge_source"] = "ENSEMBL"
    ensemblf["xref"] = ensemblf["xref"].str.split("-").str[0]
    ensemblf["protein name"] = ensemblf["xref"].map(uniprotf)
    ensemblf["source"] = "ENSEMBL"
    version = args.input.split(".")
    ensemblf["source version"] = version[3] + " " + version[4]

    gene_to_protein = ensemblf.dropna(subset=["xref"])
    gene_to_protein["subject"] = "ENSEMBL:" + gene_to_protein["gene_stable_id"]
    gene_to_protein["object"] = "UNIPROTKB:" + gene_to_protein["xref"]
    gene_to_protein["predicate"] = "biolink:has_gene_product"
    gene_to_protein["relation"] = "RO:0002205"
    gene_to_protein = gene_to_protein[
        ["subject", "predicate", "object", "relation", "knowledge_source", "source", "source version"]
    ].drop_duplicates()
    gene_to_protein["id"] = gene_to_protein["subject"].apply(lambda x: uuid.uuid4())

    protein = ensemblf.dropna(subset=["xref"])

    protein["id"] = "UNIPROTKB:" + protein["xref"]
    protein["category"] = "biolink:Protein"
    protein["name"] = protein["protein name"]
    protein["xref"] = "ENSEMBL:" + ensemblf["protein_stable_id"]
    protein = protein[["id", "category", "name", "xref", "provided_by", "source", "source version"]]

    edges = gene_to_protein

    genes = ensemblf
    genes["id"] = "ENSEMBL:" + ensemblf["gene_stable_id"]
    genes["category"] = "biolink:Gene"
    genes["name"] = genes["id"].map(genesf)
    genes = genes[["id", "category", "name", "provided_by", "source", "source version"]]

    nodes = pd.concat([genes, protein]).drop_duplicates()

    nodes[["id", "name", "category", "provided_by", "xref", "source", "source version"]].to_csv(
        f"{args.output [0]}", sep="\t", index=False
    )
    edges[
        ["object", "subject", "id", "predicate", "knowledge_source", "relation", "source", "source version"]
    ].to_csv(f"{args.output[1]}", sep="\t", index=False)


if __name__ == "__main__":
    main()

import pandas as pd
import argparse
import json

def get_parser():
    parser = argparse.ArgumentParser(
        prog="go_kgx_process.py",
        description=(
            "go_kgx_process: get go version."
        ),
    )
    parser.add_argument("-i", "--input", nargs="+", help="Input files")
    parser.add_argument("-v", "--version", help="Input version file")
    parser.add_argument(
        "-o",
        "--output",
        nargs="+",
        default="go",
        help="Output prefix. Default: out",
    )
    return parser

def main():

    parser = get_parser()
    args = parser.parse_args()
    gonodes = pd.read_csv(args.input[0], sep="\t", low_memory=False)
    goedges = pd.read_csv(args.input[1], sep="\t", low_memory=False)

    with open(args.version, "r") as f:
        version = json.load(f)["date"]

    gonodes["source"] = "GO"
    gonodes["source version"] = version

    goedges["source"] = "GO"
    goedges["source version"] = version

    gonodes[["id", "category", "name", "provided_by", "description", "xref", "source", "source version"]].drop_duplicates().to_csv(
        f"{args.output[0]}", sep="\t", index=False
    )
    goedges[
        ["id", "subject", "predicate", "object", "relation", "knowledge_source", "source", "source version"]
    ].to_csv(f"{args.output[1]}", sep="\t", index=False)

if __name__ == "__main__":
    main()

import uuid
import argparse
import pandas as pd

HPOA_COLUMNS = [
    "DatabaseId",
    "DB Name",
    "Qualifier",
    "HPO ID",
    "DB Reference",
    "Evidence",
    "Onset",
    "Frequency",
    "Sex",
    "Modifier",
    "Aspect",
    "Biocuration",
]

def get_version (fname):
    with open(fname) as f:
        for line in f:
            if "#version:" in line:
                version = line.split(":")[1].split("\n")[0].replace(" ", "")
    return version

def read_hpoa(fname):
    hpoa = pd.read_csv(fname, sep="\t", header=None, low_memory=False, comment="#")
    hpoa.columns = HPOA_COLUMNS
    return hpoa


def read_mondo(fname):
    mondo = pd.read_csv(fname, sep="\t", low_memory=False)
    mondo = mondo.drop_duplicates().set_index("disease")
    mondo = mondo[~mondo.index.duplicated(keep="first")].iloc[:, 0]
    return mondo


def get_parser():
    parser = argparse.ArgumentParser(
        prog="hpoa_to_kgx.py",
        description="hpoa_to_kgx: convert an hpoa file to CSVs with nodes and edges.",
    )
    parser.add_argument("-i", "--input", help="Input hpoa files")
    parser.add_argument("-m", "--mapping", help="Input mondo mapping files")
    parser.add_argument("-n", "--hpo", help="Input hpo nodes")
    parser.add_argument(
        "-o", "--output", nargs="+", default="goa", help="Output prefix. Default: out"
    )
    return parser


def main():
    parser = get_parser()
    args = parser.parse_args()
    hpoa = read_hpoa(args.input)
    mondo_mapping = read_mondo(args.mapping)

    version = get_version(args.input)

    hpoa["provided_by"] = "HPOA"
    hpoa["knowledge_source"] = "HPOA"
    hpoa["id"] = hpoa["DatabaseId"].map(mondo_mapping)
    hpoa["category"] = "biolink:Disease"
    hpoa["name"] = hpoa["DB Name"]
    hpoa["source"] = "HPOA"
    hpoa["source version"] = version
    hpf = pd.read_csv(args.hpo, sep="\t")[
        [
            "id",
            "name",
            "category",
            "provided_by",
            "xref",
            "source",
            "source version"
        ]
    ]
    hpf = hpf[hpf.id.str.startswith("HP")]
    nodes = pd.concat([
        hpoa[
                [
                    "id",
                    "name",
                    "category",
                    "provided_by",
                    "source",
                    "source version"
                ]
        ].dropna(subset=["id"]), hpf]).drop_duplicates().to_csv(
        f"{args.output[0]}", sep="\t", index=False
    )
    # Now edges

    hpoa["subject"] = hpoa["DatabaseId"].map(mondo_mapping)
    hpoa["object"] = hpoa["HPO ID"]
    hpoa["id"] = hpoa.id.apply(lambda x: uuid.uuid4())
    hpoa["category"] = "biolink:DiseaseToPhenotypicFeatureAssociation"
    hpoa["negated"] = hpoa.Qualifier.str.startswith("NOT")
    hpoa["predicate"] = "biolink:has_phenotype"
    hpoa["relation"] = "RO:0002200"
    hpoa = (
        hpoa[
            [
                "subject",
                "predicate",
                "object",
                "negated",
                "category",
                "relation",
                "knowledge_source",
                "source",
                "source version"
            ]
        ]
        .dropna()
        .drop_duplicates()
    )
    hpoa["id"] = hpoa.subject.apply(lambda x: uuid.uuid4())
    hpoa.to_csv(f"{args.output[1]}", sep="\t", index=False)


if __name__ == "__main__":
    main()

import pandas as pd
import argparse
import requests

release = "https://api.github.com/repos/obophenotype/human-phenotype-ontology/releases/latest"
def get_parser():
    parser = argparse.ArgumentParser(
        prog="hpo_kgx_process.py",
        description=(
            "hpo_kgx_process: get hpo version."
        ),
    )
    parser.add_argument("-i", "--input", nargs="+", help="Input files")
    parser.add_argument(
        "-o",
        "--output",
        nargs="+",
        default="go",
        help="Output prefix. Default: out",
    )
    return parser

def main():

    parser = get_parser()
    args = parser.parse_args()
    hponodes = pd.read_csv(args.input[0], sep="\t", low_memory=False)
    hpoedges = pd.read_csv(args.input[1], sep="\t", low_memory=False)

    response = requests.get(
        release
    )
    version = response.json()["name"]

    hponodes["source"] = "HPO"
    hponodes["source version"] = version

    hpoedges["source"] = "HPO"
    hpoedges["source version"] = version

    hponodes[["id", "category", "name", "provided_by", "description", "xref", "source","source version"]].drop_duplicates().to_csv(
        f"{args.output[0]}", sep="\t", index=False
    )
    hpoedges[
        ["id", "subject", "predicate", "object", "relation", "knowledge_source", "source", "source version"]
    ].to_csv(f"{args.output[1]}", sep="\t", index=False)

if __name__ == "__main__":
    main()