61:         path <- self$getEntry(path.id)

59:     for (path.id in id) {

127:     for (path.id in id) {

304:     path_idx <- sub('^[^0-9]+', '', id)

322:     path_idx <- sub('^[^0-9]+', '', id)

29: KeggPathwayConn <- R6::R6Class("KeggPathwayConn",

40:     super$initialize(db.name='pathway', db.abbrev='path', ...)

62:         if ( ! is.null(path) && path$hasField('kegg.module.id')) {

65:             for (mod.id in path$getFieldValue('kegg.module.id')) {

144:             graph[[path.id]]=list(vertices=vert, edges=edg)

147:             graph[[path.id]]=NULL

309:         params=c(org_name='map', mapno=path_idx,

325:     img_filename <- paste0('pathwaymap-', path_idx)

331:             biodb::error0('Impossible to find pathway image path inside',

335:         tmp_file <- file.path(cache$getTmpFolderPath(),

2: #' The connector class to KEGG Pathway database.

16: #' conn=mybiodb$getFactory()$createConn('kegg.pathway')

18: #' # Retrieve all reactions related to a mouse pathway:

21: #' # Get a pathway graph

44: #' Retrieves all reactions part of a KEGG pathway. Connects to

45: #'     KEGG databases, and walk through all pathways submitted, and

58:     # Loop on all Pathway IDs

89: #' Takes a list of pathways IDs and converts them to the specified organism,

92: #' @param org The organism in which to search for pathways, as a KEGG organism

113: #' Builds a pathway graph in the form of two tables of vertices and edges,

115: #' @param id A character vector of KEGG pathway entry IDs.

120: #' @return A named list whose names are the pathway IDs, and values are lists

126:     # Loop on all pathway IDs

158: #' Builds a pathway graph, as an igraph object, using KEGG database.

159: #' @param id A character vector of KEGG pathway entry IDs.

196: #' Create a pathway graph picture, with some of its elements colorized.

197: #' @param id A KEGG pathway ID.

227: #' Extracts shapes from a pathway map image.

228: #' @param id A KEGG pathway ID.

303:     # Extract pathway number

308:         'show_pathway'),

329:             'src="([^"]+)"(\\s+.*)?\\s+(name|id)="pathwayimage"')

332:                 ' HTML page for pathway ID ', id, '.')

342:     img_file <- cache$getFilePath(cid, img_filename, 'png')

22: #' graph=conn$buildPathwayGraph('mmu00260')

98: convertToOrgPathways=function(id, org) {

122: buildPathwayGraph=function(id, directed=FALSE, drop=TRUE) {

166: getPathwayIgraph=function(id, directed=FALSE, drop=TRUE) {

173:         g <- self$buildPathwayGraph(id=id, directed=directed, drop=FALSE)

210:         pix <- private$getPathwayImage(id)

213:         shapes <- self$extractPathwayMapShapes(id=id, color2ids=color2ids)

233: ,extractPathwayMapShapes=function(id, color2ids) {

237:     html <- private$getPathwayHtml(id)

301: ,getPathwayHtml=function(id) {

319: getPathwayImage=function(id) {

321:     html <- private$getPathwayHtml(id)

353:   path <- merge(merge1, symb, by = "gene")

66:     pathTable <- unique(keggPathwayDB(org_assembly))

72:     pathfreq <- as.data.frame(table(annot$pathway))

100:     pathT <- as.character(freq$Var1[enrich])

119:     pathways <- data.frame(unique(pathT))

205:     pathTable <- unique(reactomePathwayDB(org_assembly))

211:     pathfreq <- as.data.frame(table(annot$pathway))

237:     pathT <- as.character(freq$Var1[enrich])

542:   pathTable <- unique(WikiPathwayDB(org_assembly))

547:   pathfreq <- as.data.frame(table(annot$pathID))

573:   pathT <- as.character(freq$Var1[enrich])

580:   pathTerms <- as.character(r$pathTerm[match(pathT, r$pathID)])

630: pathwayEnrichment <- function(genes,

679:   pathfreq <- as.data.frame(table(annot$pathTerm))

711:   pathT <- as.character(freq$Var1[enrich])

719:   pathTerms <- as.character(r$pathTerm[match(pathT, r$pathID)])

272: reactomePathwayDB <- function(org_assembly = c("hg19",

359: keggPathwayDB <- function(org_assembly = c("hg19",

435: WikiPathwayDB <- function(org_assembly = c("hg19",

15: #' @param gmtFile File path of the gmt file

92:         file.path(x[1], x[2]))

96:         file.path(x[1], x[2]))

156: #' @param gmtFile File path of the gmt file

230:       file.path(x[1], x[2]))

233:       file.path(x[1], x[2]))

355:   return(path)

501: #' @param gmtFile File path of the gmt file

565:       file.path(x[1], x[2]))

569:       file.path(x[1], x[2]))

610: #' @param gmtFile File path of the gmt file

704:     file.path(x[1], x[2]))

707:     file.path(x[1], x[2]))

1: #' KEGG pathway enrichment

22: #' @return KEGG pathway enrichment results

69:     annot <- pathTable[which(pathTable$symbol %in% genes$g),]

73:     pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

76:     geneSize = length(unique(pathTable$symbol))

78:     bckfreq <- as.data.frame(table(pathTable$pathway))

79:     notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

80:     freq <- merge(pathfreq, notGene, by = "Var1")

105:     r <- annot[annot$pathway %in% pathT,]

107:     for (i in seq_along(pathT))

109:       if (length(which(pathT[i] == r$pathway)) > 0)

114:               as.character(r[which(pathT[i] == r$pathway),]$symbol)),

115:                      paste(pathT[i])))

120:     tmp <- character(length(pathT))

121:     if (nrow(pathways) > 0) {

123:         unlist(lapply(seq_len(nrow(pathways)), function(x)

124:           tmp[x] <- try(KEGGREST::keggGet(pathT[x])[[1]]$NAME)

130:         ID = pathT,

142: #' Reactome pathway enrichment

164: #' @return Reactome pathway enrichment results

208:     annot <- pathTable[which(pathTable$symbol %in% genes$g),]

212:     pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

214:     geneSize = length(unique(pathTable$symbol))

216:     bckfreq <- as.data.frame(table(pathTable$pathway))

217:     notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

218:     freq <- merge(pathfreq, notGene, by = "Var1")

242:     r <- annot[annot$pathway %in% pathT,]

246:     for (i in seq_along(pathT))

248:       if (length(which(pathT[i] == r$pathway)) > 0)

253:               list(as.character(r[which(pathT[i] == r$pathway),]$symbol)),

254:                      paste(pathT[i])))

260:         ID = pathT,

261:         Term = as.character(rt[order(match(rt$pathway, pathT)), ]$name),

281:   table1 <- data.frame(pathway = rep(names(xx), lapply(xx, length)),

284:   pn <- data.frame(pathway = rep(names(pn), lapply(pn, length)),

290:     ty <- table1[grepl("^R-HSA", table1$pathway),]

291:     pn1 <- pn[grepl("^R-HSA", pn$pathway),]

298:     ty <- table1[grepl("^R-MMU", table1$pathway),]

299:     pn1 <- pn[grepl("^R-MMU", pn$pathway),]

306:     ty <- table1[grepl("^R-DRE", table1$pathway),]

307:     pn1 <- pn[grepl("^R-DRE", pn$pathway),]

314:     ty <- table1[grepl("^R-RNO", table1$pathway),]

315:     pn1 <- pn[grepl("^R-RNO", pn$pathway),]

322:     ty <- table1[grepl("^R-CEL", table1$pathway),]

323:     pn1 <- pn[grepl("^R-CEL", pn$pathway),]

330:     ty <- table1[grepl("^R-SCE", table1$pathway),]

331:     pn1 <- pn[grepl("^R-SCE", pn$pathway),]

344:     ty <- table1[grepl("^R-DME", table1$pathway),]

345:     pn1 <- pn[grepl("^R-DME", pn$pathway),]

351:                   by = "pathway",

371:     kegg <- org.Hs.eg.db::org.Hs.egPATH2EG

379:     kegg <- org.Mm.eg.db::org.Mm.egPATH2EG

387:     kegg <- org.Dr.eg.db::org.Dr.egPATH2EG

395:     kegg <- org.Rn.eg.db::org.Rn.egPATH2EG

403:     kegg <- org.Ce.eg.db::org.Ce.egPATH2EG

411:     kegg <- org.Sc.sgd.db::org.Sc.sgdPATH2ORF

419:     kegg <- org.Dm.eg.db::org.Dm.egPATH2EG

425:   pathTable <-

426:     data.frame(pathway = paste0(prefix, rep(names(kegg2),

431:   pathTable <- merge(pathTable, x, by = "gene")

432:   return(pathTable)

474:     do.call(rbind, strsplit(as.character(gmtFile$pathTerm), '%'))

480:         pathID = tmp[, 3],

481:         pathTerm = tmp[, 1]

508: #' @return Wiki Pathway Enrichment

545:   annot <- pathTable[which(pathTable$gene %in% genes$g),]

548:   pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

550:   geneSize = length(unique(pathTable$gene))

551:   bckfreq <- as.data.frame(table(pathTable$pathID))

552:   notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

553:   freq <- merge(pathfreq, notGene, by = "Var1")

578:   r <- annot[annot$pathID %in% pathT,]

581:   for (i in seq_along(pathT))

583:     if (length(which(pathT[i] == r$pathID)) > 0)

587:           list(as.character(r[which(pathT[i] == r$pathID),]$gene)),

588:                           paste(pathT[i])))

595:       ID = pathT,

596:       Term = pathTerms,

606: #' For a given gmt file of a specific pathway database, pathway enrichment

628: #' @return Pathway Enrichment

671:     pathTable <-

676:     pathTable <- geneListEnrich(f = gmtFile, isSymbol = isSymbol)

678:   annot <- pathTable[which(pathTable$symbol %in% genes$g),]

680:   pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

684:     geneSize = length(unique(pathTable$symbol))

689:   bckfreq <- as.data.frame(table(pathTable$pathTerm))

691:   notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

692:   freq <- merge(pathfreq, notGene, by = "Var1")

717:   r <- annot[annot$pathTerm %in% pathT,]

721:   for (i in seq_along(pathT))

723:     if (length(which(pathT[i] == r$pathTerm)) > 0)

726:           list(as.character(r[which(pathT[i] == r$pathTerm),]$symbol)),

727:                           paste(pathT[i])))

732:       ID = pathT,

733:       Term = pathTerms,

743: #' Convert gmt formatted pathway file to the Pathway ID, Entrez, symbol

746: #' @param gmtName Custom pathway gmt file

815:     colnames(f) <- c('pathTerm', 'Entrez', 'symbol')

830:     colnames(f) <- c('pathTerm', 'symbol', 'Entrez')

852:     colnames(f) <- c('pathTerm', 'Entrez', 'symbol')

863:     colnames(f) <- c('pathTerm', 'symbol', 'Entrez')

280:   xx <- as.list(reactome.db::reactomePATHID2EXTID)

283:   pn <- as.list(reactome.db::reactomePATHID2NAME)

445:       rWikiPathways::downloadPathwayArchive(organism = "Homo sapiens",

449:       rWikiPathways::downloadPathwayArchive(organism = "Mus musculus",

453:       rWikiPathways::downloadPathwayArchive(organism = "Danio rerio",

457:       rWikiPathways::downloadPathwayArchive(organism = "Rattus norvegicus",

461:       rWikiPathways::downloadPathwayArchive(

465:       rWikiPathways::downloadPathwayArchive(

469:       rWikiPathways::downloadPathwayArchive(

487: #' WikiPathways Enrichment

928:    path <-paste(system.file(package="seq2pathway"),

856: get_python3_command_path <- function()

859:   python3_command_path <- Sys.which2("python")

1029:     script_path <- file.path(tempdir(), name)

275: pathwaygene<-length(intersect(toupper(gene_list[[i]]),

484: pathwaygene<-length(intersect(toupper(gsmap$genesets[[i]]),

843:   cmdpath <- Sys.which(cmdname)

1051: runseq2pathway<-function(inputfile,

1161: gene2pathway_result<-list()

1310: gene2pathway_test<-function(dat,DataBase="GOterm",FisherTest=TRUE,

1344: gene2pathway_result<-list()

854: #get_python3_command_path: funtion from Herve Pages, Bioconductor Maintainance Team, Oct 9 2020

858: #  python3_command_path <- Sys.which2("python3") #3/3/2021 by Holly

860:   if (python3_command_path != "")

864:           return(python3_command_path)}

873: #  python3_command_path <- Sys.which2("python")

874:   python3_command_path <- Sys.which2("python3")  #3/3/2021 by Holly

875:   if (python3_command_path != ""){

876:     print(paste0("python3 found: ",python3_command_path))

877:     return(python3_command_path)}

880:        "  'python3' (or 'python') executable is in your PATH.")

924:     ### assign the path of main function

932:     path <-paste(system.file(package="seq2pathway"),

976: 		sink(file.path(tempdir(),name,fsep = .Platform$file.sep))} 

994:     cat("'", path, "').load_module()",sep="")

1030:     if (!file.exists(script_path))

1032:     mypython <- get_python3_command_path()

1034:     response <- system2(mypython, args=script_path,

75: data(gencode_coding,package="seq2pathway.data")

155: data(gencode_coding,package="seq2pathway.data")

214: ####load GP pathway information

216:    data(GO_BP_list,package="seq2pathway.data")

217:    data(GO_MF_list,package="seq2pathway.data")

218:    data(GO_CC_list,package="seq2pathway.data") 

219:    data(Des_BP_list,package="seq2pathway.data")

220:    data(Des_MF_list,package="seq2pathway.data")

221:    data(Des_CC_list,package="seq2pathway.data")

223:          data(GO_BP_list,package="seq2pathway.data") 

224:          data(Des_BP_list,package="seq2pathway.data")

226:               data(GO_MF_list,package="seq2pathway.data") 

227:               data(Des_MF_list,package="seq2pathway.data")

229:                   data(GO_CC_list,package="seq2pathway.data")

230:                   data(Des_CC_list,package="seq2pathway.data")

237: data(GO_GENCODE_df_hg_v36,package="seq2pathway.data")

240: data(GO_GENCODE_df_hg_v19,package="seq2pathway.data")

243: data(GO_GENCODE_df_mm_vM25,package="seq2pathway.data")

246: data(GO_GENCODE_df_mm_vM1,package="seq2pathway.data")

280: c<-pathwaygene-a

289: mdat[i,7]<-pathwaygene

321: pathwaygene<-length(intersect(toupper(GO_BP_list[[i]]),

326: c<-pathwaygene-a

335: mdat[i,7]<-pathwaygene

367: pathwaygene<-length(intersect(toupper(GO_CC_list[[i]]),

372: c<-pathwaygene-a

381: mdat[i,7]<-pathwaygene

413: pathwaygene<-length(intersect(toupper(GO_MF_list[[i]]),

418: c<-pathwaygene-a

427: mdat[i,7]<-pathwaygene

455: data(Msig_GENCODE_df_hg_v36,package="seq2pathway.data")

458: data(Msig_GENCODE_df_hg_v19,package="seq2pathway.data")

461: data(Msig_GENCODE_df_mm_vM25,package="seq2pathway.data")

464: data(Msig_GENCODE_df_mm_vM1,package="seq2pathway.data")

489: c<-pathwaygene-a

498: mdat[i,7]<-pathwaygene

549: data(gencode_coding,package="seq2pathway.data")

647: rungene2pathway <-

704: colnames(res) <- c(paste(colnames(dat),"2pathscore",sep=""))

705: print("gene2pathway calculates score....... done")

711: rungene2pathway_EmpiricalP <-

770: colnames(res) <- c(paste(colnames(dat),"2pathscore",sep=""))

829: colnames(res_p) <- c(paste(colnames(dat),"2pathscore_Pvalue",sep=""))

832: print("pathwayscore Empirical Pvalue calculation..........done")

849:   success <- grepl(pattern1, cmdpath, fixed=TRUE) ||

850:     grepl(pattern2, cmdpath, fixed=TRUE)

851:   if (success) cmdpath else ""

1007:     #cat(paste("inputpath=","'",inputpath,"/'",sep=""),sep="\n")

1009:     #cat(paste("outputpath=","'",outputpath,"/'",sep=""),sep="\n")

1018:     cat(paste("pwd=","'",system.file(package="seq2pathway.data"),"/extdata/'",sep=""),sep="\n")

1103: data(GO_BP_list,package="seq2pathway.data")

1104: data(GO_MF_list,package="seq2pathway.data")

1105: data(GO_CC_list,package="seq2pathway.data")

1106: data(Des_BP_list,package="seq2pathway.data")

1107: data(Des_CC_list,package="seq2pathway.data")

1108: data(Des_MF_list,package="seq2pathway.data")

1134: #############################rungene2pathway,normalization,empiricalP,summary table

1166: GO_BP_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_BP_list,alpha=alpha,logCheck=logCheck,

1171: GO_BP_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_BP_list,

1174: ########gene2pathway table

1190: gene2pathway_result[[n.list]]<-GO_BP_N_P

1191: names(gene2pathway_result)[n.list]<-c("GO_BP")

1195: GO_MF_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_MF_list,alpha=alpha,logCheck=logCheck,

1198: GO_MF_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_MF_list,

1215: gene2pathway_result[[n.list]]<-GO_MF_N_P

1216: names(gene2pathway_result)[n.list]<-c("GO_MF")

1220: GO_CC_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_CC_list,alpha=alpha,logCheck=logCheck,

1223: GO_CC_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_CC_list,

1241: gene2pathway_result[[n.list]]<-GO_CC_N_P

1242: names(gene2pathway_result)[n.list]<-c("GO_CC")

1245: dat_FAIME<-rungene2pathway(dat=dat_CP,gsmap=DataBase,alpha=alpha,logCheck=logCheck,

1248: dat_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=DataBase,

1255: colnames(DB_N_P)<-c("score2pathscore_Normalized","score2pathscore_Pvalue")

1274: gene2pathway_result<-DB_N_P[,c(ncol(DB_N_P),1:(ncol(DB_N_P)-1))]

1276: print("gene2pathway analysis is done")

1279: if(exists("gene2pathway_result")&exists("FS_test")){

1283: TotalResult[[2]]<-gene2pathway_result

1284: names(TotalResult)[2]<-"gene2pathway_result.FAIME"

1286: names(TotalResult)[3]<-"gene2pathway_result.FET"

1289: }else if(exists("gene2pathway_result")&exists("FS_test")==FALSE){

1293: TotalResult[[2]]<-gene2pathway_result

1294: names(TotalResult)[2]<-"gene2pathway_result.FAIME"

1298: else if(exists("gene2pathway_result")==FALSE&exists("FS_test")){

1303: names(TotalResult)[2]<-"gene2pathway_result.FET"

1326: data(GO_BP_list,package="seq2pathway.data")

1327: data(GO_MF_list,package="seq2pathway.data")

1328: data(GO_CC_list,package="seq2pathway.data")

1329: data(Des_BP_list,package="seq2pathway.data")

1330: data(Des_CC_list,package="seq2pathway.data")

1331: data(Des_MF_list,package="seq2pathway.data")

1346: #############################rungene2pathway,normalization,empiricalP,summary table

1348: gene2pathway_result<-list()

1352:   GO_BP_method<-rungene2pathway(dat=dat,gsmap=GO_BP_list,alpha=alpha,logCheck=logCheck,

1358:     GO_BP_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_BP_list,alpha=alpha,

1364:   ########gene2pathway table

1376:   gene2pathway_result[[n.list]]<-GO_BP_N_P

1377:   names(gene2pathway_result)[n.list]<-c("GO_BP")

1380:     GO_MF_method<-rungene2pathway(dat=dat,gsmap=GO_MF_list,alpha=alpha,logCheck=logCheck,

1384:       GO_MF_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_MF_list,alpha=alpha,

1402:   gene2pathway_result[[n.list]]<-GO_MF_N_P

1403:   names(gene2pathway_result)[n.list]<-c("GO_MF")

1406:    GO_CC_method<-rungene2pathway(dat=dat,gsmap=GO_CC_list,alpha=alpha,logCheck=logCheck,

1410:       GO_CC_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_CC_list,alpha=alpha,

1427:   gene2pathway_result[[n.list]]<-GO_CC_N_P

1428:   names(gene2pathway_result)[n.list]<-c("GO_CC")

1431: dat_method<-rungene2pathway(dat=dat,gsmap=DataBase,alpha=alpha,logCheck=logCheck,

1435: dat_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=DataBase,alpha=alpha,

1443: colnames(DB_N_P)<-c("score2pathscore_Normalized","score2pathscore_Pvalue")

1464: gene2pathway_result<-DB_N_P[,c(ncol(DB_N_P),1:(ncol(DB_N_P)-1))]

1466: print("gene2pathway analysis is done")

1470: if(exists("gene2pathway_result")&exists("FS_test")){

1472: TResult[[1]]<-gene2pathway_result

1473: names(TResult)[1]<-"gene2pathway_result.2"

1475: names(TResult)[2]<-"gene2pathway_result.FET"

1476: }else if(exists("gene2pathway_result")&exists("FS_test")==FALSE){

1477: TResult<-gene2pathway_result

1479: else if(exists("gene2pathway_result")==FALSE&exists("FS_test")){

101:         path <- paste(dir, file, sep='//')

34:         paths <- list.files(xmlDir) 

83: pathwayToGraph <- function (i, ...)

3: createPathwayGraphs <- function(org, pathways, edgeTypes, doubleEdges, choice,

141: getPathwayType                    <- function(filepath, file)

159: metabolicPathwayToGraph           <- function(filepath)

347: nonMetabolicPathwayToGraph <- function(filepath, doubleEdges, groupMode)

102:         gr   <- metabolicPathwayToGraph(path)

119:         path <- paste(dir, file, sep='//')

120:         gr   <- nonMetabolicPathwayToGraph(path, doubleEdges, groupMode)

225: removeCompoundsMetabolicGraph     <- function(path)

228:     if(path$name != gsub('ec','',path$name)) { nodeType<-"enzyme" }

229:     enzymes  <- which(path$vertices$type == nodeType)

230:     vid      <- path$vertices$id

233:     if ( length(path$edges) > 0 )

243:             for (r1 in path$edges[path$edges$e1 == 

244:                                 path$vertices[,'id'][enzymes[j]],]$e2)  

247:                 for (r2 in path$edges[path$edges$e1 == 

248:                                 path$vertices[,'id'][which(vid == r1)],]$e2)

252:                     nid <- vid[which(path$vertices$id == r2)]

267:     xid    <- path$vertices$id[enzymes]

268:     names  <- path$vertices$names[enzymes]       

513: removeCompoundsNonMetabolicGraph <- function(path, unique, edgeTypes)

515:     if (is.null(path)) return(NULL)

516:     vid      <- as.numeric(path$vertices$id)

517:     etype    <- path$vertices$type

519:     if(path$name != gsub('ko','',path$name)) { nodeType <- "ortholog" }

522:     genesIndx <- which(path$vertices$type == nodeType)

528:         neighbors <- path$edges$e2[path$edges$e1 == vid[gi]]

546:                 idx1 <- which( path$edges$e1 == vid[gi] )

547:                 idx2 <- which( path$edges$e2 == vid[nbrId] )

549:                 TT   <- c( TT, paste((path$edges$type[idx]), collapse='_') )

557:                 cpdNeighbors <- path$edges$e2[ 

558:                                         which(path$edges$e1 == vid[nbrId]) ]

586:         names            <- unique(path$vertices$names[genesIndx])

598:             idx1 <- which(path$vertices$id == source[i])

599:             idx2 <- which(path$vertices$id == destin[i])

600:             source[i] <- names[ names == path$vertices$names[idx1] ]

601:             destin[i] <- names[ names == path$vertices$names[idx2] ]

623:         gids                <- path$vertices$id[genesIndx]

624:         names               <- unname(path$vertices$names[genesIndx])

31:     # Choose valid pathways

32:     if (missing(pathways))  

37:     if (!missing(pathways)) 

39:         paths <- paste(org, pathways, '.xml', sep='') 

44:     # Create compact adjacency matrices for given pathways.

45:     types  <- getPathwayType(paste(xmlDir, paths, sep='//'))

46:     N <- length(paths)

56:                     funcName=pathwayToGraph,

59:                     N=length(paths),

61:                     xmlDir, paths, types, FALSE, edgeTypes, 

64:     names(cAdjMats) <- gsub('.xml', '', paths)

67:     eAdjMats <- .doSafeParallel(funcName=pathwayToGraph,

70:                                 N=length(paths),

72:                                 xmlDir, paths, types, TRUE, edgeTypes, 

75:     names(eAdjMats) <- gsub('.xml', '', paths)

143:     types <- vector(mode='numeric', length=length(filepath))

144:     for (i in 1:length(filepath))

146:         num <- tail(unlist(strsplit(filepath[i], '//')), 1)

156: # Graph from Metabolic Pathways

161:     xmlDoc <- tryCatch(xmlTreeParse(filepath,error=NULL),

344: # Graph from Mon Metabolic Pathways

350:     xmlDoc         <- tryCatch(xmlTreeParse(filepath,error=NULL),

49:         'nonMetabolicPathwayToGraph', 'expandMetabolicGraph', 

51:         'metabolicPathwayToGraph', 'expandNonMetabolicGraph',

609:                 # Set new interaction types to apathetic

732:     # apathetic  3

26: path <- system.file("extdata", "metadata", package = "recountmethylation")

20: savepath <- paste(dfp, env.name, sep = "/")

27: mdpath <- paste(path, list.files(path)[1], sep = "/")

327:   save(ds, file = file.path("data_analyses", "df-l2med-signals.rda"))

28: md <- get(load(mdpath))

642:     for(path in tbaPaths) {

643:         tba <- readRDS(path)

6: #' @param tbaPaths A vector of strings, which are the paths to

186: #' @param tbaPaths A vector of strings, which are the paths to

623: #' @param tbaPaths, A vector of strings, which are the paths to

654: #' @param tbaPaths A vector of strings, which are the paths to

1064: #' @param tbaPaths A vector of strings, which are the paths to

38: #'  objects listed in the param tbaPaths. Each of these lists contain two

92: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",

102: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,

105: affiXcanTrain <- function(exprMatrix, assay, tbaPaths, regionAssoc, cov=NULL,

107:     regionsCount <- overlookRegions(tbaPaths)

131:         pca <- affiXcanPca(tbaPaths, varExplained, scale, regionsCount,

141:             pcs <- affiXcanPcs(tbaPaths, affiXcanTraining, scale, BPPARAM,

194: #' every MultiAssayExperiment RDS object indicated in the param tbaPaths; it is

200: #' of MultiAssayExperiment objects from tbaPaths) of the samples that have to

205: #' listed in the param tbaPaths. Each of these lists contain two objects:

221: #' tbaPaths <- system.file("extdata","training.tba.toydata.rds",

223: #' regionsCount <- overlookRegions(tbaPaths)

235: #' pca <- affiXcanPca(tbaPaths=tbaPaths, varExplained=80, scale=TRUE,

238: affiXcanPca <- function(tbaPaths, varExplained=80, scale=TRUE, regionsCount,

244:     for(i in seq(1,length(tbaPaths))) {

246:         tbaMatrixMAE <- readRDS(tbaPaths[i])

376: #' of MultiAssayExperiment objects from tbaPaths) of the samples that have to

401: #' tbaPaths <- system.file("extdata","training.tba.toydata.rds",

403: #' regionsCount <- overlookRegions(tbaPaths)

416: #' pca <- affiXcanPca(tbaPaths=tbaPaths, varExplained=80, scale=TRUE,

516: #' tbaPaths <- system.file("extdata","training.tba.toydata.rds",

518: #' regionsCount <- overlookRegions(tbaPaths)

531: #' pca <- affiXcanPca(tbaPaths=tbaPaths, varExplained=80, scale=TRUE,

627: #' MultiAssayExperiment RDS object indicated in the param tbaPaths

633: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",

636: #' regionsCount <- overlookRegions(tbaPaths=testingTbaPaths)

638: overlookRegions <- function(tbaPaths) {

663: #' of MultiAssayExperiment objects from tbaPaths) of the samples that have not

680: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",

682: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",

688: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,

691: #' pcs <- affiXcanPcs(tbaPaths=testingTbaPaths, affiXcanTraining=training,

694: affiXcanPcs <- function(tbaPaths, affiXcanTraining, scale, BPPARAM=bpparam(),

700:     for(i in seq(1,length(tbaPaths))) {

703:         tbaMatrixMAE <- readRDS(tbaPaths[i])

746: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",

756: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,

801: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",

811: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,

814: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",

817: #' pcs <- affiXcanPcs(tbaPaths=testingTbaPaths, affiXcanTraining=training,

863: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",

873: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,

876: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",

879: #' pcs <- affiXcanPcs(tbaPaths=testingTbaPaths, affiXcanTraining=training,

967: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",

977: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,

980: #' imputedExpr <- affiXcanImpute(tbaPaths=trainingTbaPaths,

1029: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",

1039: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,

1042: #' imputedExpr <- affiXcanImpute(tbaPaths=trainingTbaPaths,

1078: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",

1088: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc,

1091: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",

1094: #' exprmatrix <- affiXcanImpute(tbaPaths=testingTbaPaths,

1096: affiXcanImpute <- function(tbaPaths, affiXcanTraining, scale=TRUE,

1098:     regionsCount <- overlookRegions(tbaPaths)

1104:                     tbaPaths refers to ", regionsCount, " regions\n"))

1109:     pcs <- affiXcanPcs(tbaPaths, affiXcanTraining, scale, BPPARAM)

185:     path = all_paths[maxBW, ]

140:     path_individual = as.character(row)

278: path_as_network = function(path) {

123:   shortpath = rownames(as.matrix(unlist(ASP)))

347:     pathM = convertTable(response)

122: ASP_paths = function (ASP) {

360:     all_pathsGM_names = all_pathsGM

341: MS_FindPathway = function(match = NULL, organism_code = NULL) {

141:     BW = sapply(path_individual, get_bw_score, BW_matrix)

180:     ## Get global BW score for each path

186:     path = as.character(path)

187:     all_paths = matrix(path, ncol = length(path))

277: ##################### path_as_network ######################

280:     for (i in 1:(length(path) - 1)) {

281:         edge = c(path[i], path[i + 1])

348:     colnames(pathM) = c("path_ID", "path_Description")

17: #metabolite is a substrate. It is used to calculate shortest paths with SP mode.

121: ####################### ASP_paths #######################

124:   return(shortpath)

150: BW_ranked_SP = function (all_paths, BW_matrix, networkBW_i, mode) {

152:     all_nodes = unique(as.vector(all_paths))

181:     Global_BW_score = sapply (split(all_paths, row(all_paths)), get_global_BW_score,

189:     return(all_paths)

342:     file = paste("https://rest.kegg.jp/list/pathway/", organism_code, sep = "")

345:         stop("A valid organism_code is required for KEGG_entry = pathway")

349:     rownames(pathM) = NULL

351:         target_matrix = pathM

352:         target_column = pathM[, 2]

355:     } else (return(pathM))

359: network_names = function(all_pathsGM, organism_code) {

361:     all_nodes = unique(as.vector(all_pathsGM[, 1:2]))

365:         all_pathsGM_names[all_pathsGM_names == all_nodes[i]] = all_names[i]

367:     return(all_pathsGM_names)

340: #################### MS_FindPathway ####################

1497:             path = project_folder, recurse = TRUE,

1947:                 path = association_file,

3801:                                 path = report_path,

1440:     path_cols <- .path_cols_names()

2356:     path_col_names <- .path_cols_names()

1736:     stats_paths <- purrr::pmap_dfr(temp, function(...) {

1824:     stats_paths <- .stats_report(association_file,

368:     corr_fold <- fs::path(dir, "fs")

372:         proj_fold <- fs::path(corr_fold, proj)

373:         quant_fold <- fs::path(proj_fold, "quantification")

378:             pool_fold <- fs::path(quant_fold, .y)

390:                 file = fs::path(pool_fold, paste(prefix,

397:                 file = fs::path(pool_fold, paste(prefix,

408:             proj_fold <- fs::path(corr_fold, proj)

409:             iss_fold <- fs::path(proj_fold, "iss")

412:                 pool_fold <- fs::path(iss_fold, .y)

420:                         file = fs::path(pool_fold, filename),

449:     err_fold <- fs::path(dir, "fserr")

457:         proj_fold <- fs::path(err_fold, proj)

458:         quant_fold <- fs::path(proj_fold, "quantification")

477:             pool_fold <- fs::path(quant_fold, .y)

490:                     file = fs::path(pool_fold, paste(prefix,

498:                 file = fs::path(pool_fold, paste(prefix,

509:             proj_fold <- fs::path(err_fold, proj)

510:             iss_fold <- fs::path(proj_fold, "iss")

519:                 pool_fold <- fs::path(iss_fold, .y)

528:                             file = fs::path(pool_fold, filename),

561: #' @importFrom fs path_ext

562: #' @importFrom tools file_path_sans_ext

564: .check_file_extension <- function(file_path) {

566:     last <- fs::path_ext(file_path)

570:         file_path[compressed] <- tools::file_path_sans_ext(

571:             file_path[compressed]

573:         last <- fs::path_ext(file_path)

981: .read_with_fread <- function(path, additional_cols, annotated, sep) {

1010:         file = path,

1047: .read_with_readr <- function(path, additional_cols, annotated, sep) {

1072:         file = path,

1107: .import_single_matrix <- function(path,

1139:     is_compressed <- fs::path_ext(path) %in% .compressed_formats()

1142:         compression_type <- fs::path_ext(path)

1155:     peek_headers <- readr::read_delim(path,

1177:             path = path, additional_cols = additional_cols,

1182:             path = path, additional_cols = additional_cols,

1296: .read_af <- function(path, date_format, delimiter) {

1299:     file_ext <- .check_file_extension(path)

1313:         headers_peek <- readr::read_delim(path,

1321:         headers_peek <- readxl::read_excel(path, n_max = 0)

1342:             df <- readr::read_delim(path,

1352:             df <- readxl::read_excel(path,

1420: # - root_folder: Path to the root folder

1423: # ProjectID - ConcatenatePoolIDSeqRun - PathToFolderProjectID - Found - Path -

1424: # Path_quant - Path_iss (NOTE: headers are dynamic!)

1448:                 fs::path(

1449:                     fs::path(root_folder),

1460:             !!path_cols$project := NA_character_,

1461:             !!path_cols$quant := NA_character_,

1462:             !!path_cols$iss := NA_character_

1466:         project_folder <- fs::path(

1467:             fs::path(root_folder),

1471:             paste0(fs::path(

1473:                 fs::path(cur[[concat_pool_col]])

1489:             paste0(fs::path(

1491:                 fs::path(cur[[concat_pool_col]])

1505:             path = project_folder, recurse = TRUE,

1515:                     !!path_cols$project := project_folder,

1516:                     !!path_cols$quant := quant_found,

1517:                     !!path_cols$iss := iss_found

1548: .manage_association_file <- function(af_path,

1558:         path = af_path,

1689: # Finds automatically the path on disk to each stats file.

1696: # Path_iss (or designated dynamic name), stats_files, info

1701:     path_iss_col) {

1704:             dplyr::all_of(c(proj_col, pool_col, path_iss_col))

1712:     if (all(is.na(temp[[path_iss_col]]))) {

1719:         if (is.na(temp_row[[path_iss_col]])) {

1727:         files <- fs::dir_ls(temp_row[[path_iss_col]],

1809: # - path_iss_col: name of the column that contains the path

1818:     path_iss_col,

1828:         path_iss_col = path_iss_col

1939: .pre_manage_af <- function(association_file, import_af_args, report_path) {

1940:     if (!is.null(report_path) && !fs::is_dir(report_path)) {

1941:         report_path <- fs::path_dir(report_path)

1943:     ## Import association file if provided a path

1948:                 report_path = report_path,

1954:     if (!.path_cols_names()$quant %in% colnames(association_file)) {

1955:         rlang::abort(.af_missing_path_error(.path_cols_names()$quant),

1956:             class = "missing_path_col"

1960:         dplyr::filter(!is.na(.data[[.path_cols_names()$quant]]))

2345: #' @importFrom fs dir_ls as_fs_path

2359:             dplyr::all_of(c(proj_col, pool_col, path_col_names$quant))

2382:             matches <- fs::dir_ls(temp_row[[path_col_names$quant]],

2433: # @param dupl The tibble containing quantification types and path to the files

2481: # * Removing files not found (files for which Files_count$Found == 0 and Path

2656: #' @importFrom fs as_fs_path

2699:                     dplyr::mutate(Files_found = fs::as_fs_path(

2723:                     dplyr::mutate(Files_found = fs::as_fs_path(

2812: # * Removing files not found (files for which Files_count$Found == 0 and Path

2992:             list(path = x),

3740:     report_path) {

3787:                         fs::dir_create(report_path)

3817:                                 path = report_path,

4217: # @param file_path The file path as a string

4218: #' @importFrom fs dir_create path_wd path

4223: .write_recalibr_map <- function(map, file_path) {

4224:     if (!fs::file_exists(file_path)) {

4225:         ext <- fs::path_ext(file_path)

4228:             fs::dir_create(file_path)

4230:             tmp_filename <- fs::path(file_path, gen_filename)

4232:             tmp_filename <- fs::path_ext_remove(file_path)

4234:                 ext <- paste(fs::path_ext(tmp_filename), ext, sep = ".")

4235:                 tmp_filename <- fs::path_ext_remove(tmp_filename)

4253:     } else if (fs::is_dir(file_path)) {

4255:         tmp_filename <- fs::path(file_path, gen_filename)

4257:         tmp_filename <- file_path

5051:                 x = "Did you provide the correct path?"

5068:                 x = "Did you provide the correct path?"

560: # Returns the file format for each of the file paths passed as a parameter.

1431:         rlang::abort(.af_missing_pathfolder_error(proj_fold_col))

1531: # containing paths to project folder, quant folders and iss folders

1711:     # If paths are all NA return

1791:     stats_paths

1823:     # Obtain paths

1830:     stats_paths <- stats_paths %>%

1832:     if (all(is.na(stats_paths$stats_files))) {

1833:         stats_paths <- stats_paths %>%

1839:         return(list(stats = NULL, report = stats_paths))

1870:         data_list = stats_paths$stats_files,

1886:     stats_paths <- stats_paths %>%

1888:     stats_paths <- purrr::pmap_dfr(stats_paths, function(...) {

1905:     stats_paths <- stats_paths %>%

1907:     stats_dfs <- stats_dfs$res[stats_paths$Imported]

1910:         return(list(stats = NULL, report = stats_paths))

1917:     list(stats = stats_dfs, report = stats_paths)

2972: # @param files Files_found table where absolute paths of chosen files

497:     path <- .sql_get_rpath(x, rids)

533:     update_time_and_path <- function(x, i) {

542:             locfile_path <- file.path(bfccache(x), id)

404:     rpath <- .sql_add_resource(x, rname, rtype, fpath, ext, fname)

1003:         fpath <- .sql_get_fpath(x, rid)

1187:     paths <- .sql_get_rpath(x, bfcrid(x))

1314:             newpath <- file.path(dir, basename(orig))

1387:     exportPath <- file.path(exdir, "BiocFileCacheExport")

1133:     rpaths <- .sql_get_rpath(x, rids)

1435:     rpaths <- .sql_get_rpath(x, rids)

34: #'   \item{'cache': }{character(1) on-disk location (directory path) of the

53: #'   \item{'rpath': }{resource path. This is the path to the local

74: #' @param cache character(1) On-disk location (directory path) of

105:             cache <- file.path(tempdir(), "BiocFileCache")

213: #' @describeIn BiocFileCache Get a file path for select resources from

228: #' @describeIn BiocFileCache Set the file path of selected resources

230: #' @param value character(1) Replacement file path.

279: #' @return For 'bfcnew': named character(1), the path to save your

283: #' path <- bfcnew(bfc0, "NewResource")

284: #' path

329: #' @param fpath For bfcadd(), character(1) path to current file

331: #'     assumed to also be the path location. For bfcupdate()

334: #'     if the resource is a local file, a relative path in the cache,

337: #'     relative or web paths, based on the path prefix.

341: #'     in current location but save the path in the cache. If 'rtype

357: #' @return For 'bfcadd': named character(1), the path to save your

484: #' @return For 'bfcpath': the file path location to load

498:     path

517: #'     in the cache the path is returned, if it is not it will try to

522: #' @return For 'bfcrpath': The local file path location to load.

543:             locfile <- .lock2(locfile_path, exclusive = TRUE)

552:                     names(update_time_and_path(x, res))

561:                 .unlock2(locfile_path)

564:             names(update_time_and_path(x, res))

591:         update_time_and_path(x, rids)

672:                     "Setting a new remote path results in immediate\n",

1071: #' @return For 'bfcdownload': character(1) path to downloaded resource

1186:     files <- file.path(bfccache(x), setdiff(dir(bfccache(x)),c(.CACHE_FILE, .CACHE_FILE_LOCK)))

1255: #' @return character(1) The outputFile path.

1277:     dir <- file.path(tempdir(), "BiocFileCacheExport")

1318:                 newpath <- file.path(dir, filename)

1345:         outputFile = file.path(origdir, outputFile)

1355:     .util_unlink(file.path(dir, .CACHE_FILE_LOCK))

57: #'   \item{'fpath': }{If rtype is "web", this is the link to the

217: #' @return For '[[': named character(1) rpath for the given resource

225:     .sql_get_rpath(x, i)

240:     .sql_set_rpath(x, i, value)

243:         warning("updating rpath, changing rtype to 'local'")

304:         x, rname, fpath = rname, rtype=c("auto", "relative", "local", "web"),

317:         x, rname, fpath = rname, rtype=c("auto", "relative", "local", "web"),

323:     bfcadd(x=BiocFileCache(), rname=rname, fpath=fpath, rtype=rtype,

339: #'     \code{copy} of \code{fpath} in the cache directory; \code{move}

376: #' bfcadd(bfc0, "TestWeb", fpath=url)

381:         x, rname, fpath = rname,

389:         is.character(fpath), length(fpath) > 0L, !any(is.na(fpath))

395:     stopifnot((length(action) == 1) || (length(action) == length(fpath)))

396:     stopifnot((length(rtype) == 1) || (length(rtype) == length(fpath)))

397:     if (length(action) == 1) action = rep(action, length(fpath))

398:     if (length(rtype) == 1) rtype = rep(rtype, length(fpath))

400:     rtype <- .util_standardize_rtype(rtype, fpath, action)

401:     stopifnot(all(rtype == "web" | file.exists(fpath)))

405:     rid <- names(rpath)

407:     for(i in seq_along(rpath)){

411:                 copy = file.copy(fpath[i], rpath[i]),

412:                 move = file.rename(fpath[i], rpath[i]),

414:                     .sql_set_rpath(x, rid[i], fpath[i])

415:                     rpath[i] <- bfcrpath(x, rids = rid[i])

423:     rpath

457:     tbl <- mutate(tbl, rpath = unname(bfcrpath(x, rids=rids)))

469: setGeneric("bfcpath",

470:     function(x, rids) standardGeneric("bfcpath"),

475: #' @aliases bfcpath,missing-method

476: #' @exportMethod bfcpath

477: setMethod("bfcpath", "missing",

480:     bfcpath(x=BiocFileCache(), rids=rids)

486: #' bfcpath(bfc0, rid3)

487: #' @aliases bfcpath

488: #' @exportMethod bfcpath

489: setMethod("bfcpath", "BiocFileCacheBase",

502: setGeneric("bfcrpath",

503:     function(x, rnames, ..., rids, exact = TRUE) standardGeneric("bfcrpath"),

508: #' @aliases bfcrpath,missing-method

509: #' @exportMethod bfcrpath

510: setMethod("bfcrpath", "missing",

513:     bfcrpath(x=BiocFileCache(), rnames=rnames, ..., rids=rids, exact=exact)

516: #' @describeIn BiocFileCache display rpath of resource. If 'rnames' is

524: #' bfcrpath(bfc0, rids = rid3)

525: #' @aliases bfcrpath

526: #' @exportMethod bfcrpath

527: setMethod("bfcrpath", "BiocFileCacheBase",

534:         .sql_get_rpath(x, i)

588:         bfcrpath(x, rids = rids0)

611: #' @param rpath character() vector of replacement rpaths.

615: #' bfcupdate(bfc0, rid3, rpath=fl3, rname="NewRname")

617: #' bfcupdate(bfc0, "BFC5", fpath="http://google.com")

621:     function(x, rids, rname=NULL, rpath=NULL, fpath=NULL,

627:         is.null(rpath) || (length(rids) == length(rpath)),

628:         is.null(fpath) || (length(rids) == length(fpath))

632:         is.null(rpath) || is.character(rpath),

633:         is.null(fpath) || is.character(fpath)

646:         if (!is.null(rpath)) {

647:             if (!file.exists(rpath[i]))

651:                     "\n  rpath: ", sQuote(rpath[i]),

652:                     "\n  reason: rpath does not exist.",

655:             .sql_set_rpath(x, rids[i], rpath[i])

658:                 warning("updating rpath, changing rtype to 'local'")

663:         if (!is.null(fpath)) {

681:                     x, rids[i], proxy, config, "bfcupdate()", fpath[i], ...

683:                 .sql_set_fpath(x, rids[i], fpath[i])

865:     function(x, query, field=c("rname", "rpath", "fpath"), ..., exact = FALSE)

874:     function(x, query, field=c("rname", "rpath", "fpath"), ..., exact = FALSE)

887: #'     matches pattern agains rname, rpath, and fpath. If exact

892: #'     \code{bfcrpath}, the default is \code{TRUE} (exact matching).

904:     function(x, query, field=c("rname", "rpath", "fpath"), ..., exact = FALSE)

980: #'     'rid'. \code{TRUE}: fpath \code{etag} or \code{modified} time of

981: #'     web resource more recent than in BiocFileCache; \code{FALSE}: fpath

1006:         cache_info <- .httr_get_cache_info(fpath)

1088:     if (ask && any(file.exists(.sql_get_rpath(x, rid)))) {

1099:     bfcrpath(x, rids=rid)

1188:     # normalizePath on windows

1191:         files = normalizePath(files)

1192:         paths = normalizePath(paths)

1194:     untracked <- setdiff(files, paths)

1249: #' @param outputFile character(1) The <filepath>/basename for the

1313:             orig <- .sql_get_rpath(x, i)

1315:             if (file.exists(newpath)) {

1320:             file.copy(orig, newpath)

1388:     stopifnot(!dir.exists(exportPath))

1398:     bfc = BiocFileCache(exportPath)

349: #'     \code{httr::GET}. For 'bfcrpaths': Additional arguments passed

483: #' @describeIn BiocFileCache display rpaths of resource.

1134:     cached <- startsWith(rpaths, bfccache(x))

1137:     status <- .util_unlink(rpaths[cached])

1436:     cached <- startsWith(rpaths, bfccache(x))

1439:         txt0 <- paste("file ", sQuote(rpaths))

1448:     .util_unlink(rpaths[cached])

259:   path <- system.file("extdata", package=pkgname)

260:   if(path=="") stop("Are you sure ", pkgname, " is installed?")

262:   snpBuilds <- list.files(path, pattern="snpProbes_")

734:     path <- cch$getFilePath(self$getCacheId(), name='download', ext=ext)

147: #' Get the path to the persistent cache file.

727: #' Gets the path where the downloaded content is written.

728: #' @return The path where the downloaded database is written.

736:     logDebug0('Download path of ', self$getId(), ' is "', path, '".')

738:     return(path)

743: #' @param src Path to the downloaded file.

151: #' containing the paths to the cache files corresponding to the requested

156:     fp <- c$getFilePath(self$getCacheId(), entry.id, self$getEntryFileExt())

729: getDownloadPath=function() {

793:         if ( ! file.exists(self$getDownloadPath()))

795:                 self$getDownloadPath())

273:     path <- paste(compilation, paste0(endpoint, "?"), sep = "/")

319:     paste0(pkg_globals$snaptron_host, path, paste(query, collapse = "&"))

532:           path = q$pathways[[i]]

537:         path = QSarray$pathways[[i]]

379:   PDFs = pathMeans = Sizes = NULL

792:     SDPath = apply(calcBayesCI(QSarray,low=0.5,up=0.8413448)[,path.index,drop=F],2,function(x)x[2]-x[1])

800:       XPath = getXcoords(QSarray,i,addVIF=addVIF)

808:         PDFPath<-approx( XPath, QSarray$path.PDF[,i],X_Sample,rule=2)$y

47:     qs.results.comb$path.mean = 2 * qs.results.comb$path.mean

59:     for(i in c("var.method","labels","pairVector","pathways","path.size")){

408:   geneResults$path.mean = pathMeans

409:   geneResults$path.size = Sizes

412:   geneResults$path.PDF = PDFs

503:   if(!is.null(geneResults$path.PDF)){ ##if defined, rescale the pdf with the new vif values

504:     geneResults$path.PDF = t(t(geneResults$path.PDF) / pdfScaleFactor(geneResults))

524:   if(is.null(QSarray$path.PDF)){stop("convolution results not found.")}

525:   p = sapply(1:ncol(QSarray$path.PDF), function(i){

526:     if(!is.null(QSarray$path.size) && QSarray$path.size[i]==0){return(NA)}

533:           mean(q$mean[-path])

538:         null.hyp = mean(QSarray$mean[-path])

545: #         path = QSarray$pathways[[i]]

546: #         null.hyp=mean(getExAbs(QSarray$dof[path])*QSarray$SD[path])

551:     PDF_NORM<-QSarray$path.PDF[,i]/sum(QSarray$path.PDF[,i])

552: #     sum(QSarray$path.PDF[1:findInterval(0,x),i]) / sum(QSarray$path.PDF[,i])

571: twoWay.pVal <- function(grp1, grp2, path.index1 = 1:numPathways(grp1), path.index2 = 1:numPathways(grp2), 

575:   return(twoCurve.pVal(grp1, grp2, path.index1, path.index2, alternative, direction,addVIF))

582:                         path.index1 = 1:numPathways(grp1),

583:                         path.index2 = 1:numPathways(grp2), 

589: #   if(ncol(grp1$path.PDF)!=ncol(grp2$path.PDF) | all(colnames(grp1$path.PDF) != colnames(grp2$path.PDF))){

592:   if(length(path.index1)!=length(path.index2)){

595: #     if(sum(names(grp1$path.mean[path.index1])!=names(grp2$path.mean[path.index2]))){

599:   x1 = sapply(path.index1,function(i){getXcoords(grp1,i,addVIF=addVIF)})

600:   x2 = sapply(path.index2,function(i){getXcoords(grp2,i,addVIF=addVIF)})

605:   p = sapply(1:length(path.index1), function(i){

607:     PDF1<-approx( x1[,i], grp1$path.PDF[,path.index1[i]],seq(Min[i],Max[i],length.out=Length1+Length2),rule=2)$y

608:     PDF2<-approx( x2[,i], grp2$path.PDF[,path.index2[i]],seq(Min[i],Max[i],length.out=Length1+Length2),rule=2)$y

615: ## path.index can either be an integer between 1 and length(path.means), or the name of the pathway.

618: getXcoords = function(QSarray,path.index=1, addVIF=!is.null(QSarray$vif)){ #,absolute=FALSE){

619:   if(length(path.index)>1){stop("path.index must be of length 1")}

622:   sif = ifelse(addVIF,sqrt(QSarray$vif[path.index]),1)

626:   seq(-1,1,length.out=QSarray$n.points)* QSarray$ranges[path.index]* sif + QSarray$path.mean[path.index]

630: #    MeanAbs<-mean(abs(QSarray$mean[QSarray$pathways[[path.index]]]))

631: #    seq(-1,1,length.out=QSarray$n.points)* QSarray$ranges[path.index]* sif / QSarray$path.size[path.index] + MeanAbs

642:   pdfSum = colSums(QSarray$path.PDF)

655:   cis = sapply(1:ncol(QSarray$path.PDF), function(i){

657:         any(is.na(QSarray$path.PDF[,i]))){return(c(NA,NA))}

659:     cdf = cumsum(QSarray$path.PDF[,i])

668:   colnames(cis) = colnames(QSarray$path.PDF)

771:                                  path.index=1:numPathways(QSarray), ##The pathways to calculate the pVals for.

778:   ##check path.index

779:   if(is.character(path.index)){

780:     path.index = match(path.index, names(QSarray$pathways))

793:     if(!addVIF)SDPath = SDPath / sqrt(QSarray$vif[path.index])

799:     for(i in path.index){

824:             TMP<-pnorm( ( Means[j] - QSarray$path.mean[i]  ) / sqrt( SDPath[i]^2 + (DOF[j])/(DOF[j]-2)*SD[j]^2) )

835:     for(i in path.index){

842:           if(compareTo=="mean")SUBSTRACT=QSarray$path.mean[i]

875:         if(!CompareWithZero)SUBSTRACT=QSarray$path.mean[i]

17:                   geneSets,          ##a list of pathways to be compared. Each item in the list is a vector of names that correspond to the row names of ...(5 bytes skipped)...

74:                          geneSets,          ##a list of pathways to be compared. Each item in the list is a vector of names that correspond to the row names of ...(5 bytes skipped)...

308:  if(!is.null(QSarray$pathways)){stop("too late...aggregateGeneSet already being called")}

320: ##Simple function to read in a .gmt file and return a list of pathways

322:   if(!grepl("\\.gmt$",file)[1]){stop("Pathway information must be a .gmt file")}

331: #######Combine individual gene differential expresseion for each pathway (Neg) ~ 1 minute

334:                            geneSets,     ##a list of pathways to be compared, each item in the list is a vector of names that correspond to the gene names fr...(25 bytes skipped)...

336:                            silent=TRUE   ##If false, print a "." every fifth pathway, as a way to keep track of progress

401:     pathMeans = c(pathMeans, mean(Means[Indexes]))

405:   colnames(PDFs) = names(pathMeans) = names(Sizes) = names(geneSets)

407:   geneResults$pathways = geneSets

425: #                    geneSets=NULL, ##a list of pathways calculate the vif for, each item in the list is a vector of names that correspond to the gene n...(32 bytes skipped)...

430:     if(is.null(geneResults$pathways)){stop("Pathway Information not found. Please provide a list of gene sets.")}

431:     geneSets = geneResults$pathways

439: #     geneResults$pathways = geneSets

516: ## function for calculating a p-value for each pathway convolution as output by aggregateGeneSet.

519: ...(59 bytes skipped)... true (and alternative="two.sided"), p-values will be returned as eiter positive or negative if the pathway is greater or less than 0, respectively.

521: ...(15 bytes skipped)...      selfContained=TRUE                ##If false, rather than comparing to 0, it will compare the pathway mean to the mean of all genes not in the pathway.

578: ## A method to compare the pathway convolutions in two QSarray objects. 

588:   ##if the names of the pathways don't match, 

590: #     stop("Pathways in grp1 do not match pathways in grp2")

593:     stop("Number of pathways in grp1 do not match number of pathways in grp2")

596: #         warning("Some of the comparisons are made between different pathways")

614: ## Calculates the x-coordinates for the PDF of a given pathway.

629: #    ###First calculate the new mean of the pathway based on the absolute values of the means

656:     if( (!is.null(QSarray$pathways) && length(QSarray$pathways[[i]])==0 ) ||

772:                                  silent=TRUE,   ##If false, print a "." every fifth pathway, as a way to keep track of progress  

784:   if(is.null(QSarray$pathways)){stop("Pathway Information not found. Please run aggregateGeneSet first.")}

785:   geneSets = QSarray$pathways

805:         Min<-min(c(XGene[1]+ Means[Indexes],XPath[1]))

806:         Max<-max(c(XGene[NPoints]+ Means[Indexes],XPath[QSarray$n.points]))

815:             PS<-c(PS,compareTwoDistsFaster(PDFGene,PDFPath, alternative="two.sided"))                    

860: ...(17 bytes skipped)...             CompareWithZero=TRUE ###Logical, if TRUE compares with mean of zero, else with mean of pathway

862:   if(is.null(QSarray$pathways)){stop("Pathway Information not found. Please provide a list of gene sets.")}

863:   geneSets = QSarray$pathways

898: #                    geneSets=NULL, ##a list of pathways calculate the vif for, each item in the list is a vector of names that correspond to the gene n...(32 bytes skipped)...

901:   if(is.null(geneResults$pathways)){stop("Pathway Information not found. Please provide a list of gene sets.")}

902:   geneSets = geneResults$pathways  

640:   sif = sapply(1:numPathways(QSarray),function(i){ifelse(addVIF,sqrt(QSarray$vif[i]),1)})

1191:         path <- tryCatch(BiocFileCache::bfcadd(bfc, url),

536: .validate_path <- function(reference_path, subdirs = NULL) {

636:     map_path <- file.path(normalizePath(reference_path), "Mappability")

996:     r_path <- file.path(reference_path, "resource")

997:     gtf_path <- file.path(r_path, "transcripts.gtf.gz")

1167: .get_cache_file_path <- function(cache, rpath) {

10: #' subdirectory within the given `reference_path`. Resources are retrieved via

12: #' 1. User-supplied FASTA and GTF file. This can be a file path, or a web link

28: #' of the specified reference path. If `use_STAR_mappability` is set to `TRUE`

33: #' `getNonPolyARef()` returns the path of the non-polyA reference file for the

55: #' file, open the file specified in the path returned by

60: #' @param reference_path (REQUIRED) The directory path to store the generated

62: #' @param fasta The file path or web link to the user-supplied genome

65: #'   been run using the same `reference_path`.

66: #' @param gtf The file path or web link  to the user-supplied transcript

70: #'   `reference_path`.

76: #'   the file `SpliceWiz.ref.gz` is present inside `reference_path`.

135: #' * `reference_path/resource/genome.2bit`: Local copy of the genome sequences

137: #' * `reference_path/resource/transcripts.gtf.gz`: Local copy of the gene

141: #'   which is written to the given directory specified by `reference_path`.

143: #' * `reference_path/settings.Rds`: An RDS file containing parameters used

145: #' * `reference_path/SpliceWiz.ref.gz`: A gzipped text file containing collated

147: #' * `reference_path/fst/`: Contains fst files for subsequent easy access to

149: #' * `reference_path/cov_data.Rds`: An RDS file containing data required to

153: #'   subdirectory inside the designated `reference_path`

155: #' For `getNonPolyARef()`: Returns the file path to the BED file for

161: #' example_ref <- file.path(tempdir(), "Reference")

163: #'     reference_path = example_ref,

168: #'     reference_path = example_ref

173: #' example_ref <- file.path(tempdir(), "Reference")

175: #'     reference_path = example_ref,

180: #' # Get the path to the Non-PolyA BED file for hg19

192: #'     reference_path = "./Reference_user",

204: #'     reference_path = "./Reference_FTP",

220: #'     reference_path = "./Reference_AH",

232: #'     reference_path = "./Reference_UCSC",

242: #' #      inside the given `reference_path`.

247: #'     reference_path = "./Reference_with_STAR",

257: #'     reference_path = "./Reference_with_STAR",

261: #'     reference_path = reference_path,

266: #'     reference_path = "./Reference_with_STAR",

285: #' of the given reference path

288:         reference_path = "./Reference",

294:         reference_path = reference_path,

304: #' given reference path

307:         reference_path = "./Reference",

315:     .validate_path(reference_path, subdirs = "resource")

317:             file.exists(file.path(reference_path, "SpliceWiz.ref.gz"))) {

321:     extra_files <- .fetch_genome_defaults(reference_path,

330:         reference_path = reference_path,

340:     .process_gtf(reference_data$gtf_gr, reference_path, verbose = verbose)

346:     reference_data$genome <- .check_2bit_performance(reference_path,

353:     saveRDS(chromosomes, file.path(reference_path, "chromosomes.Rds"))

355:     .process_introns(reference_path, reference_data$genome,

359:     .gen_irf(reference_path, extra_files, reference_data$genome, chromosomes,

366:             .gen_nmd(reference_path, reference_data$genome,

370:         .gen_nmd(reference_path, reference_data$genome, 

376:     .gen_splice(reference_path, verbose = verbose)

378:     if (file.exists(file.path(reference_path, "fst", "Splice.fst")) &

379:         file.exists(file.path(reference_path, "fst", "Proteins.fst"))) {

381:         .gen_splice_proteins(reference_path, reference_data$genome, 

389:     cov_data <- .prepare_covplot_data(reference_path)

390:     saveRDS(cov_data, file.path(reference_path, "cov_data.Rds"))

394:     settings.list <- readRDS(file.path(reference_path, "settings.Rds"))

402:     saveRDS(settings.list, file.path(reference_path, "settings.Rds"))

415:         reference_path,

428:             file.exists(file.path(reference_path, "SpliceWiz.ref.gz"))) {

435:     getResources(reference_path = reference_path,

439:     STAR_buildRef(reference_path = reference_path,

454:     buildRef(reference_path = reference_path,

462: #' @describeIn Build-Reference-methods Returns the path to the BED file 

495: Get_Genome <- function(reference_path, validate = TRUE,

497:     if (validate) .validate_reference(reference_path)

498:     twobit <- file.path(reference_path, "resource", "genome.2bit")

501:     } else if (file.exists(file.path(reference_path, "settings.Rds"))) {

502:         settings <- readRDS(file.path(reference_path, "settings.Rds"))

505:         .log("In Get_Genome, invalid reference_path supplied")

513: Get_GTF_file <- function(reference_path) {

514:     .validate_reference(reference_path)

515:     if (file.exists(file.path(reference_path,

517:         return(file.path(reference_path, "resource", "transcripts.gtf.gz"))

519:         .log("In Get_GTF_file, invalid reference_path supplied")

538:         reference_path != "" &&

540:             ifelse(normalizePath(dirname(reference_path)) != "", TRUE, TRUE),

546:         .log(paste("Error in 'reference_path',",

547:             paste0("base path of '", reference_path, "' does not exist")

551:     base <- normalizePath(dirname(reference_path))

552:     if (!dir.exists(file.path(base, basename(reference_path))))

553:         dir.create(file.path(base, basename(reference_path)))

557:             dir_to_make <- file.path(base, basename(reference_path), subdirs)

561:     return(file.path(base, basename(reference_path)))

564: .validate_reference_resource <- function(reference_path, from = "") {

565:     ref <- normalizePath(reference_path)

570:             "in reference_path =", reference_path,

571:             ": this path does not exist"))

573:     if (!file.exists(file.path(ref, "settings.Rds"))) {

575:             "in reference_path =", reference_path,

578:     settings.list <- readRDS(file.path(ref, "settings.Rds"))

582:             "in reference_path =", reference_path,

588: .validate_reference <- function(reference_path, from = "") {

589:     ref <- normalizePath(reference_path)

594:             "in reference_path =", reference_path,

595:             ": this path does not exist"))

597:     if (!file.exists(file.path(ref, "settings.Rds"))) {

599:             "in reference_path =", reference_path,

602:     if (!file.exists(file.path(ref, "SpliceWiz.ref.gz"))) {

604:             "in reference_path =", reference_path,

607:     settings.list <- readRDS(file.path(ref, "settings.Rds"))

611:             "in reference_path =", reference_path,

621: .fetch_genome_defaults <- function(reference_path, genome_type,

637:     map_file <- file.path(map_path, "MappabilityExclusion.bed.gz")

649:                     path = map_path, overwrite = TRUE

677:     local.nonPolyAFile <- file.path(reference_path, "resource", 

679:     local.MappabilityFile <- file.path(reference_path, "resource", 

681:     local.BlacklistFile <- file.path(reference_path, "resource", 

760: .get_reference_data <- function(reference_path, fasta, gtf,

766:     .validate_path(reference_path, subdirs = "resource")

768:         twobit <- file.path(reference_path, "resource", "genome.2bit")

775:         gtf <- file.path(reference_path, "resource", "transcripts.gtf.gz")

796:         reference_path = reference_path,

803:         reference_path = reference_path,

825:         reference_path = reference_path

828:     saveRDS(settings.list, file.path(reference_path, "settings.Rds"))

830:     settings.list <- readRDS(file.path(reference_path, "settings.Rds"))

863:         reference_path = "./Reference",

873:         .fetch_fasta_save_2bit(genome, reference_path, overwrite)

878:         twobit <- file.path(reference_path, "resource", "genome.2bit")

884:             genome <- Get_Genome(reference_path, validate = FALSE,

894:             twobit <- file.path(reference_path, "resource", "genome.2bit")

900:                 genome <- Get_Genome(reference_path, validate = FALSE,

918:         .fetch_fasta_save_2bit(genome, reference_path, overwrite)

926:         genome <- Get_Genome(reference_path, validate = FALSE,

950:     genome, reference_path, overwrite, verbose = TRUE

952:     genome.fa <- file.path(reference_path, "resource", "genome.fa")

965:         genome, reference_path, overwrite, verbose = TRUE

967:     genome.2bit <- file.path(reference_path, "resource", "genome.2bit")

969:             normalizePath(rtracklayer::path(genome)) ==

979:                 file.exists(rtracklayer::path(genome))) {

980:             file.copy(rtracklayer::path(genome), genome.2bit)

991:         reference_path = "./Reference",

1003:         if (overwrite || !file.exists(gtf_path)) {

1007:                 if (file.exists(gtf_path)) file.remove(gtf_path)

1008:                 file.copy(cache_loc, gtf_path)

1013:         if (file.exists(gtf_path)) {

1018:             gtf_gr <- rtracklayer::import(gtf_path, "gtf")

1029:             if (file.exists(gtf_path)) {

1034:                 gtf_gr <- rtracklayer::import(gtf_path, "gtf")

1048:         if (!file.exists(gtf_path) ||

1049:                 normalizePath(gtf_file) != normalizePath(gtf_path)) {

1050:             if (overwrite || !file.exists(gtf_path)) {

1055:                     if (file.exists(gtf_path)) file.remove(gtf_path)

1056:                     file.copy(gtf_file, gtf_path)

1058:                     gzip(filename = gtf_file, destname = gtf_path,

1188:             return(.get_cache_file_path(cache, res$rpath[nrow(res)]))

1198:         if (identical(path, NA)) {

1202:             return(.get_cache_file_path(cache, res$rpath[nrow(res)]))

1208:         return(.get_cache_file_path(cache, res$rpath[nrow(res)]))

1307: .process_gtf <- function(gtf_gr, reference_path, verbose = TRUE) {

1309:     .validate_path(reference_path, subdirs = "fst")

1313:         file.path(reference_path, "fst", "gtf_fixed.fst"))

1317:     Genes_group <- .process_gtf_genes(gtf_gr, reference_path, verbose)

1319:     .process_gtf_transcripts(gtf_gr, reference_path, verbose)

1321:     .process_gtf_misc(gtf_gr, reference_path, verbose)

1323:     .process_gtf_exons(gtf_gr, reference_path, Genes_group, verbose)

1329: .process_gtf_genes <- function(gtf_gr, reference_path, verbose = TRUE) {

1385:         file.path(reference_path, "fst", "Genes.fst")

1394: .process_gtf_transcripts <- function(gtf_gr, reference_path, verbose = TRUE) {

1418:         file.path(reference_path, "fst", "Transcripts.fst")

1422: .process_gtf_misc <- function(gtf_gr, reference_path, verbose = TRUE) {

1433:         file.path(reference_path, "fst", "Proteins.fst")

1444:         file.path(reference_path, "fst", "Misc.fst")

1449:     gtf_gr, reference_path, Genes_group, verbose = TRUE

1480:         file.path(reference_path, "fst", "Exons.fst"))

1483:         file.path(reference_path, "fst", "Exons.Group.fst")

1545: .check_2bit_performance <- function(reference_path, genome, verbose = TRUE) {

1548:             read.fst(file.path(reference_path, "fst", "Exons.fst")),

1571:     reference_path, genome, useExtendedTranscripts = TRUE, verbose = TRUE

1576:     data <- .process_introns_data(reference_path, genome, 

1590:         file.path(reference_path, "fst", "junctions.fst"))

1595: .process_introns_data <- function(reference_path, genome,