pyopenms 2.3.0__zip

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/SCRIPTS/ProduceQCFigures_inj.R

@@ -0,0 +1,27 @@
+#install.packages("scales")
+#install.packages("ggplot2")
+## This is an R script to produce the figures that are attached to the qcML format
+library("ggplot2")
+library(scales)
+options(warn=-1) #suppress warnings
+
+file<-commandArgs(TRUE)[1]
+post<-commandArgs(TRUE)[2]
+
+#file<-"/tmp/2015-10-28_171407_Cetirizin_2990_1/TOPPAS_tmp/QCWorkflow_fr/019_QCExtractor/out_csv/old1.dta"
+knime.in<-read.csv(file=file,head=TRUE,sep="\t")
+names(knime.in)<-c("rt","it")
+knime.in$rt <- as.POSIXct(as.character(0),format="%S")+knime.in$rt
+png(post)
+##########################
+###Injection time
+##########################
+ggplot(data=knime.in, aes(x=rt, y=it)) + 
+  geom_point(shape=2) + 
+  geom_line(y=0, colour="blue") + 
+  stat_smooth(colour="red", method=loess) +
+  #scale_x_datetime( breaks="10 mins",  minor_breaks="1 mins", labels=date_format("%H:%M")) + 
+  xlab("RT (HH:MM)") +
+  ylab("Injection time (ms)")
+######################################
+garbage<-dev.off()

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/SCRIPTS/ProduceQCFigures_rt_acc.R

@@ -0,0 +1,31 @@
+library("ggplot2")
+library(scales)
+options(warn=-1) #suppress warnings
+
+#options
+options(digits=10)
+
+file<-commandArgs(TRUE)[1]
+post<-commandArgs(TRUE)[2]
+#file<-"/tmp/TOPPAS_out/023-QCExtractor-out_csv/old1.csv"
+knime.in<-read.csv(file=file,head=TRUE,sep="\t")
+names(knime.in)<- c("RT", "MZ", "Score", "PeptideSequence", "Charge", "TheoreticalWeight", "DeltaPpm")
+
+png(post)
+##########################
+###Mass accuracy
+##########################
+if(nrow(knime.in) < 2){
+  df <- data.frame()
+  ggplot(df) + geom_point() + xlim(0, 10) + ylim(0, 10)
+}else{
+  knime.in$rt <- as.POSIXct(as.character(0),format="%S")+knime.in$RT
+  ggplot(data=knime.in, aes(x=rt , y=DeltaPpm)) + 
+    geom_point(alpha=0.5) + 
+    ylim(c(-10,10)) + 
+    geom_line(y=0, colour="blue") + 
+    stat_smooth(colour="red", method=loess, span=1/5) +
+    xlab("RT (HH:MM)") 
+}
+######################################
+garbage<-dev.off()

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/SCRIPTS/ProduceQCFigures_setid.R

@@ -0,0 +1,27 @@
+## This is an R script to produce the figures that are attached to the qcML format
+
+#options
+options(digits=10)
+
+file<-commandArgs(TRUE)[1]
+post<-commandArgs(TRUE)[2]
+######
+###setid
+######
+
+a<-read.table(file=file, header=TRUE, sep="\t", na.strings="NA", dec=".", strip.white=TRUE)
+######################################
+png(post)
+bxpo=list()
+bxpo$names=a[,1]
+a <- as.matrix(a[,-1])
+a <- t(a[,c("min","Q1","Q2","Q3","max")])
+bxpo$stats = a
+bxp(bxpo)
+######################################
+dev.off()
+#
+#
+#
+#
+#

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/SCRIPTS/ProduceQCFigures_tic.R

@@ -0,0 +1,23 @@
+## This is an R script to produce the figures that are attached to the qcML format
+library("ggplot2")
+library(scales)
+options(warn=-1) #suppress warnings
+
+#options
+options(digits=10)
+
+file<-commandArgs(TRUE)[1]
+post<-commandArgs(TRUE)[2]
+knime.in<-read.csv(file=file,head=TRUE,sep="\t")
+names(knime.in)<- c("RT", "TIC")
+png(post)
+######################################
+###TIC
+######################################
+knime.in$rt <- as.POSIXct(as.character(0),format="%S")+knime.in$RT
+ggplot(data=knime.in, aes(x=rt, y=TIC)) + 
+  geom_line() + 
+  #scale_x_datetime( breaks="5 mins",  minor_breaks="1 mins", labels=date_format("%H:%M")) + 
+  xlab("RT (HH:MM)") 
+######################################
+garbage<-dev.off()

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/SCRIPTS/Rscript_generic_example.R

