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

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

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)

127: var path = svg.append('svg:g').selectAll('path'),

2499: function ShowShortestPath(){

2: var basePath1="./PPIinfo/";

3: var basePath2="./PPIinfo/";

2630: function ShowShortestPath1(){

2711: var swiss2paths={};

2765: function showPath10(){

2778: function addResultPath10(p){

2784: function addFirstPath10(p){

2800: function addLastPath10(p){

2823: function addPreviousPath10(p){

2842: function addNextPath10(p){

2560: var resultPaths=[];

2561: function ShowPaths(allPaths){

2616: function ShowPathView(index){

2712: function generatePaths(swiss, root){

2729: function ShowShortestPathExp(){

2763: var showPathFirst=0;

2764: var showPathEnd=10;

3044: function getCisPathJS(){

3065: function getCisPathJSRetry(urltry){

3096: function getPathsForTargetProtein(swissID){

3118: function getPathsForTargetProteinRetry(urltry){

53:   .append('svg:path')

68:   .append('svg:path')

94:   .append('svg:path')

109:   .append('svg:path')

115: var drag_line = svg.append('svg:path')

166:   path.attr('d', function(d) {

360:   // path (link) group

381:   path = path.data(links);

384:   path.classed('selected', function(d) { return d === selected_link; })

393:   path.enter().append('svg:path')

414:   path.exit().remove();

2384: ///////////////////////////////////////////////////////////////////////shortest path

2504:        alert("No path between this two proteins!");

2508:        alert("No path between this two proteins!");

2568:     addTh(mycurrent_row, "Path");

2601:         mycurrent_button.id = "path"+x;

2614:     ShowPathView("path0");

2701:        alert("Sorry, detect no path from "+swiss1+" to "+ swiss2);

3097:    var url="./js/"+swissID+"_path.js";

954: 	 document.getElementById("detectPath").disabled=true;

1380:   idx=pathLen-1-idx;

1415: 	var url=basePath2+sourceSwiss+".js";

1679: 	var url=basePath2+swiss1+".js";

1684:            if(this.url==(basePath2+swiss1+".js")){

1820:   var url=basePath2+"A0A5B9.js";

1827:         debugObj("basePath1:"+basePath1);

1831:         basePath1="../geneset20140628/";

1832:         basePath2="../20140628PPI/";

1833:         debugObj("basePath1:"+basePath1);

1845:   var url=basePath2+"gene2swiss.js";

1899: 	var url=basePath2+"swiss2gene.js";

1954: 	var url=basePath2+"swiss2swiss.js";

2021: 	var url=basePath1+"PPI.js";

2411:     	 ShowShortestPath();

2421:           document.getElementById("detectPath").disabled=false;

2426:        document.getElementById("detectPath").disabled=true;

2438:           document.getElementById("detectPath").disabled=false;

2443:        document.getElementById("detectPath").disabled=true;

2515:     document.getElementById("detectPath").disabled=true;

2530:           document.getElementById("detectPath").disabled=false;

2543:            setTimeout("ShowShortestPath1()",1000);

2549:     setTimeout("ShowShortestPath1()",1000);

2574: 	    mycurrent_row.id="pathrow"+x;

2608: 	showPath10();

2611:     document.getElementById("detectPath").disabled=false;

2625: 	  	document.getElementById("pathrow"+x).className="rowNotSelected";

2627: 	document.getElementById("pathrow"+i).className="rowSelected";

2705:     swiss2paths={};

2707:     debugObj(swiss2paths[swiss2]);

2708:     debugObj(swiss2paths[swiss2].length);

2709:     ShowPaths(swiss2paths[swiss2]);

2713:     swiss2paths[swiss]=[];

2715:        swiss2paths[swiss].push(swiss);

2724:         for(var y in swiss2paths[nodes[x]]){

2725:             swiss2paths[swiss].push(swiss2paths[nodes[x]][y]+"#"+swiss);

2760:     ShowShortestPath();

2771:     addResultPath10(p);

2772:     addFirstPath10(p);

2773:     addPreviousPath10(p);

2774:     addNextPath10(p);

2775:     addLastPath10(p);

2796:     resultSPAN.addEventListener("click", function(e){showPathFirst=0;showPath10();}, false);

2819:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2838:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2857:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2879: 	  	document.getElementById("pathrow"+i).style.display="none";

2882:         document.getElementById("pathrow"+i).style.display="";

3020: ...(31 bytes skipped)...ange", function(e){document.getElementById('targetPtxt').value=this.value;checkValid2();ShowShortestPath();}, false);

3108:         json.paths.pop();

3109:     	ShowPaths(json.paths);

3138:         json.paths.pop();

3139:     	ShowPaths(json.paths);

956: 	 document.getElementById("allShortestPaths").style.display="none";

957: 	 document.getElementById("allShortestPathsP").style.display="none";

1253: 	graphName = "cisPathValue#"+graphName;

1267:       if(key.substr(0,13)!="cisPathValue#"){

1285: 	graphName = "cisPathValue#"+graphName;

1306: 	graphName = "cisPathValue#"+graphName;

1327:       if(key.substr(0,13)!="cisPathValue#"){

1418:     callback: "cisPathCallBack",

1682:        callback: "cisPathCallBack",

1823:     callback: "cisPathCallBack",

1850:     callback: "cisPathCallBack",

1880:     callback: "cisPathCallBack",

1905:     callback: "cisPathCallBack",

1935:     callback: "cisPathCallBack",

1960:     callback: "cisPathCallBack",

1990:     callback: "cisPathCallBack",

2025:     callback: "cisPathCallBack",

2063:     callback: "cisPathCallBack",

2110: 	getCisPathJS();

2378:     var graphName="cisPathHTML";

2476: function ShowShortestPathWorker(){

2477:    var worker = new Worker("./D3/cisPathWorker.js");

2480:       var resultPaths=event.data.resultPaths;

2481:       ShowPaths(resultPaths);

2484:       var resultPaths=[];

2485:       ShowPaths(resultPaths);

2514:     document.getElementById("detectPathExp").disabled=true;

2521:     document.getElementById("allShortestPaths").style.display="none";

2522:     document.getElementById("allShortestPathsP").style.display="none";

2529:           document.getElementById("detectPathExp").disabled=false;

2533:           getPathsForTargetProtein(swiss2);

2539:            ShowShortestPathWorker();

2562:     resultPaths=allPaths;

2563:     var table=document.getElementById("allShortestPaths");

2571: 	for(var x in allPaths){

2572: 	    var nodes=allPaths[x].split("#");

2602:         mycurrent_button.addEventListener("click", function(e){ShowPathView(this.id);}, false);

2607: 	showPathFirst=0;

2610:     document.getElementById("detectPathExp").disabled=false;

2612:     document.getElementById("allShortestPaths").style.display="";

2613:     document.getElementById("allShortestPathsP").style.display="";

2617:     var total=resultPaths.length;

2619:     var nodes=resultPaths[i].split("#");

2706:     generatePaths(swiss2, swiss1);

2723:         generatePaths(nodes[x], root);

2767:     var p=document.getElementById("allShortestPathsP");

2780:     var content="Results: "+showPathFirst+"-"+showPathEnd+" of "+resultPaths.length+" ";

2790:     if(showPathFirst==0){

2805: 	var newFirst=(resultPaths.length-resultPaths.length%10);

2806: 	if(newFirst==resultPaths.length){

2807: 	   newFirst=resultPaths.length-10;

2813:     if(showPathEnd==resultPaths.length){

2828:     if(showPathFirst==0){

2834:     var newFirst=showPathFirst-10;

2847:     if(showPathEnd==resultPaths.length){

2853:     var newFirst=showPathFirst+10;

2854:     if(newFirst >= resultPaths.length){

2855:        newFirst = (resultPaths.length-resultPaths.length%10);

2863: 	var total=resultPaths.length;

2864: 	if(showPathFirst >= total){

2865: 	   showPathFirst=(total-total%10);

2867: 	if(showPathFirst == total){

2868: 	   showPathFirst = total-10;

2870:     if(showPathFirst < 0){

2871: 	   showPathFirst = 0;

2873: 	showPathFirst=showPathFirst-(showPathFirst%10);

2874: 	showPathEnd=showPathFirst+10;

2875: 	if(showPathEnd > total){

2876: 	   showPathEnd = total;

2881:     for(var i=showPathFirst;i<showPathEnd;i++){

3049:     callback: "cisPathCallBack",

3061:         getCisPathJSRetry(this.url);

3078:     callback: "cisPathCallBack",

3090:         getCisPathJSRetry(this.url);

3101:      callback: "cisPathCallBack",

3114:         getPathsForTargetProteinRetry(this.url);

3131:     callback: "cisPathCallBack",

3144:         getPathsForTargetProteinRetry(this.url);

3151: 	document.getElementById("detectPathExp").disabled=true;

3156: 	document.getElementById("detectPathExp").disabled=false;

127: var path = svg.append('svg:g').selectAll('path'),

2501: function ShowShortestPath(){

2: var basePath1="./PPIinfo/";

3: var basePath2="./PPIinfo/";

2632: function ShowShortestPath1(){

2719: var swiss2paths={};

2753: function showPath10(){

2766: function addResultPath10(p){

2772: function addFirstPath10(p){

2788: function addLastPath10(p){

2811: function addPreviousPath10(p){

2830: function addNextPath10(p){

2548: var resultPaths=[];

2549: function ShowPaths(allPaths){

2615: function ShowPathView(index){

2720: function generatePaths(swiss, root){

2737: function ShowShortestPathExp(){

2751: var showPathFirst=0;

2752: var showPathEnd=10;

53:   .append('svg:path')

68:   .append('svg:path')

94:   .append('svg:path')

109:   .append('svg:path')

115: var drag_line = svg.append('svg:path')

166:   path.attr('d', function(d) {

360:   // path (link) group

381:   path = path.data(links);

384:   path.classed('selected', function(d) { return d === selected_link; })

393:   path.enter().append('svg:path')

414:   path.exit().remove();

2386: ///////////////////////////////////////////////////////////////////////shortest path

2506:        alert("No path between this two proteins!");

2510:        alert("No path between this two proteins!");

2554:     	 alert("Sorry, detect no path from "+swiss1+" to "+ swiss2);

2566:     addTh(mycurrent_row, "Path");

2599:         mycurrent_button.id = "path"+x;

2613:       ShowPathView("path0");

2705:        alert("Sorry, detect no path from "+name1+" to "+ name2);

954: 	 document.getElementById("detectPath").disabled=true;

1380:   idx=pathLen-1-idx;

1415: 	var url=basePath2+sourceSwiss+".js";

1679: 	var url=basePath2+swiss1+".js";

1684:            if(this.url==(basePath2+swiss1+".js")){

1820:   var url=basePath2+"A0A5B9.js";

1827:         debugObj("basePath1:"+basePath1);

1831:         basePath1="../geneset20140628/";

1832:         basePath2="../20140628PPI/";

1833:         debugObj("basePath1:"+basePath1);

1845:   var url=basePath2+"gene2swiss.js";

1899: 	var url=basePath2+"swiss2gene.js";

1954: 	var url=basePath2+"swiss2swiss.js";

2021: 	var url=basePath1+"PPI.js";

2413:     	 ShowShortestPath();

2423:           document.getElementById("detectPath").disabled=false;

2428:        document.getElementById("detectPath").disabled=true;

2440:           document.getElementById("detectPath").disabled=false;

2445:        document.getElementById("detectPath").disabled=true;

2517:     document.getElementById("detectPath").disabled=true;

2531:            setTimeout("ShowShortestPath1()",1000);

2537:     setTimeout("ShowShortestPath1()",1000);

2558:        document.getElementById("detectPath").disabled=false;

2572: 	    mycurrent_row.id="pathrow"+x;

2606: 	showPath10();

2610:     document.getElementById("detectPath").disabled=false;

2627: 	  	document.getElementById("pathrow"+x).className="rowNotSelected";

2629: 	document.getElementById("pathrow"+i).className="rowSelected";

2709:        document.getElementById("detectPath").disabled=false;

2713:     swiss2paths={};

2715:     debugObj(swiss2paths[swiss2]);

2716:     debugObj(swiss2paths[swiss2].length);

2717:     ShowPaths(swiss2paths[swiss2]);

2721:     swiss2paths[swiss]=[];

2723:        swiss2paths[swiss].push(swiss);

2732:         for(var y in swiss2paths[nodes[x]]){

2733:             swiss2paths[swiss].push(swiss2paths[nodes[x]][y]+"#"+swiss);

2748:     ShowShortestPath();

2759:     addResultPath10(p);

2760:     addFirstPath10(p);

2761:     addPreviousPath10(p);

2762:     addNextPath10(p);

2763:     addLastPath10(p);

2784:     resultSPAN.addEventListener("click", function(e){showPathFirst=0;showPath10();}, false);

2807:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2826:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2845:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2867: 	  	document.getElementById("pathrow"+i).style.display="none";

2870:         document.getElementById("pathrow"+i).style.display="";

956: 	 document.getElementById("allShortestPaths").style.display="none";

957: 	 document.getElementById("allShortestPathsP").style.display="none";

1253: 	graphName = "cisPathValue#"+graphName;

1267:       if(key.substr(0,13)!="cisPathValue#"){

1285: 	graphName = "cisPathValue#"+graphName;

1306: 	graphName = "cisPathValue#"+graphName;

1327:       if(key.substr(0,13)!="cisPathValue#"){

1418:     callback: "cisPathCallBack",

1682:        callback: "cisPathCallBack",

1823:     callback: "cisPathCallBack",

1850:     callback: "cisPathCallBack",

1880:     callback: "cisPathCallBack",

1905:     callback: "cisPathCallBack",

1935:     callback: "cisPathCallBack",

1960:     callback: "cisPathCallBack",

1990:     callback: "cisPathCallBack",

2025:     callback: "cisPathCallBack",

2063:     callback: "cisPathCallBack",

2380:     var graphName="cisPathHTML";

2478: function ShowShortestPathWorker(){

2479:    var worker = new Worker("./D3/cisPathWorker.js");

2482:       var resultPaths=event.data.resultPaths;

2483:       ShowPaths(resultPaths);

2486:       var resultPaths=[];

2487:       ShowPaths(resultPaths);

2516:     document.getElementById("detectPathExp").disabled=true;

2523:     document.getElementById("allShortestPaths").style.display="none";

2524:     document.getElementById("allShortestPathsP").style.display="none";

2527:            ShowShortestPathWorker();

2550:     resultPaths=allPaths;

2551:     if(resultPaths.length==0){

2557:        document.getElementById("detectPathExp").disabled=false;

2561:     var table=document.getElementById("allShortestPaths");

2569: 	for(var x in allPaths){

2570: 	    var nodes=allPaths[x].split("#");

2600:         mycurrent_button.addEventListener("click", function(e){ShowPathView(this.id);}, false);

2605: 	showPathFirst=0;

2609:     document.getElementById("detectPathExp").disabled=false;

2611:     document.getElementById("allShortestPaths").style.display="";

2612:     document.getElementById("allShortestPathsP").style.display="";

2616:     var total=resultPaths.length;

2618:     if(i>=resultPaths.length){

2621:     var nodes=resultPaths[i].split("#");

2708:        document.getElementById("detectPathExp").disabled=false;

2714:     generatePaths(swiss2, swiss1);

2731:         generatePaths(nodes[x], root);

2755:     var p=document.getElementById("allShortestPathsP");

2768:     var content="Results: "+showPathFirst+"-"+showPathEnd+" of "+resultPaths.length+" ";

2778:     if(showPathFirst==0){

2793: 	var newFirst=(resultPaths.length-resultPaths.length%10);

2794: 	if(newFirst==resultPaths.length){

2795: 	   newFirst=resultPaths.length-10;

2801:     if(showPathEnd==resultPaths.length){

2816:     if(showPathFirst==0){

2822:     var newFirst=showPathFirst-10;

2835:     if(showPathEnd==resultPaths.length){

2841:     var newFirst=showPathFirst+10;

2842:     if(newFirst >= resultPaths.length){

2843:        newFirst = (resultPaths.length-resultPaths.length%10);

2851: 	var total=resultPaths.length;

2852: 	if(showPathFirst >= total){

2853: 	   showPathFirst=(total-total%10);

2855: 	if(showPathFirst == total){

2856: 	   showPathFirst = total-10;

2858:     if(showPathFirst < 0){

2859: 	   showPathFirst = 0;

2861: 	showPathFirst=showPathFirst-(showPathFirst%10);

2862: 	showPathEnd=showPathFirst+10;

2863: 	if(showPathEnd > total){

2864: 	   showPathEnd = total;

2869:     for(var i=showPathFirst;i<showPathEnd;i++){

2942: 	document.getElementById("detectPathExp").disabled=true;

2947: 	document.getElementById("detectPathExp").disabled=false;

147:         path <- Sys.getenv("APPDATA", "")

176:         path <- file.path(d, exec)

207:     path <- NULL # cache the path to megadepth

183:     path2 <- Sys.which(cmd)

143: bin_paths <- function(

15: #' found via the environment variable \code{PATH}.

17: #' If you want to install Megadepth to a custom path, you can set the global

35: #' @importFrom xfun is_windows is_macos same_path

75:     exec <- file.path(tempdir(), exec_name)

145:         extra_path = getOption("megadepth.dir")) {

148:         path <- if (fs::dir_exists(path)) {

149:             file.path(path, dir)

152:         path <- "~/Library/Application Support"

153:         path <- if (fs::dir_exists(path)) file.path(path, dir)

154:         path <- c("/usr/local/bin", path)

156:         path <- c("~/bin", "/snap/bin", "/var/lib/snapd/snap/bin")

158:     path <- c(extra_path, path, pkg_file(dir, mustWork = FALSE))

160:     path <- path[path != ""]

163:         path <- c(tempdir(), path)

165:     path

168: # find an executable from PATH, APPDATA, system.file(), ~/bin, etc

177:         if (utils::file_test("-x", path)) {

180:             path <- ""

184:     if (path == "" || xfun::same_path(path, path2)) {

185:         if (path2 == "") {

188:         return(cmd) # do not use the full path of the command

190:         if (path2 != "") {

195:                 path,

197:                 path2,

203:     normalizePath(path)

209:         if (is.null(path)) {

210:             path <<- find_exec(

216:         path

109:     dirs <- bin_paths()

139:     message("megadepth has been installed to ", normalizePath(destdir))

159:     # remove empty paths potentially created by pkgfile

170:     for (d in bin_paths(dir)) {

217:     path <- file.path("inst", "assets", "_book.yml")

246:     gert::git_init(path = repo) 

207:         file.path(tmpdir, 'BiocBook.template'), 

218:     .fix_placeholders(file.path(repo, path), pkg = repo, usr = user)

219:     cli::cli_alert_success(cli::col_grey("Filled out `{cli::col_cyan(path)}` fields"))

222:     path <- "README.md"

223:     .fix_placeholders(file.path(repo, path), pkg = repo, usr = user)

224:     cli::cli_alert_success(cli::col_grey("Filled out `{cli::col_cyan(path)}` fields"))

227:     path <- "DESCRIPTION"

228:     .fix_placeholders(file.path(repo, path), pkg = repo, usr = user)

229:     cli::cli_alert_success(cli::col_grey("Filled out `{cli::col_cyan(path)}` fields"))

230:     cli::cli_alert_info(cli::col_grey("Please finish editing the `{cli::col_cyan(path)}` fields, including:"))

236:     path <- file.path("inst", "index.qmd")

237:     .fix_placeholders(file.path(repo, path), pkg = repo, usr = user)

238:     cli::cli_alert_success(cli::col_grey("Filled out `{cli::col_cyan(path)}` fields"))

239:     cli::cli_alert_info(cli::col_grey("Please finish editing the `{cli::col_cyan(path)}` fields, including the `Welcome` section"))

255:     version <- read.dcf(file.path(repo, "DESCRIPTION"))[1,"BiocBookTemplate"]

325:             path = "_temp",

362:         charToRaw('{ "source": { "branch": "gh-pages", "path": "/docs" } }'), 

386:         file.path("inst", "assets", "cover.png")

106: path <- system.file("files", package="PloGO2")

107: allDat = read.csv(file.path(path,"rice.csv") )

108: Group = read.csv(file.path(path, "group_rice.csv") ) [,2]

357:                         path <- system.file("extdata",package=paste0(input$Summarycompselect,"Expr"))

716:                                           path <- system.file("extdata",package=paste0(input$Summarycompselect,"Expr"))

358:                         load(paste0(path,"/geneid.rda"))

378:                                     load(paste0(path,"/quality.rda"))

388:                                     load(paste0(path,"/quality.rda"))

475:                               path <- system.file("extdata",package=paste0(input$Summarycompselect,"Expr"))

482:                                           tmpgeneexpr <- rbind(tmpgeneexpr,t(h5read(paste0(path,"/data",h5id,".h5"),"expr",index=list(NULL,match(currenth5gene,h5gene))))/1000)

485:                                     tmpgeneexpr <- t(h5read(paste0(path,"/data.h5"),"expr",index=list(NULL,match(currentgeneset[,2],Maindata$geneid))))/1000

724: ...(9 bytes skipped)...                                                   tmpgeneexpr <- rbind(tmpgeneexpr,t(h5read(paste0(path,"/data",h5id,".h5"),"expr",index=list(NULL,match(currenth5gene,h5gene))))/1000)

727:                                                 tmpgeneexpr <- t(h5read(paste0(path,"/data.h5"),"expr",index=list(NULL,match(currentgeneset[,2],Maindata$geneid))))/1000

118:                         tmpfile <- read.table(GenesetFileHandle$datapath,header=input$InputGenesetheader,sep=input$InputGenesetsep,quote=input$InputGenesetquote,stringsAsFa...(30 bytes skipped)...

401:                         tmptab <- read.table(input$Summaryuploadtabfile$datapath,stringsAsFactors=F,blank.lines.skip=TRUE)

405: ...(8 bytes skipped)...                Maindata$uploadgeneexpr <- as.matrix(read.table(input$Summaryuploadgeneexprfile$datapath,stringsAsFactors=F,blank.lines.skip=TRUE,row.names=1))

1917:                               tmp <- read.table(input$GSCAinteractiveload$datapath)

1946: ...(35 bytes skipped)... updateTextInput(session,"Formulainputtext","Input Formula",readLines(input$GSCAinteractiveload$datapath))

2412:                         Utidata$Maindata <- Utidata$rawdata <- read.table(UtiFileHandle$datapath,header=input$Utiheader,sep=input$Utisep,quote=input$Utiquote,stringsAsFactors=F,blank.lines.skip=TR...(15 bytes skipped)...

1626:             path = project_folder, recurse = TRUE,

3357:                                 path = report_path,

1569:     path_cols <- .path_cols_names()

2142:     path_col_names <- .path_cols_names()

1870:     stats_paths <- purrr::pmap(temp, function(...) {

1961:     stats_paths <- .stats_report(association_file,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

602: #' @importFrom fs path_ext

603: #' @importFrom tools file_path_sans_ext

605: .check_file_extension <- function(file_path) {

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

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

612:             file_path[compressed]

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

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

1092:         file = path,

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

1155:         file = path,

1251:         path,

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

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

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

1326:             path = path, additional_cols = additional_cols,

1331:             path = path, additional_cols = additional_cols,

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

1426:     file_ext <- .check_file_extension(path)

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

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

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

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

1547: # - root_folder: Path to the root folder

1549: #' @importFrom fs path dir_ls

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

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

1577:                 fs::path(

1578:                     fs::path(root_folder),

1589:             !!path_cols$project := NA_character_,

1590:             !!path_cols$quant := NA_character_,

1591:             !!path_cols$iss := NA_character_

1595:         project_folder <- fs::path(

1596:             fs::path(root_folder),

1600:             paste0(fs::path(

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

1618:             paste0(fs::path(

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

1634:             path = project_folder, recurse = TRUE,

1644:                     !!path_cols$project := project_folder,

1645:                     !!path_cols$quant := quant_found,

1646:                     !!path_cols$iss := iss_found

1681:         af_path,

1691:         path = af_path,

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

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

1835:         path_iss_col) {

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

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

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

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

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

1955:         path_iss_col,

1965:         path_iss_col = path_iss_col

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

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

2078:             class = "missing_path_col"

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

2131: #' @importFrom fs dir_ls as_fs_path

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

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

2269: #' @importFrom fs as_fs_path

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

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

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

2589:     wrapper <- function(path, import_matrix_args, progress) {

2591:             path = path,

3296:         report_path) {

3343:                         fs::dir_create(report_path)

3373:                                 path = report_path,

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

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

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

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

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

1845:     # If paths are all NA return

1927:     stats_paths

1960:     # Obtain paths

1967:     stats_paths <- stats_paths |>

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

1970:         stats_paths <- stats_paths |>

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

2006:         data_list = stats_paths$stats_files,

2022:     stats_paths <- stats_paths |>

2024:     stats_paths <- purrr::pmap(stats_paths, function(...) {

2042:     stats_paths <- stats_paths |>

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

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

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

634:     path <- pvalue_results@pwayCounts[[pathway]]

780:     path1 <- pvalue_results@pwayCounts1[[pathway]]

781:     path2 <- pvalue_results@pwayCounts2[[pathway]]

99: pathVarOneSample <- function(dat.mat, pways, test = c("chisq", "exact"), varStat = c("sd", 

131:     pathwayCounts <- lapply(lapply(olap.pways, function(x) table(x, deparse.level = 0)), function(x) if (len...(10 bytes skipped)...

206: pathVarTwoSamplesCont <- function(dat.mat, pways, groups, boot = 1000, varStat = c("sd", "mean", 

290: pathVarTwoSamplesDisc <- function(dat.mat, pways, groups, perc = c(1/3, 2/3), test = c("chisq", 

344:     pathwayCounts1 <- lapply(lapply(olap.pways1, function(x) table(x, deparse.level = 0)), 

354:     pathwayCounts2 <- lapply(lapply(olap.pways2, function(x) table(x, deparse.level = 0)), 

853:     pathDat1 <- as.data.frame(table(mixDat1))

855:     pathDat2 <- as.data.frame(table(mixDat2))

943:     pathname <- sapply(listPath, function(x) if (length(unlist(strsplit(x, "/"))) > 1) {

796:     plotPath1 <- ggplot(path1, aes(x = Cluster, y = Number_of_genes, fill = Cluster)) + geom_bar(stat = "identity", 

800:     plotPath2 <- ggplot(path2, aes(x = Cluster, y = Number_of_genes, fill = Cluster)) + geom_bar(stat = "identity", 

659:         plotPathway <- d + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

738:             plotPathway <- d + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

806:         plotPathway1 <- plotPath1 + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

809:         plotPathway2 <- plotPath2 + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

871:     plotPathDat1 <- ggplot(path...(136 bytes skipped)...("Number of genes") + theme(legend.position = "none") + ggtitle("Group 1") + xlab("") + ylim(0, max(pathDat1[,2], pathDat2[,2]))

872:     plotPathDat2 <- ggplot(path...(136 bytes skipped)...("Number of genes") + theme(legend.position = "none") + ggtitle("Group 2") + xlab("") + ylim(0, max(pathDat1[,2], pathDat2[,2]))

26: ...(25 bytes skipped)...ptions are TRUE or FALSE. If TRUE then the first column of the tab delimited file is expected to be path IDs. If FALSE, then the first column is expected to be pathway names.

645:     path <- as.data.frame(path)

646:     colnames(path) <- c("Cluster", "Number_of_genes")

653:     d <- ggplot(path, aes(x = Cluster, y = Number_of_genes, fill = Cluster)) + geom_bar(stat = "identity", 

663:             plotPathway <- plotPathway + annotate("text", x = sigCat, y = path[sigCat + 0.1, 

789:     path1 <- as.data.frame(path1)

790:     colnames(path1) <- c("Cluster", "Number_of_genes")

792:     path2 <- as.data.frame(path2)

793:     colnames(path2) <- c("Cluster", "Number_of_genes")

794:     yLimMax <- max(path1[, 2], path2[, 2])

813:             plotPathway1 <- plotPathway1 + annotate("text", x = sigCat, y = path1[sigCat + 

815:             plotPathway2 <- plotPathway2 + annotate("text", x = sigCat, y = path2[sigCat + 

20: #makeDBList put your pathways text file into a list

21: #pway$PATHNAME is the pathway names from the file

22: #pway$PATHID is a vector of pathway ID numbers is there are any. Otherwise it will be a vector filled with NA

23: #pway$GENES is a list of vectors, where each vector are the genes for a single pathway

25: #file is a tab delimited text file, where first and second columns are pathwayID and pathway name. The third (or last column is the genes associated with each pathway, seperated by commas.

33:         pways$PATHNAME <- as.vector(pwayTable[, 2])

34:         pways$PATHID <- as.vector(pwayTable[, 1])

35:         pways$GENES <- list(length(pways$PATHID))

37:         for (i in 1:length(pways$PATHID)) {

43:                 pways$PATHID <- pways$PATHID[-i]

44:                 pways$PATHNAME <- pways$PATHNAME[-i]

49:         pways$PATHNAME <- as.vector(pwayTable[, 1])

50:         pways$PATHID <- rep("NA", length(pways$PATHNAME))

51:         pways$GENES <- list(length(pways$PATHID))

53:         for (i in 1:length(pways$PATHID)) {

59:                 pways$PATHID <- pways$PATHID[-i]

60:                 pways$PATHNAME <- pways$PATHNAME[-i]

64:     names(pways$GENES) <- pways$PATHNAME

69: #pathVarOneSample

73: # 3. For each pathway, we extract the gene in our dataset and in which cluster they belong.

74: # 4. For each pathway, we look how the gene counts in each category and compare it to the reference counts with all th...(59 bytes skipped)...

78: # Output 1: tablePway columns are :pathway name, path...(46 bytes skipped)...or exact test,the percentage of genes from our dataset related to the total number of genes in each pathway, the number of genes from our dataset inside the pathway and the total number of genes inside the pathway

79: #Output 2: NAPways corresponds to the pathway names of the pathway having less than 10 genes for the Chi-Squared or also more than 500 genes for the exact tes.

80: # Output 3: genesInPway correspond to each pathway with the genes from the datasets belonging to it and in which cluster they were classsify.

83: # Output 6: pwayCounts is the genes counts of the each pathway in each cluster.

91: #Input 2: pways contains the pathways of interest (KEGG, REACTOME, etc...) in the same format that makeDBList

103:     # check if any GENES are in the pathway.

106:         stop("None of the genes in the data set are found in the given gene set or pathway")

125:     # olap.pways contains the genes are in each pathway with their cluster number

127:     names(olap.pways) <- pways$PATHNAME

130:     # list of tables of the number of genes in each cluster per pathway

140:     # Chi-Square or Exact test to compare the reference and the pathway distribution

142:         # chisq test and ajustment of the pvalue for each pathway

143:         pvals.pways <- sapply(pathwayCounts, function(x) if (sum(x) >= 10) {

154:         # Exact test and ajustment of the pvalue for each pathway

157:         # We perform the multinomial test on the pathway containing between 10 and 500 genes because a bigger number will involve too many possibilities ...(11 bytes skipped)...

158:         pvals.pways <- sapply(pathwayCounts, function(x) if (sum(x) >= 10 & sum(x) < 500) {

170:     xtab <- data.table(PwayName = pways$PATHNAME[not_na], PwayID = pways$PATHID[not_na], APval = apvals.pways, 

172:         NumOfGenesFromDataSetInPathway = lengths(olap.pways[not_na]), PathwaySize = pways$SIZE[not_na])

176: ...(50 bytes skipped)...ab, NAPways=pval.NA, genesInPway=olap.pways, refProb=pexp, refCounts=pexp * length(mix), pwayCounts=pathwayCounts, numOfClus=nmix, varStat=varStat, genesInClus=mix, var=vs)

181: #pathVarTwoSamplesCont

184: # 2. For each pathway, we extract the gene in our dataset.

185: # 3. For each pathway, we look how its genes are distributed and compare the 2 groups using the bootstrap Kolmogorov-S...(12 bytes skipped)...

189: # Output 1: tablePway columns are :pathway name, pathway IDs, adjusted p-value ffrom the boot KS test, the number of genes from our dataset inside the pathway and the total number of genes inside the pathway.

190: #Output 2: NAPways corresponds to the pathway names of the pathway having no genes inside the dataset.

191: # Output 3: genesInPway correspond to the genes from the dataset belonging to each pathway

200: #Input 2: pways contains the pathways of interest (KEGG, REACTOME, etc...) in the same format that makeDBList

209:     # check if any GENES are in the pathway

212:         stop("None of the genes in the data set are found in the given gene set or pathway")

236:     # olap.pways contains the genes from the dataset in each pathway

238:     names(olap.pways) <- pways$PATHNAME

239:     # We compare the two densities (one for each group) of the genes of each pathway with the Kolmogorov-Smirnow test.       

251:     xtab <- data.table(PwayName = pways$PATHNAME[not_na], PwayID = pways$PATHID[not_na], APval = apvals, 

253:         NumOfGenesFromDataSetInPathway = lengths(olap.pways[not_na]), PathwaySize = pways$SIZE[not_na])

261: #pathVarTwoSamplesDisc

265: # 3. For each pathway, we extract the gene in our dataset and in which cluster they belong.

266: # 4. For each pathway, we look at the gene counts in each category and compare the 2 samples to each other with all th...(60 bytes skipped)...

269: # Output 1: tablePway columns are :pathway name, path...(11 bytes skipped)...justed p-value, the percentage of genes in our dataset related to the total number of genes in each pathway, the number of genes from our dataset inside the pathway and the total number of genes inside the pathway.

270: #Output 2: NAPways corresponds to the pathway names of the pathway having no genes inside the dataset.

271: # Output 3: genesInPway1 corresponds to the genes from the dataset belonging to each pathway in the first sample

272: # Output 4: genesInPway2 corresponds to the genes from the dataset belonging to each pathway in the second sample

273: # Output 5: pwayCounts1 corresponds to a list of tables of the number of genes in each cluster per pathway for group 1

274: # Output 6: pwayCounts2 corresponds to a list of tables of the number of genes in each cluster per pathway for group 2

283: #Input 2: pways contains the pathways of interest (KEGG, REACTOME, etc...) in the same format that makeDBList

294:     # check if any GENES are in the pathway

297:         stop("None of the genes in the data set are found in the given gene set or pathway")

338:     # olap.pways contains the genes from the dataset in each pathway

340:     names(olap.pways1) <- pways$PATHNAME

342:     names(olap.pways2) <- pways$PATHNAME

343:     # list of tables of the number of genes in each cluster per pathway

353:     # list of tables of the number of genes in each cluster per pathway

364:         # chisq test and ajustment of the pvalue for each pathway

365:         pvals.pways <- sapply(pways$PATHNAME, function(x) if (sum(pathwayCounts1[x][[1]]) >= 

367:             exp.val <- pathwayCounts1[x][[1]]  #forgot the.val

368:             chi <- sum((pathwayCounts2[x][[1]] - exp.val)^2/exp.val)

374:         pval.NA <- pways$PATHNAME[-not_na]

377:         # Exact test and ajustment of the pvalue for each pathway

380:         # We perform the multinomial test on the pathway containing between 10 and 500 genes because a bigger number will involve too many possibilities ...(11 bytes skipped)...

381:         pvals.pways <- sapply(pways$PATHNAME, function(x) if (sum(pathwayCounts1[x][[1]]) >= 

382:             10 & sum(pathwayCounts1[x][[1]]) < 500) {

383:             pexp <- pathwayCounts1[x][[1]]/sum(pathwayCounts1[x][[1]])

384:             multinomial.test(as.vector(pathwayCounts2[x][[1]]), as.vector(pexp), useChisq = FALSE)$p.value

391:         pval.NA <- pways$PATHNAME[-not_na]

395:     xtab <- data.table(PwayName = pways$PATHNAME[not_na], PwayID = pways$PATHID[not_na], APval = apvals.pways, 

397:         NumOfGenesFromDataSetInPway = lengths(olap.pways1[not_na]), PathwaySize = pways$SIZE[not_na])

402: ...(36 bytes skipped)...", tablePway=xtab, NAPways=pval.NA, genesInPway1=olap.pways1, genesInPway2=olap.pways2, pwayCounts1=pathwayCounts1, pwayCounts2=pathwayCounts2, groups=groups, groupNames=groupNames, var1=var_1, var2=var_2, varStat=varStat)

409: #It is a function that returns the significant pathway(s),which category(ies) from this pathway are significant and which gene(s) belongs to this(ese) category(ies).

413: # Output 1: genesInSigPways1 contains the genes per significant pathway belonging to the significant category.

414: #Output 2: sigCatPerPway contains the category(ies) per pathway that are significant.

418: #Input 1: pvalue_results is result from the pathVarOneSample function

430:         warning("There are no significant pathways. Quitting significant_category function and returning empty object")

434:     # PathName that were significant in xtab.

436:     # The list of table with the number of genes in each cluster from the significant pathways

442:     # results contain the p-value for each category in each pathway computed with the binomial test.

450:     # For each significant pathway we look which category(ies) is are significant and the genes

477: #It is a function that returns the significant pathways and which genes belongs to these #pathways.

481: # Output 1: genesInSigPways1 contains the genes belonging to each significant pathway

485: #Input 1: pvalue_results is result from the pathVarTwoSamplesCont function

493:         warning("There are no significant pathways. Quitting significant_category function and returning empty object")

497:     # Pathways that were significant in xtab.

499:     # Genes from the dataset inside each significant pathway

507: #It is a function that returns the significant pathways and which genes belong to these pathways

511: # Output 1: genesInSigPways1 contains the genes belonging to each significant pathway in significant categories in the first sample

512: # Output 2: genesInSigPways2 contains the genes belonging to each significant pathway in significant categories in the second sample

513: # Output 3: sigCatPerPway contains the significant categories in each pathway

517: #Input 1: pvalue_results is result from the pathVarTwoSamplesDisc function

527:         warning("There are no significant pathways. Quitting significant_category function and returning empty object")

531:     # PathName that were significant in xtab.

533:     # The list of table with the number of genes in each cluster from the significant pathways

540:     # results contain the p-value for each category in each pathway computed with the binomial

550:     # For each significant pathway we look which category(ies) are significant and the genes belonging to this(ese) category(ies). ...(81 bytes skipped)...

576: ...(77 bytes skipped)...es cases and then use sigOneSample, sigTwoSamplesCont, or sigTwoSamplesDisc to find the significant pathways.

582: #Input 1: pvalue_results is result from the pathVarOneSample, pathVarTwoSamplesCont, or pathVarTwoSamplesDisc function.

602: #It is a function that returns the plot of the reference counts along with the plot of a chosen #pathway. This function is made for output from pathVarOneSample.

605: # plot of the reference and a pathway counts

608: #Input 1: pvalue_results is result from the pathVarOneSample function

609: #Input 2: pathway is the chosen pathway you want to plot.

613: #If sig is not NULL, the function will check if the pathway is a significant one and if yes the

619: plotOneSample <- function(pvalue_results, pathway, sig) {

620:     mp <- pathway

621:     # If the name of the pathway is two long it will cut it into two lines in the plot.

644:     # data frame for the pathway distribution

656:     # If the pathway is one of the significant ones, the title will be in red. and the categories, if any, we be high...(24 bytes skipped)...

657:     if (pathway %in% names(category)) {