diff --git a/HGNC_pathways/secondaryHgncSymbolsInDatabases.Rmd b/HGNC_pathways/secondaryHgncSymbolsInDatabases.Rmd index bd130ed..a063f6e 100644 --- a/HGNC_pathways/secondaryHgncSymbolsInDatabases.Rmd +++ b/HGNC_pathways/secondaryHgncSymbolsInDatabases.Rmd @@ -49,7 +49,7 @@ secondaryHGNCSymbols <- setdiff(HGNCMappings$secondarySymbol, HGNCMappings$prima ## 2. Data Download We download the data for each database, based on their API, RDF, or other data download option (depending on availability). -### 1. KEGG +### 2.1. KEGG The information in KEGG was obtained using an API call. ```{r, include=FALSE} ##Install and load required packages: @@ -62,8 +62,7 @@ library(httr) library(jsonlite) library(data.table) -## pathway map IDs listed under "1.3 Lipid metabolism" -#lipid_kegg_maps <- c("00061", "00062", "00071", "00073", "00100", "00120", "00121", "00140", "00561", "00564", "00565", "00600", "00590", "00591", "00592", "01040") +## Get all pathway map IDs first: kegg_maps_APIcall <- "https://rest.kegg.jp/list/pathway/hsa" res_maps = GET(kegg_maps_APIcall) Kegg_data_maps <- rawToChar(res_maps$content) @@ -74,6 +73,7 @@ if(length(res_maps$content)>1){ Kegg_maps_total <- rbind(Kegg_maps_total,df_maps) } +##Convert KEGG maps results to new API call to retrieve all genes within each map: kegg_maps <- Kegg_maps_total$V1 ##Add URL for query item: kegg_genes_APIcall <- paste("https://rest.kegg.jp/link/hsa/", kegg_maps, sep="") @@ -100,7 +100,7 @@ rm(list=setdiff(ls(), retain)) ``` Unfortunately, the KEGG database does not allow to retrieve the labels within the pathway images, so we cannot use it further in our comparison. -### 2. Reactome +### 2.2. Reactome For the Reactome content, we download the Physical Entity (PE) Identifier mapping files. Since the HGNC symbols are not available as a direct mapping, we retrieve all mappings from UniProt, Ensembl, and NCBI, to integrate their content on HGNC symbols. ```{r, include=FALSE} ##Only download the data, if not available already locally. @@ -150,13 +150,25 @@ retain <- append(retain, "mergedReactome") rm(list=setdiff(ls(), retain)) ``` -Compare the Reactome data against primary symbols first, then against secondary symbols, last count how many were not matching at all. +Compare the Reactome data against primary symbols first, then against secondary symbols, last count how many were not matching at all. ```{r} - +##Check overlap between prim and sec: +uniqueSec <- setdiff(secondaryHGNCSymbols, primaryHGNCSymbols) + +##Convert reactome data to vector format: +mergedReactomeVector <- mergedReactome[['HGNC']] +##Check primary symbols: +primaryMatchesReactome <- intersect(primaryHGNCSymbols, mergedReactomeVector) +##Amount: +amountPrimaryMatchesReactome <- length(primaryMatchesReactome) +##Check secondary symbols: +secondaryMatchesReactome <- intersect(uniqueSec, mergedReactomeVector) +##Amount: +amountSecondaryMatchesReactome <- length(secondaryMatchesReactome) ``` -### 3. WikiPathways +### 2.3. WikiPathways The WikiPathways data was queried in the RDF format. ```{r, include=FALSE} ##WikiPathways (original pathways) @@ -230,11 +242,51 @@ showresultsWikiPathways <- resultsWikiPathways$results remove(queryWikiPathways, resultsWikiPathways) ``` +Compare the WikiPathways data against primary symbols first, then against secondary symbols, last count how many were not matching at all. +```{r} +##Check overlap between prim and sec: +uniqueSec <- setdiff(secondaryHGNCSymbols, primaryHGNCSymbols) + +##Convert reactome data to vector format: +mergedWikiPathwaysVector <- showresultsWikiPathways[['HGNC']] +##Check primary symbols: +primaryMatchesWikiPathways <- intersect(primaryHGNCSymbols, mergedWikiPathwaysVector) +##Amount: +amountPrimaryMatchesWikiPathways <- length(primaryMatchesWikiPathways) +##Check secondary symbols: +secondaryMatchesWikiPathways <- intersect(uniqueSec, mergedWikiPathwaysVector) +##Amount: +amountSecondaryMatchesWikiPathways <- length(secondaryMatchesWikiPathways) +``` + + + +### 2.4. BiGG data Models +```{r, include=FALSE} +##Install and load required packages: +api_packages <- c("httr", "jsonlite", "data.table") +for (i in 1:length(api_packages)) { +if(!api_packages[i] %in% installed.packages()){install.packages(api_packages[i])} +} +#install.packages(c("httr", "jsonlite", "data.table")) +library(httr) +library(jsonlite) +library(data.table) +biggModelsAPIcall <- 'http://bigg.ucsd.edu/api/v2/models' +biggModels_maps = GET(biggModelsAPIcall) +biggModels_data_maps <- rawToChar(biggModels_maps$content) +biggModels_maps_total = data.frame() +if(length(biggModels_maps$content)>1){ + cleaned_biggModels_data_maps <- fread(text = biggModels_data_maps, header=FALSE, fill = TRUE, sep = '\t') + df_maps <- data.frame(cleaned_biggModels_data_maps) + biggModels_maps_total <- rbind(biggModels_maps_total,df_maps) + } +``` -### 5. Gene Ontology +### 2.5. Gene Ontology From the Quick-GO website (https://www.ebi.ac.uk/QuickGO/), we downloaded data based on the following criteria: --> Use API instead! I. Taxon: 9606 (Homo sapiens, human). @@ -253,14 +305,12 @@ work_DIR <- getwd() ## 3. Data Comparison We compare the data for each database to the secondary HGNC symbols. - ```{r} plot(cars) ``` ## 4. Data Visualization We visualize the data for all databases combined. - ```{r} plot(cars) ``` diff --git a/HGNC_pathways/secondaryHgncSymbolsInDatabases.nb.html b/HGNC_pathways/secondaryHgncSymbolsInDatabases.nb.html index ce52944..d7cf88e 100644 --- a/HGNC_pathways/secondaryHgncSymbolsInDatabases.nb.html +++ b/HGNC_pathways/secondaryHgncSymbolsInDatabases.nb.html @@ -1779,14 +1779,10 @@

0. Notebook setup

library(rstudioapi) library(dplyr) - +

 Attaching package: ‘dplyr’
 
-The following objects are masked from ‘package:data.table’:
-
-    between, first, last
-
 The following objects are masked from ‘package:stats’:
 
     filter, lag
@@ -1818,7 +1814,7 @@ 

2. Data Download

We download the data for each database, based on their API, RDF, or other data download option (depending on availability).

-

1. KEGG

+

2.1. KEGG

The information in KEGG was obtained using an API call.

@@ -1827,7 +1823,7 @@

1. KEGG

comparison.

-

2. Reactome

+

2.2. Reactome

For the Reactome content, we download the Physical Entity (PE) Identifier mapping files. Since the HGNC symbols are not available as a direct mapping, we retrieve all mappings from UniProt, Ensembl, and @@ -1838,17 +1834,59 @@

2. Reactome

secondary symbols, last count how many were not matching at all.

+ +
##Check overlap between prim and sec:
+uniqueSec <-  setdiff(secondaryHGNCSymbols, primaryHGNCSymbols)
+
+##Convert reactome data to vector format:
+mergedReactomeVector <- mergedReactome[['HGNC']]
+##Check primary symbols:
+primaryMatchesReactome <- intersect(primaryHGNCSymbols, mergedReactomeVector)
+##Amount:
+amountPrimaryMatchesReactome <- length(primaryMatchesReactome)
+##Check secondary symbols:
+secondaryMatchesReactome <- intersect(uniqueSec, mergedReactomeVector)
+##Amount:
+amountSecondaryMatchesReactome <- length(secondaryMatchesReactome)
+
-

3. WikiPathways

+

2.3. WikiPathways

The WikiPathways data was queried in the RDF format.

+

Compare the WikiPathways data against primary symbols first, then +against secondary symbols, last count how many were not matching at +all.

+ + + +
##Check overlap between prim and sec:
+uniqueSec <-  setdiff(secondaryHGNCSymbols, primaryHGNCSymbols)
+
+##Convert reactome data to vector format:
+mergedWikiPathwaysVector <- showresultsWikiPathways[['HGNC']]
+##Check primary symbols:
+primaryMatchesWikiPathways <- intersect(primaryHGNCSymbols, mergedWikiPathwaysVector)
+##Amount:
+amountPrimaryMatchesWikiPathways <- length(primaryMatchesWikiPathways)
+##Check secondary symbols:
+secondaryMatchesWikiPathways <- intersect(uniqueSec, mergedWikiPathwaysVector)
+##Amount:
+amountSecondaryMatchesWikiPathways <- length(secondaryMatchesWikiPathways)
+ + + +
+
+

2.4. BiGG data Models

+ +
-

5. Gene Ontology

+

2.5. Gene Ontology

From the Quick-GO website (https://www.ebi.ac.uk/QuickGO/), we downloaded data based on the following criteria: –> Use API instead! I. Taxon: 9606 (Homo sapiens, human).

@@ -1881,7 +1919,7 @@

4. Data Visualization

-
---
title: "Secondary HGNC Symbols used in different Databases"
output: html_notebook
---

This is an [R Markdown](http://rmarkdown.rstudio.com) Notebook. When you execute code within the notebook, the results appear beneath the code. 

This script compares gene symbol names from four different databases (KEGG, Reactome, WikiPathways, Gene Ontology) to the list of outdated HGNC symbols.

## 0. Notebook setup
The first section of this Notebook lists all the libraries required to run this script.

```{r}
#Package manager:
if(!requireNamespace("BiocManager", quietly = TRUE)) install.packages("BiocManager",repos = "http://cran.us.r-project.org")
#Package for path variable
if(!"rstudioapi" %in% installed.packages()) BiocManager::install("rstudioapi")
#Libraries required for markdown documents:
if(!"markdown" %in% installed.packages()){install.packages("markdown")}
if(!"rmarkdown" %in% installed.packages()){install.packages("rmarkdown")}
if(!"dplyr" %in% installed.packages()){install.packages("dplyr")}

#load libraries
library(rstudioapi)
library(dplyr)
library(tidyr)

# set working environment to current folder
workingDirectory <- setwd(dirname(rstudioapi::getSourceEditorContext()$path))
```

## 1. HGNC Symbol data download
First, we load all the primary and secondary symbols of HGNC to be used in this comparison (based on data release in Zenodo).
We filter out the symbols which are used as both primary and secondary symbols (which could lead to false positive results).

```{r, include=FALSE}
if(!file.exists("HGNC_secID2priID.tsv")){
  #download.file('https://reactome.org/download/current/UniProt2Reactome_PE_Pathway.txt', destfile=paste0(workingDirectory, '/dataInput/UniProt2Reactome.txt'), method = "wget", extra = "-r -p --random-wait") ##Replace with Zenodo download when available!
}

HGNCMappings <- EnsemblReactome <- read.delim(paste0(workingDirectory, '/dataInput/HGNC_secID2priID.tsv'), header = TRUE, sep = "\t", dec = ".") #Create dataframe from HGNC Symbols data
##Create unique set of primary IDs (without overlap to secondaries)
primaryHGNCSymbols <- setdiff(HGNCMappings$primarySymbol, HGNCMappings$secondarySymbol)

##Create unique set of secondary IDs (without overlap to primaries)
secondaryHGNCSymbols <- setdiff(HGNCMappings$secondarySymbol, HGNCMappings$primarySymbol)
```

## 2. Data Download
We download the data for each database, based on their API, RDF, or other data download option (depending on availability).

### 1. KEGG
The information in KEGG was obtained using an API call.
```{r, include=FALSE}
##Install and load required packages:
api_packages <- c("httr", "jsonlite", "data.table")
for (i in 1:length(api_packages)) {
if(!api_packages[i] %in% installed.packages()){install.packages(api_packages[i])}
}
#install.packages(c("httr", "jsonlite", "data.table"))
library(httr)
library(jsonlite)
library(data.table)

## pathway map IDs listed under "1.3 Lipid metabolism"
#lipid_kegg_maps <- c("00061", "00062", "00071", "00073", "00100", "00120", "00121", "00140", "00561", "00564", "00565", "00600", "00590", "00591", "00592", "01040") 
kegg_maps_APIcall <- "https://rest.kegg.jp/list/pathway/hsa"
res_maps = GET(kegg_maps_APIcall)
Kegg_data_maps <- rawToChar(res_maps$content)
Kegg_maps_total = data.frame()
if(length(res_maps$content)>1){
  cleaned_Kegg_data_maps <- fread(text = Kegg_data_maps, header=FALSE, fill = TRUE, sep = '\t')
  df_maps <- data.frame(cleaned_Kegg_data_maps)
  Kegg_maps_total <- rbind(Kegg_maps_total,df_maps)
  }

kegg_maps <- Kegg_maps_total$V1
##Add URL for query item:
kegg_genes_APIcall <- paste("https://rest.kegg.jp/link/hsa/", kegg_maps, sep="")

##Create an empty dataframe to store the results of the loop:
Kegg_genes_total = data.frame()

## Execute API calls, example to obtain chemical compounds for a PW map:
for (i in 1:length(nrow(Kegg_maps_total[1]))) {
  ##Get the genes:
  res_genes = GET(kegg_genes_APIcall[i])
  Kegg_data_genes <- rawToChar(res_genes$content)
  if(length(res_genes$content)>1){
  cleaned_Kegg_data_genes <- fread(text = Kegg_data_genes, header=FALSE, fill = TRUE)
  df_genes <- data.frame(cleaned_Kegg_data_genes)
  Kegg_genes_total <- rbind(Kegg_genes_total,df_genes)
  }
}

##Keep only dataframes with name "_total" to save space
#rm(list = ls()[!grepl("_total", ls())])
retain = c("primaryHGNCSymbols", "secondaryHGNCSymbols", "workingDirectory", "retain")
rm(list=setdiff(ls(), retain))
```
Unfortunately, the KEGG database does not allow to retrieve the labels within the pathway images, so we cannot use it further in our comparison.

### 2. Reactome
For the Reactome content, we download the Physical Entity (PE) Identifier mapping files. Since the HGNC symbols are not available as a direct mapping, we retrieve all mappings from UniProt, Ensembl, and NCBI, to integrate their content on HGNC symbols.
```{r, include=FALSE}
##Only download the data, if not available already locally.
##UniProt mappings
if(!file.exists("dataInput/UniProt2Reactome.txt")){
  download.file('https://reactome.org/download/current/UniProt2Reactome_PE_Pathway.txt', destfile=paste0(workingDirectory, '/dataInput/UniProt2Reactome.txt'), method = "wget", extra = "-r -p --random-wait")
}
##Ensembl mappings
if(!file.exists("dataInput/Ensembl2Reactome.txt")) {
  download.file('https://reactome.org/download/current/Ensembl2Reactome_PE_Pathway.txt', destfile=paste0(workingDirectory, '/dataInput/Ensembl2Reactome.txt'), method = "wget", extra = "-r -p --random-wait")
}
##NCBI mappings
if(!file.exists("dataInput/NCBI2Reactome.txt")) {
  download.file('https://reactome.org/download/current/NCBI2Reactome_PE_Pathway.txt', destfile=paste0(workingDirectory, '/dataInput/NCBI2Reactome.txt'), method = "wget", extra = "-r -p --random-wait")
}

##Store the data in a dataframe, extract the relevant information, and merge results from three mapping systems (if needed):
#Uniprot mappings
UniprotReactome <- read.delim(paste0(workingDirectory, '/dataInput/UniProt2Reactome.txt'), header = FALSE, sep = "\t", dec = ".") #Create dataframe from input data
UniprotReactome <- UniprotReactome[UniprotReactome[8] == 'Homo sapiens',] #Only keep data for one species (Homo sapiens)
UniprotReactome <- UniprotReactome[c(3)] #Retain column with HGNC Symbols
UniprotReactome <- separate(UniprotReactome, V3, into = c("HGNC", "Location"), sep = " (?=(\\[[^\\]]*\\])+$)") ##Split localization data from HGNC symbol
UniprotReactome <- UniprotReactome[c(1)] #remove localization data
UniprotReactome <- unique(UniprotReactome) #Keep unique symbols only 
#Ensembl mappings
EnsemblReactome <- read.delim(paste0(workingDirectory, '/dataInput/Ensembl2Reactome.txt'), header = FALSE, sep = "\t", dec = ".") #Create dataframe from input data
EnsemblReactome <- EnsemblReactome[EnsemblReactome[8] == 'Homo sapiens',] #Only keep data for one species (Homo sapiens)
EnsemblReactome <- EnsemblReactome[c(3)] #Retain column with HGNC Symbols
EnsemblReactome <- separate(EnsemblReactome, V3, into = c("HGNC", "Location"), sep = " (?=(\\[[^\\]]*\\])+$)") ##Split localization data from HGNC symbol
EnsemblReactome <- EnsemblReactome[c(1)] #remove localization data
EnsemblReactome <- unique(EnsemblReactome) #Keep unique symbols only 
#NCBI mappings
NCBIReactome <- read.delim(paste0(workingDirectory, '/dataInput/NCBI2Reactome.txt'), header = FALSE, sep = "\t", dec = ".") #Create dataframe from input data
NCBIReactome <- NCBIReactome[NCBIReactome[8] == 'Homo sapiens',] #Only keep data for one species (Homo sapiens)
NCBIReactome <- NCBIReactome[c(3)] #Retain column with HGNC Symbols
NCBIReactome <- separate(NCBIReactome, V3, into = c("HGNC", "Location"), sep = " (?=(\\[[^\\]]*\\])+$)") ##Split localization data from HGNC symbol
NCBIReactome <- NCBIReactome[c(1)] #remove localization data
NCBIReactome <- unique(NCBIReactome) #Keep unique symbols only 

#Merge the data together
df_list <- list(UniprotReactome, EnsemblReactome, NCBIReactome)
mergedReactome <- Reduce(function(x, y) merge(x, y, all=TRUE), df_list, accumulate=FALSE)
#mergedReactome <- unique(mergedReactome) #Keep unique symbols only (to check if above function worked correctly)

#Remove unnecessary data
retain <- append(retain, "mergedReactome")
rm(list=setdiff(ls(), retain))
```

Compare the Reactome data against primary symbols first,  then against secondary symbols, last count how many were not matching at all.
```{r}

```


### 3. WikiPathways
The WikiPathways data was queried in the RDF format.
```{r, include=FALSE}
##WikiPathways (original pathways)

###PRIOR code to install SPARQl package; Package not available in CRAN anymore, only works for older version of R
#if(!"SPARQL" %in% installed.packages()){
#  install.packages("SPARQL")
#}

##Solution: download from archived version
#Location to install archived packages:
packageFolder <-paste0(workingDirectory, '/packages/SPARQL.tar.gz')
downloadLinkSPARQL <-"https://cran.r-project.org/src/contrib/Archive/SPARQL/SPARQL_1.16.tar.gz"

##Download archived version instead:
if(!"downloader" %in% installed.packages()){
  install.packages("downloader")
}
library("downloader")

##Only download file if needed
if (!file.exists(packageFolder)) {
  download.file(downloadLinkSPARQL, packageFolder)
}

##Install the local version of the library
install.packages(packageFolder, repos = NULL, type="source")

library(SPARQL)
##Connect to Endpoint WikiPathways
endpointwp <- "https://sparql.wikipathways.org/sparql"

## 1. Query metadata:
queryMetadata <-
"SELECT DISTINCT ?dataset (str(?titleLit) as ?title) ?date ?license 
WHERE {
   ?dataset a void:Dataset ;
   dcterms:title ?titleLit ;
   dcterms:license ?license ;
   pav:createdOn ?date .
 }"
 #below code should be performed first to handle the ssl certificate error
options(RCurlOptions = list(cainfo = paste0( tempdir() , "/cacert.pem" ), ssl.verifypeer = FALSE))
resultsMetadata <- SPARQL(endpointwp,queryMetadata,curl_args=list(useragent=R.version.string))
showresultsMetadata <- resultsMetadata$results
remove(queryMetadata, resultsMetadata)

## 2. Query WikiPathways PWs, HGNC symbols used in Labels:

## 3. Query WikiPathways PWs, HGNC symbol used in original annotations:

## 4. Query WikiPathways PWs, HGNC symbol Mappings:
queryWikiPathways <-
"PREFIX cur:            <http://vocabularies.wikipathways.org/wp#Curation:> #to differentiate between Reactome and WP PWs.

select distinct (fn:substring(?hgncId,37) as ?HGNC) (GROUP_CONCAT(DISTINCT str(?wpid);separator=', ') AS ?pathways)  (COUNT(DISTINCT str(?wpid)) AS ?usage)
where {
  ?pathwayRes a wp:Pathway ;                   #Define what is a pathway
              wp:organismName 'Homo sapiens' ; #Filter pathways on species Human
              dcterms:identifier ?wpid ;       #Obtain identifier of pathway
              wp:ontologyTag cur:AnalysisCollection .  #Reactome: Reactome_Approved . WP: Curation:AnalysisCollection
  
  ?protein wp:bdbHgncSymbol ?hgncId ;          #Find proteins based on HGNC symbol
           dcterms:isPartOf ?pathwayRes .      #Connect protein to PW
}
ORDER BY DESC (?usage)
"
##Execute query:
resultsWikiPathways <- SPARQL(endpointwp,queryWikiPathways,curl_args=list(useragent=R.version.string))
showresultsWikiPathways <- resultsWikiPathways$results
remove(queryWikiPathways, resultsWikiPathways)
```




### 5. Gene Ontology

From the Quick-GO website (https://www.ebi.ac.uk/QuickGO/), we downloaded data based on the following criteria: --> Use API instead!
I. Taxon: 9606 (Homo sapiens, human).

Data was downloaded on: Nov. 6 (2023), with 1,685,892 annotations, as a TSV file.
```{r, include=FALSE}
GO_fileLocation <- paste0(workingDirectory, '/DataInput/... .tsv')
##GO terms
go_terms <- read.delim(file = "DataInput/QuickGO-annotations-1659356807403-20220801.tsv", header = TRUE, sep = '\t')
go_terms_unique <- unique(go_terms$SYMBOL)

# Set Working Directory back to current folder
setwd(dirname(rstudioapi::getSourceEditorContext()$path))
work_DIR <- getwd()

```

## 3. Data Comparison
We compare the data for each database to the secondary HGNC symbols.

```{r}
plot(cars)
```

## 4. Data Visualization
We visualize the data for all databases combined.

```{r}
plot(cars)
```

+
---
title: "Secondary HGNC Symbols used in different Databases"
output: html_notebook
---

This is an [R Markdown](http://rmarkdown.rstudio.com) Notebook. When you execute code within the notebook, the results appear beneath the code. 

This script compares gene symbol names from four different databases (KEGG, Reactome, WikiPathways, Gene Ontology) to the list of outdated HGNC symbols.

## 0. Notebook setup
The first section of this Notebook lists all the libraries required to run this script.

```{r}
#Package manager:
if(!requireNamespace("BiocManager", quietly = TRUE)) install.packages("BiocManager",repos = "http://cran.us.r-project.org")
#Package for path variable
if(!"rstudioapi" %in% installed.packages()) BiocManager::install("rstudioapi")
#Libraries required for markdown documents:
if(!"markdown" %in% installed.packages()){install.packages("markdown")}
if(!"rmarkdown" %in% installed.packages()){install.packages("rmarkdown")}
if(!"dplyr" %in% installed.packages()){install.packages("dplyr")}

#load libraries
library(rstudioapi)
library(dplyr)
library(tidyr)

# set working environment to current folder
workingDirectory <- setwd(dirname(rstudioapi::getSourceEditorContext()$path))
```

## 1. HGNC Symbol data download
First, we load all the primary and secondary symbols of HGNC to be used in this comparison (based on data release in Zenodo).
We filter out the symbols which are used as both primary and secondary symbols (which could lead to false positive results).

```{r, include=FALSE}
if(!file.exists("HGNC_secID2priID.tsv")){
  #download.file('https://reactome.org/download/current/UniProt2Reactome_PE_Pathway.txt', destfile=paste0(workingDirectory, '/dataInput/UniProt2Reactome.txt'), method = "wget", extra = "-r -p --random-wait") ##Replace with Zenodo download when available!
}

HGNCMappings <- EnsemblReactome <- read.delim(paste0(workingDirectory, '/dataInput/HGNC_secID2priID.tsv'), header = TRUE, sep = "\t", dec = ".") #Create dataframe from HGNC Symbols data
##Create unique set of primary IDs (without overlap to secondaries)
primaryHGNCSymbols <- setdiff(HGNCMappings$primarySymbol, HGNCMappings$secondarySymbol)

##Create unique set of secondary IDs (without overlap to primaries)
secondaryHGNCSymbols <- setdiff(HGNCMappings$secondarySymbol, HGNCMappings$primarySymbol)
```

## 2. Data Download
We download the data for each database, based on their API, RDF, or other data download option (depending on availability).

### 2.1. KEGG
The information in KEGG was obtained using an API call.
```{r, include=FALSE}
##Install and load required packages:
api_packages <- c("httr", "jsonlite", "data.table")
for (i in 1:length(api_packages)) {
if(!api_packages[i] %in% installed.packages()){install.packages(api_packages[i])}
}
#install.packages(c("httr", "jsonlite", "data.table"))
library(httr)
library(jsonlite)
library(data.table)

## Get all pathway map IDs first:
kegg_maps_APIcall <- "https://rest.kegg.jp/list/pathway/hsa"
res_maps = GET(kegg_maps_APIcall)
Kegg_data_maps <- rawToChar(res_maps$content)
Kegg_maps_total = data.frame()
if(length(res_maps$content)>1){
  cleaned_Kegg_data_maps <- fread(text = Kegg_data_maps, header=FALSE, fill = TRUE, sep = '\t')
  df_maps <- data.frame(cleaned_Kegg_data_maps)
  Kegg_maps_total <- rbind(Kegg_maps_total,df_maps)
  }

##Convert KEGG maps results to new API call to retrieve all genes within each map:
kegg_maps <- Kegg_maps_total$V1
##Add URL for query item:
kegg_genes_APIcall <- paste("https://rest.kegg.jp/link/hsa/", kegg_maps, sep="")

##Create an empty dataframe to store the results of the loop:
Kegg_genes_total = data.frame()

## Execute API calls, example to obtain chemical compounds for a PW map:
for (i in 1:length(nrow(Kegg_maps_total[1]))) {
  ##Get the genes:
  res_genes = GET(kegg_genes_APIcall[i])
  Kegg_data_genes <- rawToChar(res_genes$content)
  if(length(res_genes$content)>1){
  cleaned_Kegg_data_genes <- fread(text = Kegg_data_genes, header=FALSE, fill = TRUE)
  df_genes <- data.frame(cleaned_Kegg_data_genes)
  Kegg_genes_total <- rbind(Kegg_genes_total,df_genes)
  }
}

##Keep only dataframes with name "_total" to save space
#rm(list = ls()[!grepl("_total", ls())])
retain = c("primaryHGNCSymbols", "secondaryHGNCSymbols", "workingDirectory", "retain")
rm(list=setdiff(ls(), retain))
```
Unfortunately, the KEGG database does not allow to retrieve the labels within the pathway images, so we cannot use it further in our comparison.

### 2.2. Reactome
For the Reactome content, we download the Physical Entity (PE) Identifier mapping files. Since the HGNC symbols are not available as a direct mapping, we retrieve all mappings from UniProt, Ensembl, and NCBI, to integrate their content on HGNC symbols.
```{r, include=FALSE}
##Only download the data, if not available already locally.
##UniProt mappings
if(!file.exists("dataInput/UniProt2Reactome.txt")){
  download.file('https://reactome.org/download/current/UniProt2Reactome_PE_Pathway.txt', destfile=paste0(workingDirectory, '/dataInput/UniProt2Reactome.txt'), method = "wget", extra = "-r -p --random-wait")
}
##Ensembl mappings
if(!file.exists("dataInput/Ensembl2Reactome.txt")) {
  download.file('https://reactome.org/download/current/Ensembl2Reactome_PE_Pathway.txt', destfile=paste0(workingDirectory, '/dataInput/Ensembl2Reactome.txt'), method = "wget", extra = "-r -p --random-wait")
}
##NCBI mappings
if(!file.exists("dataInput/NCBI2Reactome.txt")) {
  download.file('https://reactome.org/download/current/NCBI2Reactome_PE_Pathway.txt', destfile=paste0(workingDirectory, '/dataInput/NCBI2Reactome.txt'), method = "wget", extra = "-r -p --random-wait")
}

##Store the data in a dataframe, extract the relevant information, and merge results from three mapping systems (if needed):
#Uniprot mappings
UniprotReactome <- read.delim(paste0(workingDirectory, '/dataInput/UniProt2Reactome.txt'), header = FALSE, sep = "\t", dec = ".") #Create dataframe from input data
UniprotReactome <- UniprotReactome[UniprotReactome[8] == 'Homo sapiens',] #Only keep data for one species (Homo sapiens)
UniprotReactome <- UniprotReactome[c(3)] #Retain column with HGNC Symbols
UniprotReactome <- separate(UniprotReactome, V3, into = c("HGNC", "Location"), sep = " (?=(\\[[^\\]]*\\])+$)") ##Split localization data from HGNC symbol
UniprotReactome <- UniprotReactome[c(1)] #remove localization data
UniprotReactome <- unique(UniprotReactome) #Keep unique symbols only 
#Ensembl mappings
EnsemblReactome <- read.delim(paste0(workingDirectory, '/dataInput/Ensembl2Reactome.txt'), header = FALSE, sep = "\t", dec = ".") #Create dataframe from input data
EnsemblReactome <- EnsemblReactome[EnsemblReactome[8] == 'Homo sapiens',] #Only keep data for one species (Homo sapiens)
EnsemblReactome <- EnsemblReactome[c(3)] #Retain column with HGNC Symbols
EnsemblReactome <- separate(EnsemblReactome, V3, into = c("HGNC", "Location"), sep = " (?=(\\[[^\\]]*\\])+$)") ##Split localization data from HGNC symbol
EnsemblReactome <- EnsemblReactome[c(1)] #remove localization data
EnsemblReactome <- unique(EnsemblReactome) #Keep unique symbols only 
#NCBI mappings
NCBIReactome <- read.delim(paste0(workingDirectory, '/dataInput/NCBI2Reactome.txt'), header = FALSE, sep = "\t", dec = ".") #Create dataframe from input data
NCBIReactome <- NCBIReactome[NCBIReactome[8] == 'Homo sapiens',] #Only keep data for one species (Homo sapiens)
NCBIReactome <- NCBIReactome[c(3)] #Retain column with HGNC Symbols
NCBIReactome <- separate(NCBIReactome, V3, into = c("HGNC", "Location"), sep = " (?=(\\[[^\\]]*\\])+$)") ##Split localization data from HGNC symbol
NCBIReactome <- NCBIReactome[c(1)] #remove localization data
NCBIReactome <- unique(NCBIReactome) #Keep unique symbols only 

#Merge the data together
df_list <- list(UniprotReactome, EnsemblReactome, NCBIReactome)
mergedReactome <- Reduce(function(x, y) merge(x, y, all=TRUE), df_list, accumulate=FALSE)
#mergedReactome <- unique(mergedReactome) #Keep unique symbols only (to check if above function worked correctly)

#Remove unnecessary data
retain <- append(retain, "mergedReactome")
rm(list=setdiff(ls(), retain))
```

Compare the Reactome data against primary symbols first, then against secondary symbols, last count how many were not matching at all.
```{r}
##Check overlap between prim and sec:
uniqueSec <-  setdiff(secondaryHGNCSymbols, primaryHGNCSymbols)

##Convert reactome data to vector format:
mergedReactomeVector <- mergedReactome[['HGNC']]
##Check primary symbols:
primaryMatchesReactome <- intersect(primaryHGNCSymbols, mergedReactomeVector)
##Amount:
amountPrimaryMatchesReactome <- length(primaryMatchesReactome)
##Check secondary symbols:
secondaryMatchesReactome <- intersect(uniqueSec, mergedReactomeVector)
##Amount:
amountSecondaryMatchesReactome <- length(secondaryMatchesReactome)
```


### 2.3. WikiPathways
The WikiPathways data was queried in the RDF format.
```{r, include=FALSE}
##WikiPathways (original pathways)

###PRIOR code to install SPARQl package; Package not available in CRAN anymore, only works for older version of R
#if(!"SPARQL" %in% installed.packages()){
#  install.packages("SPARQL")
#}

##Solution: download from archived version
#Location to install archived packages:
packageFolder <-paste0(workingDirectory, '/packages/SPARQL.tar.gz')
downloadLinkSPARQL <-"https://cran.r-project.org/src/contrib/Archive/SPARQL/SPARQL_1.16.tar.gz"

##Download archived version instead:
if(!"downloader" %in% installed.packages()){
  install.packages("downloader")
}
library("downloader")

##Only download file if needed
if (!file.exists(packageFolder)) {
  download.file(downloadLinkSPARQL, packageFolder)
}

##Install the local version of the library
install.packages(packageFolder, repos = NULL, type="source")

library(SPARQL)
##Connect to Endpoint WikiPathways
endpointwp <- "https://sparql.wikipathways.org/sparql"

## 1. Query metadata:
queryMetadata <-
"SELECT DISTINCT ?dataset (str(?titleLit) as ?title) ?date ?license 
WHERE {
   ?dataset a void:Dataset ;
   dcterms:title ?titleLit ;
   dcterms:license ?license ;
   pav:createdOn ?date .
 }"
 #below code should be performed first to handle the ssl certificate error
options(RCurlOptions = list(cainfo = paste0( tempdir() , "/cacert.pem" ), ssl.verifypeer = FALSE))
resultsMetadata <- SPARQL(endpointwp,queryMetadata,curl_args=list(useragent=R.version.string))
showresultsMetadata <- resultsMetadata$results
remove(queryMetadata, resultsMetadata)

## 2. Query WikiPathways PWs, HGNC symbols used in Labels:

## 3. Query WikiPathways PWs, HGNC symbol used in original annotations:

## 4. Query WikiPathways PWs, HGNC symbol Mappings:
queryWikiPathways <-
"PREFIX cur:            <http://vocabularies.wikipathways.org/wp#Curation:> #to differentiate between Reactome and WP PWs.

select distinct (fn:substring(?hgncId,37) as ?HGNC) (GROUP_CONCAT(DISTINCT str(?wpid);separator=', ') AS ?pathways)  (COUNT(DISTINCT str(?wpid)) AS ?usage)
where {
  ?pathwayRes a wp:Pathway ;                   #Define what is a pathway
              wp:organismName 'Homo sapiens' ; #Filter pathways on species Human
              dcterms:identifier ?wpid ;       #Obtain identifier of pathway
              wp:ontologyTag cur:AnalysisCollection .  #Reactome: Reactome_Approved . WP: Curation:AnalysisCollection
  
  ?protein wp:bdbHgncSymbol ?hgncId ;          #Find proteins based on HGNC symbol
           dcterms:isPartOf ?pathwayRes .      #Connect protein to PW
}
ORDER BY DESC (?usage)
"
##Execute query:
resultsWikiPathways <- SPARQL(endpointwp,queryWikiPathways,curl_args=list(useragent=R.version.string))
showresultsWikiPathways <- resultsWikiPathways$results
remove(queryWikiPathways, resultsWikiPathways)
```

Compare the WikiPathways data against primary symbols first, then against secondary symbols, last count how many were not matching at all.
```{r}
##Check overlap between prim and sec:
uniqueSec <-  setdiff(secondaryHGNCSymbols, primaryHGNCSymbols)

##Convert reactome data to vector format:
mergedWikiPathwaysVector <- showresultsWikiPathways[['HGNC']]
##Check primary symbols:
primaryMatchesWikiPathways <- intersect(primaryHGNCSymbols, mergedWikiPathwaysVector)
##Amount:
amountPrimaryMatchesWikiPathways <- length(primaryMatchesWikiPathways)
##Check secondary symbols:
secondaryMatchesWikiPathways <- intersect(uniqueSec, mergedWikiPathwaysVector)
##Amount:
amountSecondaryMatchesWikiPathways <- length(secondaryMatchesWikiPathways)
```



### 2.4. BiGG data Models
```{r, include=FALSE}
##Install and load required packages:
api_packages <- c("httr", "jsonlite", "data.table")
for (i in 1:length(api_packages)) {
if(!api_packages[i] %in% installed.packages()){install.packages(api_packages[i])}
}
#install.packages(c("httr", "jsonlite", "data.table"))
library(httr)
library(jsonlite)
library(data.table)

biggModelsAPIcall <- 'http://bigg.ucsd.edu/api/v2/models'
biggModels_maps = GET(biggModelsAPIcall)
biggModels_data_maps <- rawToChar(biggModels_maps$content)
biggModels_maps_total = data.frame()
if(length(biggModels_maps$content)>1){
  cleaned_biggModels_data_maps <- fread(text = biggModels_data_maps, header=FALSE, fill = TRUE, sep = '\t')
  df_maps <- data.frame(cleaned_biggModels_data_maps)
  biggModels_maps_total <- rbind(biggModels_maps_total,df_maps)
  }

```


### 2.5. Gene Ontology
From the Quick-GO website (https://www.ebi.ac.uk/QuickGO/), we downloaded data based on the following criteria: --> Use API instead!
I. Taxon: 9606 (Homo sapiens, human).

Data was downloaded on: Nov. 6 (2023), with 1,685,892 annotations, as a TSV file.
```{r, include=FALSE}
GO_fileLocation <- paste0(workingDirectory, '/DataInput/... .tsv')
##GO terms
go_terms <- read.delim(file = "DataInput/QuickGO-annotations-1659356807403-20220801.tsv", header = TRUE, sep = '\t')
go_terms_unique <- unique(go_terms$SYMBOL)

# Set Working Directory back to current folder
setwd(dirname(rstudioapi::getSourceEditorContext()$path))
work_DIR <- getwd()

```

## 3. Data Comparison
We compare the data for each database to the secondary HGNC symbols.
```{r}
plot(cars)
```

## 4. Data Visualization
We visualize the data for all databases combined.
```{r}
plot(cars)
```