@@ -0,0 +1,88 @@
+## This is an exemplary R-Script which can be used in conjunction with TOPP:GenericWrapper (of type: RScript_General)
+## In this mode, the GenericWrapper provides four 'in' and six 'out' slots (four single files, two lists), which the user can couple to in/out files as desired
+## Slots can be empty, and depending on who is invoking this script, you should not rely on
+## argument strings being present (even empty) or not.
+## e.g. a user may write
+## ...... -out3 "" ...
+## or leave it out completely.
+
+## grabbing command args
+## you might want to use a dedicated R package to do this
+## The script will be invoked like this when used with GenericWrapper, where <inX> and <outX> might be missing completely:
+## <thisScript> -in1 <in1> -in2 <in2> -in3 <in3> -in4 <in4> -out1 <out1> -out2 <out2> -out3 <out3> -out4 <out4> -outlist1 <outlist1> -outlist2 <outlist2>
+argv = commandArgs(TRUE)
+#argv = c("-in1", "bla", "-in3", "-out1", "o1", "-out3", "") ## internal debug, worst combination of arguments.. and we should be able to deal with it
+cat("Arguments passed are:")
+cat(argv)
+
+cat("\n\nLooking at parameters now ... \n\n")
+
+## sanity check for input. This script (arbitrarily demands that the first input file (in1) is provided plus an optional output (out1) 
+##  while assuming that the outer GenericWrapper node provides up to four inputs plus six outputs)
+## everything that starts with a "-" is assumed to be a parameter name (not a value)
+idx_in1 = which(argv == "-in1") + 1
+if (length(idx_in1)!=1 | is.na(argv[idx_in1]) | nchar(argv[idx_in1])==0 | substr(argv[idx_in1],1,1)=="-")
+{
+  stop("This script requires one input file for slot 'in1' for arbitrary reasons. The value must not start with '-'\n",
+       "Usage:", "<thisScript> -in1 <in1> -in2 <list> [[-in3 <ignored> -in4 <ignored>] -out1 <optional> -out2 <ignored> -out3 <ignored> -out4 <ignored>] -outlist1 <optional> [-outlist2 <ignored>]", " \n");
+}
+
+
+in1 = argv[2]
+cat(paste0("Argument -in1: '", in1, "'\n"))
+
+idx_in2 = which(argv == "-in2") + 1
+if (length(idx_in2)!=1 | is.na(argv[idx_in2]) | nchar(argv[idx_in2])==0 | substr(argv[idx_in2],1,1)=="-")
+{
+  stop("This script requires a second input in list format (in2) for arbitrary reasons. The values must not start with '-'\n",
+       "Usage:", "<thisScript> -in1 <in1> -in2 <list> [[-in3 <ignored> -in4 <ignored>] -out1 <optional> -out2 <ignored> -out3 <ignored> -out4 <ignored>] -outlist1 <optional> [-outlist2 <ignored>]", " \n");
+}
+idx_in2_end = idx_in2 + 1
+while (!(length(idx_in2_end)!=1 | is.na(argv[idx_in2_end]) | nchar(argv[idx_in2_end])==0 | substr(argv[idx_in2_end],1,1)=="-"))
+{ ## consume as many files as present until a new parameter shows up
+  idx_in2_end = idx_in2_end + 1
+}
+idx_in2_end = idx_in2_end - 1
+
+in2 = argv[idx_in2:idx_in2_end]
+cat(paste0("Argument -in2 (list): '", paste0(in2, collapse=" + "), "'\n"))
+
+
+## do something with input ...
+## ...
+
+
+
+## deal with output (here we only look at -out1 and -outlist1 ...)
+idx_out1 = which(argv == "-out1") + 1
+if (length(idx_out1)==1 && !is.na(argv[idx_out1]) && nchar(argv[idx_out1])>0 && substr(argv[idx_out1],1,1)!="-")
+{
+  out1 = argv[idx_out1]
+  cat(paste0("Argument -out1 provided as: '", out1, "'\n"))
+  ## if the file is requested, we need to deliver
+  cat(file=out1, "The R script wrote some output here...")
+} else {
+  cat("No output out1 requested!\n")
+}
+
+## deal with output (here we only look at -out1 ...
+idx_outlist1 = which(argv == "-outlist1") + 1
+if (length(idx_outlist1)==1 && !is.na(argv[idx_outlist1]) && nchar(argv[idx_outlist1])>0 && substr(argv[idx_outlist1],1,1)!="-")
+{
+  idx_outlist1_end = idx_outlist1 + 1
+  while (!(length(idx_outlist1_end)!=1 | is.na(argv[idx_outlist1_end]) | nchar(argv[idx_outlist1_end])==0 | substr(argv[idx_outlist1_end],1,1)=="-"))
+  { ## consume as many files as present until a new parameter shows up
+    idx_outlist1_end = idx_outlist1_end + 1
+  }
+  idx_outlist1_end = idx_outlist1_end - 1
+  outlist1 = argv[idx_outlist1:idx_outlist1_end]
+  cat(paste0("Argument -outlist1 provided as: '", paste0(outlist1, collapse=" + "), "'\n"))
+  ## if the file is requested, we need to deliver
+  for (outlist_entry in outlist1)
+  {
+    cat(paste0("Writing some content to : '", outlist_entry, "' ...\n"))
+    cat(file=outlist_entry, "The R script wrote some output here...")
+  }
+} else {
+  cat("No output outlist1 requested!\n")
+}

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/SCRIPTS/mzTab2tsv_PEP.R

