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")){

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)

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

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

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

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

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

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

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

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

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

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

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

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

628: pathwayEnrichment <- function(genes,

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

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

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

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

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

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

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

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

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

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

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

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

353:   return(path)

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

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

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

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

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

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

1: #' KEGG pathway enrichment

22: #' @return KEGG pathway enrichment results

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

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

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

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

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

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

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

106:     for (i in seq_along(pathT))

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

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

114:                      paste(pathT[i])))

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

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

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

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

129:         ID = pathT,

141: #' Reactome pathway enrichment

163: #' @return Reactome pathway enrichment results

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

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

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

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

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

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

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

244:     for (i in seq_along(pathT))

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

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

252:                      paste(pathT[i])))

258:         ID = pathT,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

349:                   by = "pathway",

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

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

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

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

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

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

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

423:   pathTable <-

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

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

430:   return(pathTable)

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

478:         pathID = tmp[, 3],

479:         pathTerm = tmp[, 1]

506: #' @return Wiki Pathway Enrichment

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

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

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

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

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

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

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

579:   for (i in seq_along(pathT))

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

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

586:                           paste(pathT[i])))

593:       ID = pathT,

594:       Term = pathTerms,

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

626: #' @return Pathway Enrichment

670:     pathTable <-

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

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

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

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

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

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

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

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

720:   for (i in seq_along(pathT))

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

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

726:                           paste(pathT[i])))

731:       ID = pathT,

732:       Term = pathTerms,

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

745: #' @param gmtName Custom pathway gmt file

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

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

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

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

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

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

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

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

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

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

459:       rWikiPathways::downloadPathwayArchive(

463:       rWikiPathways::downloadPathwayArchive(

467:       rWikiPathways::downloadPathwayArchive(

485: #' WikiPathways Enrichment

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

43:         path <- path.index[path.index != ""]

41:         path.index <- substr(get_pathway_text,start,final)

26:       pathway_start <- str_locate_all(pattern = "PATHWAY", get_GO_text)[[1]][2]

27:       pathway_end <- str_locate_all(pattern = "BRITE", get_GO_text)[[1]][1]

28:       pathways <- substr(get_GO_text,pathway_start+1,pathway_end-1)

34:         pathway <- as.character(unlist(str_extract_all(unlist(pathways)[i],"hsa[a-zA-Z0-9]{5}")))

36:         get_pathway <- GET(paste("http://rest.kegg.jp/get/map",substr(pathway,4,nchar(pathway)),sep = ""))

37:         get_pathway_text <- content(get_pathway, "text")

71:   repeated.pathways <- names(which(table(KEGG.data$KEGG_hsa) > 1))

10: DEGsToPathways <- function(geneList){

42:         path.index <- strsplit(path.index,split = " ")[[1]]

44:         path <- path[2]

59:         KEGG.data <- rbind(KEGG.data,c(as.character(path),as.character(name), as.character(description),as.character(class),as.character(gene.name)))

66:   names(KEGG.data) <- c("KEGG_Path","Name","Description","Class","Genes")

1: #' The function uses the DEGs to retrieves the different pathways in which those DEGs involve any interaction.

3: #' The function uses the DEGs to retrieves the different pathways in which those DEGs involve any interaction.

4: #' @param geneList A list which contains the DEGs that will be used to retrieve the related pathways to them.

5: #' @return A list with the pathways that contain relation to the DEGs within the geneList parameter.

18:   cat("Retrieving information about KEGG pathways...\n")

29:       pathways <- strsplit(pathways,split = "\n")

31:       index <- grep("hsa", unlist(pathways))

35:         if (length(pathway) == 0) break

39:         start <- str_locate_all(pattern = "ENTRY", get_pathway_text)[[1]][2]

40:         final <- str_locate_all(pattern = "Pathway", get_pathway_text)[[1]][2]

46:         start <- str_locate_all(pattern = "\nNAME ", get_pathway_text)[[1]][2]

47:         final <- str_locate_all(pattern = "\nDESCRIPTION", get_pathway_text)[[1]][2]

48:         name <- substr(get_pathway_text,start + 8,final - 12)

50:         start <- str_locate_all(pattern = "\nDESCRIPTION ", get_pathway_text)[[1]][2]

51:         final <- str_locate_all(pattern = "\nCLASS", get_pathway_text)[[1]][2]

52:         description <- substr(get_pathway_text,start + 1,final - 6)

55:         start <- str_locate_all(pattern = "\nCLASS ", get_pathway_text)[[1]][2]

56:         final <- str_locate_all(pattern = "\nPATHWAY_MAP", get_pathway_text)[[1]][2]

57:         class <- substr(get_pathway_text,start + 7,final - 12)

69:   # Collapse repeated pathways

72:   for (pathway in repeated.pathways){

73:     index <- which(KEGG.data$KEGG_hsa == pathway,)

85:   #cat("Retrieving information about Reactome pathways...\n")

7: #' DEGsToPathways(c("BRCA1","MLANA"))

21:   path <- Sys.getenv(

31:   patharch <- paste0(path, arch)

36:     ## so we use the 8+3 form of the path and replace slashes

22:     x = "RHDF5LIB_RPATH",

37:     patharch <- gsub(x = utils::shortPathName(patharch),

49:                                       patharch, winlibs)

52:                                       patharch, patharch, .getDynamicLinks())

60:                                       patharch, winlibs)

63:                                       patharch, patharch, patharch, .getDynamicLinks())

71:                                       patharch, winlibs)

74:                                       patharch, patharch, patharch, .getDynamicLinks())

82:                                       patharch, winlibs)