@@ -0,0 +1,47 @@
+## This is an R script for the conversion of mzTab to a better readable tsv format
+
+# options
+options(digits=10)
+
+input.file <- commandArgs(TRUE)[1]
+output.file <- commandArgs(TRUE)[2]
+
+# count the occurences of character c in string s
+countOccurrences <- function(char,s) {
+	s2 <- gsub(char,"",s)
+	return (nchar(s) - nchar(s2))
+}
+
+# check that all protein accessions are of the format *|*|*
+checkAccessionFormat <- function(accessions) {
+	n <- length(accessions)
+	count <- countOccurrences("[|]",accessions)
+	m <- length(which(count==2))
+	return (n==m)
+}
+
+# read the PEP section of an mzTab file
+readMzTabPEP <- function(file) {
+  
+  # read entire mzTab
+  no.col <- max(count.fields(file, sep = "\t", quote=""))
+  data <- read.table(file,sep="\t",fill=TRUE, quote="", col.names=1:no.col)
+  
+  # extract PEP data
+  peptide.data <- data[which(data[,1]=="PEP"),]
+  colnames(peptide.data) <- unlist(data[which(data[,1]=="PEH")[1],])
+  peptide.data$PEH <- NULL
+  
+  # simplify accession (in case it is of the format *|*|* )
+  peptide.data$accession <- as.character(peptide.data$accession)
+  if (checkAccessionFormat(peptide.data$accession)) {
+    list <- strsplit(peptide.data$accession,"[|]")
+    peptide.data$accession <- unlist(lapply(list, '[[', 2))
+    peptide.data$gene <- unlist(lapply(list, '[[', 3))
+  }
+  
+  return (peptide.data)
+}
+
+peptide.data <- readMzTabPEP(input.file)
+write.table(peptide.data, output.file, sep="\t", row.names=FALSE, col.names=TRUE, quote=FALSE)

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/SCRIPTS/mzTab2tsv_PRT.R

@@ -0,0 +1,104 @@
+## This is an R script for the conversion of mzTab to a better readable tsv format
+
+# options
+options(digits=10)
+
+input.file <- commandArgs(TRUE)[1]
+output.file <- commandArgs(TRUE)[2]
+
+# get index in protein groups list containing protein x
+getIndex <- function(x, members) {
+	g <- gsub(x, "", members, fixed=TRUE)
+	d <- nchar(members)-nchar(g)
+	return (which(d>0)[1])
+}
+
+# returns first entry of a comma-separated list
+firstEntry <- function(x) {
+	list <- strsplit(as.character(x),",",fixed=TRUE)
+	return (unlist(lapply(list, '[[', 1)))
+}
+
+# count the occurences of character c in string s
+countOccurrences <- function(char,s) {
+	s2 <- gsub(char,"",s)
+	return (nchar(s) - nchar(s2))
+}
+
+# check that all protein accessions are of the format *|*|*
+checkAccessionFormat <- function(accessions) {
+	n <- length(accessions)
+	count <- countOccurrences("[|]",accessions)
+	m <- length(which(count>=2))
+	return (n==m)
+}
+
+getAccessions <- function(string) {
+	accessions <- strsplit(string,",")
+	accessions <- lapply(accessions,strsplit,"[|]")
+	accessions <- data.frame(matrix(unlist(accessions),ncol=3,byrow=TRUE))
+	return (paste(as.character(accessions[,2]), collapse=","))
+}
+
+getGenes <- function(string) {
+	accessions <- strsplit(string,",")
+	accessions <- lapply(accessions,strsplit,"[|]")
+	accessions <- data.frame(matrix(unlist(accessions),ncol=3,byrow=TRUE))
+	return (paste(as.character(accessions[,3]), collapse=","))
+}
+
+# read the PRT section of an mzTab file
+readMzTabPRT <- function(file) {
+  
+  # read entire mzTab
+  no.col <- max(count.fields(file, sep = "\t", quote=""))
+  data <- read.table(file, sep="\t", fill=TRUE, quote="", col.names=1:no.col)
+  
+  # extract protein data
+  protein.data <- data[which(data[,1]=="PRT"),]
+  colnames(protein.data) <- unlist(data[which(data[,1]=="PRH")[1],])
+  protein.data$PRH <- NULL
+  columns.to.keep <- which(colnames(protein.data)!="")
+  protein.data <- protein.data[,columns.to.keep]
+  
+  proteins <- protein.data[which(protein.data$opt_global_protein_group_type=="single_protein"),]
+  protein.groups <- protein.data[which(protein.data$opt_global_protein_group_type=="protein_group"),]
+  indistinguishable.groups <- protein.data[which(protein.data$opt_global_protein_group_type=="indistinguishable_group"),]
+
+  protein.groups.members <- as.character(protein.groups$ambiguity_members)
+  
+  indistinguishable.groups.members <- as.character(indistinguishable.groups$ambiguity_members)
+  
+  if ((dim(protein.groups)[1] > 0) && (dim(indistinguishable.groups)[1] > 0)) {
+    # match indistinguishable groups to protein groups
+    group.index <- as.vector(sapply(firstEntry(indistinguishable.groups.members), getIndex, members=protein.groups.members))
+    table <- data.frame(cbind(group.index, indistinguishable.groups.members))
+    
+    # merge information from the protein list
+    colnames(table) <- c("protein group","accessions")
+    table$accession <- firstEntry(table$accessions)
+    table <- merge(table, proteins, by="accession")
+    table$accession <- NULL
+    
+    # order table by protein.group
+    table$"protein group" <- as.integer(table$"protein group")
+    table <- table[order(table$"protein group"),]
+  } else {
+    table <- proteins
+    colnames(table) <- gsub("accession","accessions", colnames(table))
+  }
+  
+  # simplify accessions (in case they are of the format *|*|* )
+  table$accessions <- as.character(table$accessions)
+  if (checkAccessionFormat(table$accessions)) {
+    x <- unlist(lapply(table$accessions,getAccessions))
+    y <- unlist(lapply(table$accessions,getGenes))
+    table$accessions <- x
+    table$gene <- y
+  }
+
+  return (protein.groups)
+}
+
+table <- readMzTabPRT(input.file)
+write.table(table, output.file, sep="\t", row.names=FALSE, col.names=TRUE, quote=FALSE)

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/SCRIPTS/mzTab2tsv_PSM.R