85:                                       patharch, patharch, patharch, patharch, patharch, .getDynamicLinks())

18: #' @rawNamespace if(tools:::.OStype() == "windows") { importFrom(utils, shortPathName) }

1724:             device = "png", path = saveFolder, dpi = 100, width = 21,

1853:     path_cpdMeta <- paste(saveFolder, "/", annotationName,

1871:     path_specMeta <- paste(saveFolder, "/", annotationName,

1883:         path_var <- paste(saveFolder, "/", annotationName, "_", i, ".csv",

1918:     path_summary <- paste(saveFolder, "/", annotationName, "_summary.csv",

1116:     .filepath <- x@filepath[i]

1863:     tmp_filepath <- filepath(object)

2045:     .spectraPaths <- resSpectra$spectraPaths

2182: resetAnnot_spectraPathMetadata <- function(previousAnnotation, spectraPaths,

2186:         .spectraPaths <- filepath(previousAnnotation)

1076:     return(tools::file_path_sans_ext(basename(object@filepath)))

1386: #' @param saveFolder (str) Path of folder where annotationParameters_summary.csv

1399: #' spectraPaths <- c('./path/file1', './path/file2', './path/file3')

1610: #' @param saveFolder (str) Path of folder where annotationParameters_summary.csv

1703:     # @param saveFolder (str) Path where plots will be saved

1727:         # output path

1758: #' @param saveFolder (str) Path of folder where the annotation result csv will

1855:     utils::write.csv(tmp_outCpdMeta, file = path_cpdMeta, row.names = FALSE,

1858:     if (verbose) { message("Compound metadata saved at ", path_cpdMeta) }

1873:     utils::write.csv(tmp_outSpecMeta, file = path_specMeta, row.names = FALSE,

1876:     if (verbose) { message("Spectra metadata saved at ", path_specMeta) }

1885:         utils::write.csv(tmp_var, file = path_var, row.names = TRUE,

1889:             message("Peak measurement \"", i, "\" saved at ", path_var)

1920:     utils::write.csv(tmp_summary, file = path_summary, row.names = TRUE,

1923:     if (verbose) { message("Summary saved at ", path_summary) }

24:             length(object@filepath), " samples. \n", sep = "")

53: # @filepath length. Slot type is not checked as \code{setClass} enforces it.

78: #' # Paths to spectra files

119: #' # Paths to spectra files

160: #' # Paths to spectra files

206: #' # Paths to spectra files

253: #' # Paths to spectra files

286: # filepath

287: setGeneric("filepath", function(object, ...) standardGeneric("filepath"))

288: #' filepath accessor

290: #' @return (str) A character vector of file paths, of length number of spectra

293: #' @aliases filepath

300: #' # Paths to spectra files

319: #' filepath(annotation)

324: setMethod("filepath", "peakPantheRAnnotation", function(object) {

325:     object@filepath

343: #' # Paths to spectra files

386: #' # Paths to spectra files

430: #' # Paths to spectra files

472: #' # Paths to spectra files

512: #' # Paths to spectra files

552: #' # Paths to spectra files

593: #' # Paths to spectra files

636: #' # Paths to spectra files

695: #' # Paths to spectra files

742: #' # Paths to spectra files

788: #' # Paths to spectra files

817: #' nbSamples accessor established on filepath

828: #' # Paths to spectra files

852:     return(length(object@filepath))

868: #' # Paths to spectra files

913: #' # Paths to spectra files

946:     nbSample <- length(object@filepath)

953:         rownames(tmpAnnotation) <- object@filepath

961:         rownames(tmpAnnotation) <- object@filepath

977:     rownames(tmpAnnotation) <- object@filepath

1000: #' # Paths to spectra files

1041: #' filename accessor by spliting filepath

1052: #' # Paths to spectra files

1134:         FIR = .FIR, uROI = .uROI, filepath = .filepath,

1214: #' # Paths to spectra files

1398: #' # Paths to spectra files

1416: #' savePath        <- tempdir()

1419: #' outputAnnotationParamsCSV(emptyAnnotation, saveFolder=savePath, verbose=TRUE)

1488: #' # Paths to spectra files

1627: #' # Paths to spectra files

1652: #' savePath1       <- tempdir()

1653: #' outputAnnotationDiagnostic(annotation, saveFolder=savePath1, savePlots=FALSE,

1771: #' # Paths to spectra files

1796: #' savePath1       <- tempdir()

1797: #' outputAnnotationResult(annotation, saveFolder=savePath1,

1867:     tmp_outSpecMeta <- data.frame(filepath = tmp_filepath,

1941: #' the slots (\code{filepath} (from \code{spectraPaths}), \code{ROI},

1947: #' @param spectraPaths NULL or a character vector of spectra file paths, to set

1972: #' (\code{cpdID}, \code{cpdName}, \code{ROI}, \code{filepath}, \code{TIC},

1984: #' # Paths to spectra files

2188:             message("  Previous \"filepath\" value kept")

2415: #' # Paths to spectra files

80: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

95: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

121: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

136: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

162: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

177: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

208: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

223: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

255: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

270: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

302: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

317: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

345: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

360: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

388: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

403: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

432: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

447: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

474: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

489: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

514: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

529: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

554: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

569: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

595: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

610: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

638: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

653: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

697: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

712: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

744: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

759: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

790: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

805: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

830: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

845: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

870: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

885: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

915: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

930: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

1002: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

1017: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

1054: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

1069: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

1216: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

1231: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

1412: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

1490: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

1505: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

1629: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

1644: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

1773: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

1788: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,

1931:     function(previousAnnotation, spectraPaths = NULL, targetFeatTable = NULL,

1939: #' \code{spectraPaths}) or compounds (\code{targetFeatTable}) are passed, the

1986: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

2000: #' smallAnnotation  <- peakPantheRAnnotation(spectraPaths=spectraPaths, 

2011: #' newSpectraPaths  <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

2015: #'                                     spectraPaths=newSpectraPaths,

2026:     function(previousAnnotation, spectraPaths, targetFeatTable, uROI, FIR,

2042:     # spectraPaths, spectraMetadata

2043:     resSpectra <- resetAnnot_spectraPathMetadata(previousAnnotation,

2044:                                         spectraPaths, spectraMetadata, verbose)

2061:     # Create new object In all case (old or new value) spectraPaths and

2063:     peakPantheRAnnotation(spectraPaths = .spectraPaths,

2181: # resetAnnotation spectraPaths, spectraMetadata

2185:     if (all(is.null(spectraPaths))) {

2208:         .spectraPaths <- spectraPaths

2210:             message("  New \"spectraPaths\" value set")

2229:     return(list(spectraPaths = .spectraPaths,

2417: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),

2431: #' smallAnnotation  <- peakPantheRAnnotation(spectraPaths=spectraPaths,

720:     path <- c(anc_from[1:i], rev(anc_to[1:(j-1)]))

726:     path <- get.path(phylo, from, to)

694:     path_length <- sapply(1:(root-1), function(x) get.path_length(tr, root, x))

710: get.path <- function(phylo, from, to) {

978:     pathLength <- sapply(1:length(tr$tip.label), function(i) {

725: get.path_length <- function(phylo, from, to, weight=NULL) {

695:     i <- which.max(path_length)

696:     return(get.path(tr, root, i))

699: ##' path from start node to end node

702: ##' @title get.path

721:     return(path)

728:         return(length(path)-1)

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

744:         ee <- get_edge_index(df, path[i], path[i+1])

979:         get.path_length(tr, i, root, yscale)

982:     ordered_tip <- order(pathLength, decreasing = TRUE)

664:     path <- name.gdsn(node, TRUE)

175: .var_path <- function(var.name, prefix)

173: # Variable path

667:         varname <- .var_path(substring(varname, 2L), "@")

668:     fullvarname <- paste(path, varname, sep="/")

676:         if (path == "genotype")

679:             varname2 <- path

693:             if (path == "genotype")

286:   for (path in filepaths) {

39:       cbu.path <- "/export/valenfs/data/processed_data/experiment_tables_for_R/"

230:     cbu.path <- "/export/valenfs/data/processed_data/experiment_tables_for_R/"

913:     cbu.path <- "/export/valenfs/data/processed_data/experiment_tables_for_R/"

277: findFromPath <- function(filepaths, candidates, slot = "auto") {

501: filepath <- function(df, type, basename = FALSE) {

505:   paths <- lapply(df$filepath, function(x, df, type) {

642:       paths <- filepath(df, type)

358:     reversePaths <- df$reverse[!(df$reverse %in% c("", "paired-end"))]

7: #' @param file relative path to a ORFik experiment. That is a .csv file following

10: #' also be full path to file, then in.dir argument is ignored.

13: #' it to disc. Does not apply if file is not a path, but a data.frame. Also

14: #' does not apply if file was given as full path.

28: #' # save.experiment(df, file = "path/to/save/experiment")

30: #' # read.experiment("path/to/save/experiment")

32: #' # read.experiment("experiment", in.dir = "path/to/save/")

40:       if (file.exists(pasteDir(cbu.path, basename(file))))

41:         file <- pasteDir(cbu.path, basename(file))

103: #' @param txdb A path to TxDb (prefered) or gff/gtf (not adviced, slower)

105: #' @param fa A path to fasta genome/sequences used for libraries, remember the

169: #' # Save with: save.experiment(df, file = "path/to/save/experiment.csv")

231:     if (dir.exists(cbu.path)) { # This will only trigger on CBU server @ UIB

233:       message(cbu.path)

234:       saveDir <- cbu.path

253: #' #save.experiment(df, file = "path/to/save/experiment.csv")

255: #' #save.experiment(df, file = "path/to/save/experiment")

270: #' @param filepaths path to all files

287:     hit <- names(unlist(sapply(candidates, grep, x = path)))

290:     hitRel <- names(unlist(sapply(candidates, grep, x = gsub(".*/", "", path))))

831:       fext[compressed] <-file_ext(file_path_sans_ext(files[compressed],

903: #' ## Path above is default path, so no dir argument needed

907: #' #list.experiments(dir = "MY/CUSTOM/PATH)

911:   experiments <- list.files(path = dir, pattern = "\\.csv")

914:     if (dir.exists(cbu.path)) { # If on UIB SERVER

915:       dir <- cbu.path

916:       experiments <- list.files(path = dir, pattern = "\\.csv")

22: #' df <- read.experiment(filepath) # <- valid ORFik .csv file

198:     df[4,] <- c("libtype", "stage", "rep", "condition", "fraction","filepath",

205:     df[4,] <- c("libtype", "stage", "rep", "condition", "fraction","filepath")

208:   # set file paths

211:   df[5:(5+length(files)-1), 1] <- findFromPath(files, libNames(), libtype)

214:   df[5:(5+length(files)-1), 2] <- findFromPath(files, stages, stage)

216:   df[5:(5+length(files)-1), 3] <- findFromPath(files, repNames(), rep)

218:   df[5:(5+length(files)-1), 4] <- findFromPath(files, conditionNames(), condition)

220:   df[5:(5+length(files)-1), 5] <- findFromPath(files, fractionNames(), fraction)

355:   files <- df$filepath

356:   if (length(df$filepath) == 0) stop("df have no filepaths!")

426: #' Get variable name per filepath in experiment

488: #' Get relative paths instead of full. Only use for inspection!

489: #' @return a character vector of paths, or a list of character with 2 paths per,

496: #' filepath(df, "default")

498: #' # filepath(df, "bedo")

500: #' # filepath(df, "pshifted")

506:     i <- which(df$filepath == x)

509:       out.dir <- paste0(dirname(df$filepath[1]), "/pshifted/")

539:       out.dir <- paste0(dirname(df$filepath[1]), "/",type,"/")

555:     if (is.null(input)) stop("filepath type not valid!")

559:   if (all(lengths(paths) == 1)) {

560:     paths <- unlist(paths)

562:   return(paths)

643:       libs <- bplapply(seq_along(paths),

644:                        function(i, paths, df, chrStyle, param, strandMode, varNames) {

646:         fimport(paths[i], chrStyle, param, strandMode)

647:       }, BPPARAM = BPPARAM, paths = paths, chrStyle = chrStyle, df = df,

688: #' dirname(df$filepath[1]),

716:                        out.dir = dirname(df$filepath[1]),

758:                        remove.file_ext(df$filepath[i], basename = TRUE),

274: #' else must be a character vector of length 1 or equal length as filepaths.

279:     if(length(slot) != 1 & length(slot) != length(filepaths)) {

359:     files <- c(files, reversePaths)

378:     stop("Duplicated filepaths in experiment!")

478: #' Get filepaths to ORFik experiment

482: #' default filepaths without warning. \cr

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]

125:                                  host = "grch37.ensembl.org", path = "/biomart/martservice",

130:                                  host = "grch38.ensembl.org", path = "/biomart/martservice",

138:                                  host = "grch37.ensembl.org", path = "/biomart/martservice",

132:     path <- ls(x, all.names = FALSE)

208:     path <- lol_path(x)

290:     path <- lol_path(x)

272: lol_path <- function(x) x[["path"]]

172:     paths <- lol_path(x)

1: .lol_visit_impl <- function(x, path, index, dict)

5: .lol_visit_impl.default <- function(x, path, index, dict) {

6:     dict[[path]] <- append(dict[[path]], list(index))

7:     attr(dict[[path]], "leaf") <- TRUE

15: .lol_visit_impl.list <- function(x, path, index, dict) {

18:     dict[[path]] <- append(dict[[path]], list(index))

19:     attr(dict[[path]], "leaf") <- FALSE

29:     ## logic for building out path names

30:     ## starting with current node of the nested list and extending the path by

32:     if (identical(path, ".")) {

33:         path <- nms

36:             path <- paste0(path, nms)

38:             path <- paste0(path, ".", nms)

44:         .lol_visit_impl(x[[i]], path[[i]], append(index, i), dict)

48:     function(lol, dict, path = .lol_path(dict), class = "lol")

53:         list(lol = lol, dict = dict, path = path),

75: #'     path, number of occurrences, and leaf status of each unique

76: #'     path.

129: .lol_path <-

133:     is_leaf <- .lol_is_leaf(x)[path]

135:         path = path,

136:         n = unname(.lol_lengths(x)[path]),

139:     arrange(tbl, .data$path)

142: .lol_valid_path <-

143:     function(x, path)

145:     ok <- .is_character_0(path) || path %in% lol_path(x)$path

146:     ok || stop("'path' not in 'x':\n", "  path: '", path, "'")

153: #' @param path character(1) from the tibble returned by `lol_path(x)`.

156: #'     to contain just the elements matching `path` as 'top-level'

164:     function(x, path = character())

168:         .is_character_0(path) || .is_scalar_character(path),

169:         .lol_valid_path(x, path)

173:     idx <- paths$path[startsWith(paths$path, path)]

174:     paths <- paths[paths$path %in% idx,]

175:     dict <-  .lol_dict(x)[paths$path]

190: #'     of rows in `lol_path()`.

209:     ## FIXME: don't allow filtering on 'path$path'

210:     path <- filter(path, ...)

211:     dict <- .lol_dict(x)[path$path]

213:     .lol(.lol_lol(x), dict, path, class(x))

219: #'     corresponding to a single `path`.

222: #'     corresponds to an element found at `path` in the list-of-lists

227:     function(x, path)

231:         .is_scalar_character(path),

232:         .lol_valid_path(x, path)

235:     value <- lapply(.lol_dict(x)[[path]], function(idx) lol[[idx]])

236:     names(value) <-  rep(path, length(value))

257:     function(x, path)

259:     value <- lol_lpull(x, path)

265: #' @description `lol_path()` returns a tibble representing the paths

269: #' plol |> lol_path()

293:         "# number of distinct paths: ", NROW(path), "\n",

297:         "# lol_path():\n",

300:     print(path, ...)

17:     ## building out the various paths

67: #'     individual paths from across the list-of-lists.

74: #'     paths through the list, as well as a tibble summarizing the

177:     .lol(.lol_lol(x), dict, paths, class(x))

183: #' @description `lol_filter()` filters available paths based on

295:         "# number of leaf paths: ", sum(is_leaf), "\n",

568:         path<-h[2]

710:         path<-paste(stringr::str_sub(k, 1, 3),

858:             path<-stringr::str_split(s[1], "__")[[1]]

366:     notin_path<-vapply(elem_names, function(e){

369:         nb_path<-length(first_item[first_item %in% "X"])

387:     kegg_path<-pathways[stringr::str_sub(pathways, 1, 3) == "hsa"]

390:     path_walks_k<-vapply(kegg_path, function(x){

396:     wp_path<-pathways[stringr::str_sub(pathways, 1, 2) == "WP"]

397:     path_walks_w<-vapply(wp_path, function(x){

404:     path_walks_r<-vapply(first_walks_r, function(x){

425:     path_walks<-rbind(final_walks_r, path_walks_k,path_walks_w)

536:     cluster_elem<-save_cluster_elem<-listele[[1]];notin_path<-listele[[2]]

585:                 path_inter<-tagged[tagged$path == path,]

601:     heatmap<-listhtmp[[1]]; notin_path<-listhtmp[[2]]; hierapath<-listhtmp[[3]]

670:     rea_path<-sorted_path[stringr::str_sub(sorted_path, 1, 3) == "R-H"]

708:     kegg_path<-sorted_path[stringr::str_sub(sorted_path, 1, 3) == "hsa"]

740:     wp_path<-sorted_path[stringr::str_sub(sorted_path, 1, 2) == "WP"]

771: type_path<-function(sorted_path, hierapath){

800:     path_types<-unique(types$root)

802:         type_path<-types[types[, 2] %in% p, 1]#concerned pathways

948: filter_path<-function(tagged,size){

949:     path_inter<-as.vector(tagged[,4])

950:     sorted_path<-apply(size,1,function(x){ #sort pathways obtained

951:         path_elem<-as.integer(x[4])+as.integer(x[8])

965:     central<-listparam[[5]]; no_path<-listparam[[6]];

969:     sorted_path<-filter_path(tagged,size)

971:     path_walks<-listpath[[1]]; max<-listpath[[2]]

977:     heatmap<-listtab[[1]]; notin_path<-listtab[[2]]; hierapath<-listtab[[3]]

996:         path_cat<-stringr::str_split(i[6], ", ")[[1]]

435:     pathidtoname <- as.list(reactome.db::reactomePATHID2NAME)

516:     hierapath<-vapply(root_ids, function(r){

542:     heatmap<-listhiera[[1]]; hierapath<-listhiera[[2]]

963:     size<-listparam[[1]]; pathways<-listparam[[2]]; tagged<-listparam[[3]];

970:     listpath<-sort_hiera(sorted_path)

370:         if(element == TRUE && nb_path == 0){list(e)}

373:     notin_path<-unname(unlist(notin_path))

381:     if (element == TRUE){return(list(cluster, notin_path))}

388:     kegg_path<-paste(stringr::str_sub(kegg_path,1,3),

389:                         stringr::str_sub(kegg_path,5),sep="")

393:     path_walks_k<-as.data.frame(sort(unlist(path_walks_k)))

394:     if(ncol(path_walks_k) == 0){path_walks_k<-data.frame(walks=character())}

400:     path_walks_w<-as.data.frame(sort(unlist(path_walks_w)))

401:     if(ncol(path_walks_w) == 0){path_walks_w<-data.frame(walks=character())}

412:     path_walks_r<-rm_vector(unname(unlist(path_walks_r)))

413:     path_walks_r<-path_walks_r[stringr::str_detect(path_walks_r, ">")]

415:     final_walks_r<-vapply(path_walks_r, function(x){

416:         dupl<-which(stringr::str_detect(path_walks_r, x))

417:         dupl<-dupl[-which(dupl == which(path_walks_r == x))]

424:     names(final_walks_r)<-names(path_walks_w)<-names(path_walks_k)<-"walks"

426:     max<-max(stringr::str_count(path_walks[,1],">"))+1

427:     return(list(path_walks, max))

434:                                         treeview, no_path, list_elem){

455:                 paste("'", size[size$path == node, 2], "/",

456:                         size[size$path == node, 4], sep=""),

457:                 paste("'", size[size$path == node, 6], "/",

458:                         size[size$path == node, 8], sep=""),NA)

463:     colnames(heatmap)<-c("path_name", "path_id", "meta_ratio", "gene_ratio",

466:     heatmap[which(heatmap[, 4] == "'/"), 4]<-"'0/0";tags<-no_path$tag

480: cluster_hiera<-function(heatmap, size, tagged, no_path){

532: cluster_htmp<-function(heatmap, tags, size, tagged, no_path){

538:     cluster_elem<-cluster_elem[!(cluster_elem %in% notin_path)]

539:     heatmap<-heatmap[,c("path_name", "path_id", "meta_ratio", "gene_ratio",

541:     listhiera<-cluster_hiera(heatmap, size, tagged, no_path)

550:         if(x[2] %in% tagged$path){

556:     names(heatmap)<-c("path_name", "path_id", "meta_ratio", "gene_ratio",

558:     return(list(heatmap, notin_path, hierapath, save_cluster_elem))

562: final_tab<-function(build_hm, pathways, size, sorted_path, no_path,

564:     heatmap<-hiera_info(pathways, size, sorted_path, build_hm,

565:                         no_path, list_elem)

566:     sub_htmp<-heatmap[2:nrow(heatmap),]; tags<-no_path$tag #direct interactions

569:         pre_elem<-c(size[size$path %in% path, 3], size[size$path %in% path, 7])

586:                 path_inter<-path_inter[path_inter$tag ==

588:                 if(nrow(path_inter)>0){list("X")}

600:     listhtmp<-cluster_htmp(heatmap, tags, size, tagged, no_path)

603:     return(list(heatmap, notin_path, hierapath, save_cluster_elem))

625: infos_elem<-function(genes, notin_path, meta, keggchebiname, no_path,

634:     genetab<-pre_genetab[which(!(pre_genetab[,1] %in% notin_path)),]

635:     gene_notin<-pre_genetab[which(pre_genetab[,1] %in% notin_path),]

653:     intetab<-apply(no_path, 1, function(p){

664:                         "go", "path", "type")

669: type_reactome<-function(sorted_path){

672:     rea_types<-vapply(rea_path,function(r){

707: type_kegg<-function(sorted_path){

709:     kegg_types<-vapply(kegg_path, function(k){

712:         hiera<-kegg_hiera[stringr::str_detect(kegg_hiera[, 1], path), ]

725:         else if (path == "hsa01100"){

739: type_wp<-function(sorted_path){

741:     wp_types<-vapply(wp_path, function(w){

772:     kegg_type<-type_kegg(sorted_path)#kegg types

773:     rea_types<-type_reactome(sorted_path)#Reactome types

774:     wp_types<-type_wp(sorted_path)#wikipathways types

801:     hieratypes<-vapply(path_types, function(p){

804:             if(length(intersect(type_path, h[["name"]]))>0){h[["index"]]}

807:             if(length(intersect(type_path, h[["name"]]))>0){h[["name"]]}

872:                     list(paste("x : ",element,"\ny : ",path[length(path)],

881:                     list(paste("x : ", element, "\ny : ", path[length(path)],

952:         if (path_elem>0){

954:             if(num/path_elem>=0.2){x[1]}

957:     sorted_path<-unname(unlist(sorted_path))

958:     sorted_path<-rm_vector(c(sorted_path[!is.na(sorted_path)],path_inter))

959:     return(sorted_path)

972:     path_walks<-tidyr::separate(path_walks, 1, as.character(c(seq_len(max))),

974:     treeview<-tree_view(path_walks);names(treeview)<-c(seq_len(ncol(treeview)))

975:     listtab<-final_tab(treeview, pathways, size, sorted_path, no_path,

981:     listelm<-infos_elem(gene_list, notin_path, meta_list, keggchebiname,

982:                         no_path, go_genelist)

986:     listype<-type_path(sorted_path, hierapath)

998:                                           %in% path_cat),2]), collapse=", ")

1002:     names(intetab)<-c("tag", "first_item", "link", "sec_item", "go", "path",

341: ##find which elements are found in the same pathways, and put them together

342: ##find which pathways contain the same elements also

343: ##if element=T, also return user's elements which aren't in pathways

385: #filter entire pathways hierarchy to build a hierarchy concerning our pathways

386: sort_hiera<-function(pathways){

406:         if(length(pathways[pathways %in% rea_walks])>0){

407:             rea_walks<-rm_vector(rea_walks[c(1, which(rea_walks%in%pathways))])

430: #add informations about pathway hierarchies to the final heatmap

432: #names and ids of pathways in hierarchies

433: hiera_info<-function(pathways, size, sorted_pathways,

443:         name<-pathways[pathways[,2] == node, 1]

447:                             pathways[pathways[,2] == node, 1], sep=""))

450:             htmp<-c(htmp,paste(space, stringr::str_sub(pathidtoname[[node]],

451:                                     15, nchar(pathidtoname[[node]])), sep=""))

479: ##the hierarchy pathways are added to the root

527:     hierapath[length(hierapath)]=NULL

528:     return(list(heatmap, hierapath))

544:     hierapath<-lapply(hierapath,function(x){

549:     heatmap<-apply(heatmap,1,function(x){#pathway with direct interaction ?

561: ##build heatmap of hierarchies of pathways and elements included in them

668: #reactome pathways types

706: #kegg pathways types

738: #wikipathways pathways types

747:                 if(root%in%c("classic metabolic pathway", "regulatory pathway")

770: #pathways types=roots of pathways hierarchy

799:     ##list of concerned hierarchies by pathways types

803:         index<-lapply(hierapath, function(h){

806:         name<-lapply(hierapath, function(h){

947: #filter pathways regarding user's element ratio and direct interactions

1010:                 hierapath, save_cluster_elem, centrality, inter_values,

671:     mapnameid <- as.list(reactome.db::reactomePATHID2NAME) #id-name mapping

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("http://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 ####################

348:   Experiment <- Path <- Compound <- NULL

570:  Path <- label <- conc <- Compound <- Experiment <- 

371:   givenPaths <- NULL

253:                "Experiment", "Path", "Path", 

254:                "Path", "Condition", "Replicate", 

334: #' @param infoTable character string of a file path to

372:   if (any("Path" %in% colnames(infoTable))) {

373:     if (all(infoTable$Path == "") || all(is.na(infoTable$Path))) {

374:       message("Removing empty 'Path' column from config table")

375:       infoTable <- infoTable %>% select(-Path)

378:       givenPaths <- infoTable$Path

443: #' @param configTable character string of a file path to a config table

485:   files <- configTable$Path

511:                   "RefCol", "Path", "Condition")

573:   if(any(grepl("Path", colnames(configWide)))){

575:       dplyr::select(-Path) %>%

756: #' @param configTable character string of a file path to a config table

433:       expCond = infoTable$Condition, files = givenPaths, 

516: 	path = mageFiles$path

30: isOneChannel = function(sdrf,path){

31: 	ph = try(read.AnnotatedDataFrame(sdrf, path = path, row.names = NULL, blank.lines.skip = TRUE, fill = TRUE, varMetadata.char = "$", quote="\""))

39: readPhenoData = function(sdrf,path){

42: 	ph = try(read.AnnotatedDataFrame(sdrf, path = path, row.names = NULL, blank.lines.skip = TRUE, fill = TRUE, varMetadata.char = "$", quote="\""))

105: readAEdata = function(path,files,dataCols,green.only){

108: 	source = getDataFormat(path,files)

121: 		rawdata = try(oligo::read.celfiles(filenames = file.path(path,unique(files))))

123: 			stop("Unable to read cel files in",path)

130: 			dataCols= try(getDataColsForAE1(path,files))

133: 		rawdata = try(read.maimages(files=files,path=path,source="generic",columns=dataCols,annotation=headers$ae1))

138: 		rawdata = try(read.maimages(files=files,path=path,source=source,columns=dataCols,green.only=green.only))

142: 		rawdata = try(read.maimages(files=files,path=path,source="generic",columns=dataCols,green.only=green.only))

149: 		stop("Unable to read data files in",path)

169: readFeatures<-function(adf,path,procADFref=NULL){

173: 	lines2skip = skipADFheader(adf,path,!is.null(procADFref))

174: 	features = try(read.table(file.path(path, adf), row.names = NULL, blank.lines.skip = TRUE, fill = TRUE, sep="\t", na.strings=c('?','NA'), sk...(40 bytes skipped)...

223: readExperimentData = function(idf, path){

224: 	idffile = scan(file.path(path,idf),character(),sep = "\n",encoding="UTF-8")

264: skipADFheader<-function(adf,path,proc=F){

270: 	con = file(file.path(path, adf), "r")	

319: getDataFormat=function(path,files){

326: 		allcnames = scan(file.path(path,files[1]),what = "",nlines = 200, sep = "\t",quiet=TRUE)

329: 			allcnames = scan(file.path(path,files[1]),what = "",nlines = 200, sep = "\t",quiet=TRUE,encoding="latin1")

345: 	allcnames = scan(file.path(path,files[1]),what = "",nlines = 1, sep = "\n",quiet=TRUE)

352: getDataColsForAE1 = function(path,files){

362: 						file.path(system.file("doc", package = "ArrayExpress"),"QT_list.txt"),

375: 	allcnames = scan(file.path(path,files[1]),what = "",nlines = 1, sep = "\t",quiet=TRUE)

430: 		if(!all(sapply(2:length(files), function(i) readLines(file.path(path,files[1]),1) == readLines(file.path(path,files[i]),1))))

518: 	try(file.remove(file.path(path, mageFiles$rawFiles)))

519: 	try(file.remove(file.path(path, mageFiles$processedFiles)))

521: 	try(file.remove(file.path(path, mageFiles$sdrf)))

522: 	try(file.remove(file.path(path, mageFiles$idf)))

523: 	try(file.remove(file.path(path, mageFiles$adf)))

524: 	try(file.remove(file.path(path, mageFiles$rawArchive)))

525: 	try(file.remove(file.path(path, mageFiles$processedArchive)))

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

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

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

182:     path2 <- Sys.which(cmd)

143: bin_paths <- function(dir = "Megadepth",

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)

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

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

148:             file.path(path, dir)

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

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

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

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

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

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

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

164:     path

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

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

179:             path <- ""

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

184:         if (path2 == "") {

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

189:         if (path2 != "") {

194:                 path,

196:                 path2,

202:     normalizePath(path)

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

209:             path <<- find_exec(

215:         path

109:     dirs <- bin_paths()

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

158:     # remove empty paths potentially created by pkgfile

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

438:     path <- req$PATH_INFO

217:   abs.path <- file.path(dir, relpath)

446:     abs.path <- resolve(root, path)

367:   pathPattern <- paste("^\\Q", prefix, "\\E/", sep = "")

371:       origPath <- req$PATH_INFO

376:       pathInfo <- substr(req$PATH_INFO, nchar(prefix)+1, nchar(req$PATH_INFO))

402:   pathPattern <- paste("^\\Q", prefix, "\\E/", sep = "")

407:       origPath <- req$PATH_INFO

412:       pathInfo <- substr(req$PATH_INFO, nchar(prefix)+1, nchar(req$PATH_INFO))

205: # Attempt to join a path and relative path, and turn the result into a

206: # (normalized) absolute path. The result will only be returned if it is an

218:   if (!file.exists(abs.path))

220:   abs.path <- normalizePath(abs.path, winslash='/', mustWork=TRUE)

224:   if (nchar(abs.path) <= nchar(dir) + 1)

226:   if (substr(abs.path, 1, nchar(dir)) != dir ||

227:       substr(abs.path, nchar(dir)+1, nchar(dir)+1) != '/') {

230:   return(abs.path)