@@ -0,0 +1,80 @@
+## This is an R script for the conversion of mzTab to a better readable tsv format
+
+# options
+options(digits=10)
+
+input.file <- commandArgs(TRUE)[1]
+output.file <- commandArgs(TRUE)[2]
+
+# count the occurences of character c in string s
+countOccurrences <- function(c,s) {
+  s2 <- gsub(c,"",s)
+  return (nchar(s) - nchar(s2))
+}
+
+# check that all protein accessions are of the format *|*|* 
+checkAccessionFormat <- function(accessions) {
+  n <- length(accessions)
+  count <- countOccurrences("[|]",accessions)
+  m <- length(which(count==2))
+  return (n==m)
+}
+
+# collapse rows
+# (In mzTab, PSMs with multiple protein accessions are reported in multiple rows. This function collapses them to a single row.)
+collapseRows <- function(psm.data) {
+  
+  # generate index vector idx
+  tmp.psm.id <- 0
+  idx <- c()
+  accessions.tmp <- c()
+  accessions.strings <- c()
+  for (i in 1:length(psm.data$PSM_ID)) {
+    
+    if (psm.data$PSM_ID[i] == tmp.psm.id) {
+      if (length(accessions.tmp) > 0) {
+        accessions.strings <- c(accessions.strings, toString(accessions.tmp, sep=','))
+        accessions.tmp <- c()
+      }
+      
+      idx <- c(idx,i)
+      tmp.psm.id <- tmp.psm.id + 1
+    }
+    
+    accessions.tmp <- c(accessions.tmp, psm.data$accession[i])
+  }
+  accessions.strings <- c(accessions.strings, toString(accessions.tmp, sep=','))
+  
+  psm.data <- psm.data[idx,]
+  psm.data$accession <- accessions.strings
+  
+  return (psm.data)
+}
+
+# read the PSM section of an mzTab file
+readMzTabPSM <- function(file) {
+  
+  # read entire mzTab
+  no.col <- max(count.fields(file, sep = "\t", quote=""))
+  data <- read.table(file, sep="\t", fill=TRUE, quote="", col.names=1:no.col)
+  
+  # extract PSM data
+  psm.data <- data[which(data[,1]=="PSM"),]
+  colnames(psm.data) <- unlist(data[which(data[,1]=="PSH")[1],])
+  psm.data$PSH <- NULL
+  
+  # simplify accession (in case it is of the format *|*|* )
+  psm.data$accession <- as.character(psm.data$accession)
+  if (checkAccessionFormat(psm.data$accession)) {
+    list <- strsplit(psm.data$accession, "[|]")
+    psm.data$accession <- unlist(lapply(list, '[[', 2))
+    psm.data$gene <- unlist(lapply(list, '[[', 3))
+  }
+  
+  psm.data <- collapseRows(psm.data)
+  
+  return (psm.data)
+}
+
+psm.data <- readMzTabPSM(input.file)
+write.table(psm.data, output.file, sep="\t", row.names=FALSE, col.names=TRUE, quote=FALSE)

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/SCRIPTS/plot_trafo.R

@@ -0,0 +1,126 @@
+#!/usr/bin/env Rscript
+
+library(XML)
+
+## utility function:
+"%within%" <- function(x, range) {
+  (x >= range[1]) & (x <= range[2])
+}
+
+## read pairs of data points from trafoXML file:
+read.pairs <- function(filename) {
+  pairs <- matrix(nrow=0, ncol=2)
+  pair.handler <- function(name, attrs) {
+    pairs <<- rbind(pairs, as.numeric(c(attrs["from"], attrs["to"])))
+  } 
+  xmlEventParse(filename, list("Pair"=pair.handler))
+  pairs
+}
+
+## create short, but unique names from trafoXML files:
+unique.names <- function(paths) {
+  stopifnot(!any(duplicated(paths)))
+  paths <- sub("\\.trafoXML", "", paths, ignore.case=TRUE)
+  labels <- basename(paths)
+  if (!any(duplicated(labels)))
+    return(labels)
+
+  parts <- strsplit(paths, .Platform$file.sep, fixed=TRUE)
+  parts <- lapply(parts, rev)
+  i <- 2
+  repeat {
+    labels <- file.path(sapply(parts, function(p) p[i]), labels)
+    if (!any(duplicated(labels)))
+      return(labels)
+    i <- i + 1
+  }
+}
+
+## plot data points:
+plot.pairs <- function(filenames, percent=90, pch=1, legend.loc="topleft",
+                       legend.ncol=2) {
+  filenames <- unique(filenames)
+  pairs <- lapply(filenames, read.pairs)
+  lens <- sapply(pairs, nrow)
+  pairs <- do.call(rbind, pairs)
+  diffs <- pairs[, 2] - pairs[, 1]
+  diffs.range <- range(diffs)
+  if (percent < 100) {
+    frac <- (100 - percent) / 2 / 100
+    q <- quantile(diffs, c(frac, 1 - frac))
+    ## double the quantile range:
+    yrange <- q + (diff(q) / 2) * c(-1, 1)
+    ## ...unless the data range is smaller:
+    yrange[1] <- max(yrange[1], diffs.range[1])
+    yrange[2] <- min(yrange[2], diffs.range[2])
+
+    xrange <- range(pairs[diffs %within% yrange, 1])
+  }
+  else {
+    yrange <- xrange <- NULL
+  }
+
+  colors <- rainbow(length(filenames))
+  plot(pairs[, 1], diffs, xlim=xrange, ylim=yrange, col=rep(colors, lens),
+       pch=pch, main="Retention time transformation", xlab="original RT [s]",
+       ylab=expression(paste(Delta, "RT [s]", sep="")))
+  abline(h=0, col="grey")
+  if (legend.loc != "none")
+    legend(legend.loc, legend=unique.names(filenames), pch=20, col=colors,
+           ncol=legend.ncol, cex=0.8)
+}
+
+## command line parameters:
+opt <- data.frame(
+    c("percent", "pch", "legend.loc", "legend.ncol"),
+    desc=c("Percentage of data points to define (half the) visible range",
+           "Plotting character", "Location of legend",
+           "Number of columns for legend"),
+    value=c("90", ".", "topleft", "2"), row.names=1,
+    stringsAsFactors=FALSE)
+
+params <- commandArgs(trailingOnly=TRUE)
+
+if (length(params) < 2) {
+  cat("Usage: Rscript Plot_trafoXML.R",
+      paste0("[", rownames(opt), "=?]", collapse=" "),
+      "in1.trafoXML [in2.trafoXML ...] out.pdf\n\n")
+  cat("Generate a plot of RT transformation data.\n\n")
+  cat("Input: trafoXML file(s)\n")
+  cat("Output: PDF file with plot\n")
+  cat("Optional parameters:\n")
+  width <- max(nchar(rownames(opt)))
+  cat(paste0("  ", format(rownames(opt), width=width), " ", opt$desc,
+             " (default: ", opt$value, ")", collapse="\n"), "\n")
+  quit("no")
+}
+
+## no R package for handling command line parameters installed by default :-(
+params.split <- strsplit(params, "=", fixed=TRUE)
+for (i in 1:length(params)) {
+  parts <- params.split[[i]]
+  if (length(parts) == 1)
+    break # no "=", therefore no optional parameter
+  if (!(parts[[1]] %in% rownames(opt))) {
+    cat("Unknown parameter:", parts[[1]], "- ignored.\n")
+    next
+  }
+  parts[[2]] <- sub("^['\"](.*)['\"]$", "\\1", parts[[2]]) # remove quotes
+  opt[parts[[1]], "value"] <- parts[[2]]
+}
+
+filenames <- params[i:(length(params) - 1)]
+outfile <- params[length(params)]
+for (i in 1:nrow(opt)) {
+  assign(rownames(opt)[i], opt[i, "value"])
+}
+percent <- as.numeric(percent)
+legend.ncol <- as.numeric(legend.ncol)
+if (pch %in% as.character(1:25))
+  pch <- as.numeric(pch)
+
+pdf(outfile)
+plot.pairs(filenames, percent, pch, legend.loc, legend.ncol)
+invisible(dev.off())
+
+cat("Done.\n")

media/doc/pyenv/py27_bleeding/lib/python2.7/site-packages/pyopenms/share/OpenMS/THIRDPARTY/ReadMe.txt

@@ -0,0 +1,9 @@
+This folder is empty in the svn and developer installs.
+
+In a Windows-Installer, we add all third party executables here and also add them to the PATH
+We do not simply add executables to our own OpenMS/bin, because this prevents users from using their
+custom third party executables (by prepending them in their path, such that they will be found earlier, e.g. by TOPPAS).
+
+Current Libs:
+ - ProteoWizard (http://proteowizard.sourceforge.net/)
+