Expanding the Perseus Software for Omics Data Analysis With Custom Plugins

The Perseus software provides a comprehensive framework for the statistical analysis of large‐scale quantitative proteomics data, also in combination with other omics dimensions. Rapid developments in proteomics technology and the ever‐growing diversity of biological studies increasingly require the flexibility to incorporate computational methods designed by the user. Here, we present the new functionality of Perseus to integrate self‐made plugins written in C#, R, or Python. The user‐written codes will be fully integrated into the Perseus data analysis workflow as custom activities. This also makes language‐specific R and Python libraries from CRAN (cran.r‐project.org), Bioconductor (bioconductor.org), PyPI (pypi.org), and Anaconda (anaconda.org) accessible in Perseus. The different available approaches are explained in detail in this article. To facilitate the distribution of user‐developed plugins among users, we have created a plugin repository for community sharing and filled it with the examples provided in this article and a collection of already existing and more extensive plugins. © 2020 The Authors.


INTRODUCTION
The complex downstream analysis of proteomic data requires the integration of bioinformatics, statistics, network analysis, and, frequently, machine learning. This has led to the development of the Perseus software  as a comprehensive multipurpose tool and framework for such analyses. The user-friendly interface facilitates a variety of data transformations and visualizations and provides gapless documentation, a storable analysis workspace, and a visual representation of the analysis workflow. The options for multidimensional omics data analysis include normalization, pattern recognition, time-series analysis, cross-omics comparisons, and controlled multiple-hypothesis testing.
The core data structure is a matrix, containing one row per entry in the dataset, usually a protein or protein group. The columns can contain variable information of different data types. Perseus distinguishes between "Numerical" columns containing single number values, "Multi-numerical" columns that can contain more than one value in one cell (split by semi-colons), "Categorical" columns that can contain binary flags, grouping information, or biological annotation of individual entries (which can be added through Perseus), and, finally "Text" columns for anything that is neither a number nor a category. Perseus additionally distinguishes the columns containing the "Main" data for each entry, e.g., the quantitative expression values of each protein group in different samples. These types can be specified on data import and changed throughout the analysis. In addition to the annotation columns, annotation rows can be defined to specify column grouping parameters such as biological conditions and technical replicates. This structure makes Perseus very flexible, allowing statistical analysis for a considerable variety of experimental designs and thereby facilitating hypothesis generation (Rudolph & Cox, 2019).
Despite this broad applicability there will always be a specific case study or new technology that requires additional functionalities so far not provided by Perseus. To expand Perseus' functionality with plugins is neither difficult nor complex: the core data structure is propagated to external plugins and back to the Perseus framework through well-defined interfaces. Newly implemented functionalities can be directly incorporated into the Perseus interface, making them indistinguishable from the core functions. This had already been possible for plugins written in C#, since it is Perseus's native language, but it is now also possible for plugins written in other languages including R and Python. This facilitates the interoperability of Perseus with external scripting languages, and allows developers to use a language they are already comfortable with. The backend providing this new functionality is called PluginInterop: it runs the external plugin with a specified executable and facilitates passing additional arguments to the plugin (Rudolph & Cox, 2019). Since R and Python are widely used in data science, two companion libraries are provided for these two languages to be used alongside PluginInterop: PerseusR and perseuspy. They provide the other half of the interface for seamless transfer of matrices and annotations from Perseus to R/Python data frame objects and vice versa.
In this article, we provide extensive explanations for all the steps and details of creating custom plugins for Perseus in all three languages-starting from the basic installation steps and the use of the different interfaces and proceeding all the way to advanced analysis plugins. Together with the protocols, we provide a GitHub repository (https:// github.com / JurgenCox/ perseus-plugin-programming) where the given examples are available for download, as well as a list of already existing plugins of varying complexity and where to find them online (Table 1).

STRATEGIC PLANNING
Before starting to develop a new Perseus plugin, a few things need to be considered, for instance, which language should be employed, who is going to use the plugin, and how many additional arguments are needed for the plugin to work. These are relevant questions, since there are two ways of integrating non-C# plugins into Perseus. They can be incorporated with a command line interface or with a C# wrapper for R/Python plugins. The command line interface lets you select the plugin script file and provides a single input line for arguments to be passed to the script. On the other hand, the C# wrapper generates a small graphical user interface to ask for parameter values and adds a separate entry to a selectable interface menu in Perseus, thereby avoiding the manual selection of the script file before every run (see Figs. 1-4). Thus, a C# wrapper for R/Python plugins is not required if the plugin is meant to be used only by the developer or users comfortable with the command line interface. Conversely, the use of a C# wrapper is highly recommended if a broad user base is expected or a larger number of arguments needs to be supplied to the plugin. A third alternative is to write the plugin entirely in C#, in which case the integration is direct, and no wrapping code is necessary. For all these variants, detailed protocols are provided. If an R or Python plugin is being developed, it is always possible to initially use the command line interface, and then add a C# wrapper before it is released to other users, as long as some conventions are followed. All the software development tools required for Perseus plugin development are freely available. The collection of imputation methods for proteomics data. The software of imputeLCMD (Johnson, Li, & Rabinovic, 2007) is from sva (Leek, Johnson, Parker, Jaffe, & Storey, 2012).

Quantile normalization
Making the distributions identical in statistical properties. The software is from Limma (Ritchie et al., 2015).

Input files
This protocol requires no extra input files. The outlined plugin works with a randomly generated matrix, which can be done using the dice button in Perseus.  PerseusR is the package that bridges between Perseus and R. It needs to be imported first. Afterwards, the matrix from Perseus can be read into a special matrixData object by read.perseus.
3. Get the main matrix of Perseus for data processing.
The matrix in Perseus is composed of annotation rows/columns and the main data columns. In order to extract the main matrix for analysis, the function −main() needs to be used.
counts <main(mdata) 4. Execute the main custom code for data analysis or modification.
After obtaining the main matrix, the custom analysis steps and modifications can be done. In this protocol, the head of the matrix is extracted ("15 rows" is assigned).

mdata2 <head(counts, n=15)
Since the number of rows is reduced for the main matrix, the annotation columns need to be shortened for the output matrix as well. To get the annotation columns, use annotCols().
After finishing all data-processing steps, the data needs to be converted back to the Perseus txt format and written to the predefined temporary output file. For generating the final output, a new matrixData object consisting of main matrix (main), annotation columns (annotCols). and annotation rows (annotRows) needs to be created. Similar to annotCols(), the function annotRows() extracts the content of Perseus annotation rows. Since the annotation rows are not changed by the plugin, they are reused from the original matrix. mdata2 <-matrixData(main=mdata2, annotCols=aCols, annotRows=annotRows(mdata))

of 29
Current Protocols in Bioinformatics 6. Apply the plugin in Perseus.
a. Open Perseus and import the matrix/load a session file.
A random matrix is used for testing the plugin in this tutorial.
b. Execute the plugin.
In the "Processing" block, click "External" -> "Matrix -> R". If the button "select" is green, it means that Perseus recognized your R installation and PerseusR ( Figure 5A), otherwise navigate to your Rscript.exe or add it to your systems PATH variable. Afterwards, specify the R script that you want to execute and click OK (Fig. 5B).

R PLUGINS WITH ADDITIONAL ARGUMENTS
In order to make a script more flexible and useful, additional parameters are usually required. With the above example of extracting the head of a matrix (Basic Protocol 1), it will be much more convenient if the number of rows can be defined by the users. The following steps will provide the details of how to add parameters to the plugins. The script, including all steps, can also be found at https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ scripts/ head_add_argument.R.

Use PerseusR to read the data in Perseus.
In the same was as for the scripts without parameters, PerseusR needs to be imported, and read.perseus is used for converting the matrix from Perseus to R format. library(PerseusR) mdata <read.perseus(inFile) 3. Get the main matrix of Perseus for the data processing.
Use main() to obtain the main matrix that is needed for the following data processing.
counts <main(mdata) 4. Execute the main part for data analysis or modification.
The information from the additional parameter was already parsed and stored. The extraction of the head of the matrix can be performed based on the number of rows that the user assigned.
Yu et al.

Apply the plugin in Perseus.
Now the plugin is ready to be executed. The number of extracted rows can be assigned from "Additional arguments" in the pop-up window (Fig. 5B). For instance, writing "--nrow 10" in "Additional arguments," only the first 10 rows will remain in the output matrix in Perseus.

BASIC STEPS FOR PYTHON PLUGINS
In recent years, many useful Python packages have been developed for computational biology and data visualization. Moreover, an annual conference (SciPy) provides a platform where up-to-date Python tools are released and presented. Perseuspy builds a bridge to integrate Python libraries into Perseus as plugins (Rudolph & Cox, 2019). In this section, we provide the basic steps for generating Python-only plugins through the command line style interface. The code for this example is available at https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ scripts/ head.py.

Necessary Resources Hardware
A computer running Windows 8 (64 bit) or higher or Windows Server 2008 or higher 4 GB RAM minimum At least a quad core processor is recommended Software Perseus 1.6.13 or higher: can be downloaded from https:// maxquant.org/ perseus. Python: use version higher than 3.7.0. The Python executable has to be listed in the PATH environment variable of the operating system. Please refer to Troubleshooting if Perseus cannot find your Python installation, which is indicated in the command line−style interface. Perseuspy: available at https:// github.com/ cox-labs/ perseuspy. An installation guide and required dependencies can be found in the repository. Also available on PyPI (https:// pypi.org/ project/ perseuspy/ ). Python supported editor like Visual Studio, PyCharm or Notepad++

Input files
This protocol requires no extra input files. The outlined plugin works with a randomly generated matrix, which can be generated using the dice button in Perseus.
1. Import the required packages.
import sys from perseuspy import pd Yu et al.

of 29
Current Protocols in Bioinformatics Perseuspy builds on top of the widely-used pandas package to handle matrix processing (Mckinney, 2010). The nested namespace pd contains this extended version of pandas.
2. Parse command line arguments from Perseus. 3. Read the data from Perseus.
Using the new pandas function read_perseus the data matrix from Perseus can be read from the input file directly into a pandas data frame object. df = pd.read_perseus(infile)

The main custom code for data analysis or modification.
This part is for the custom desired data analysis. In this example, the code for extraction of the head of the matrix is placed in this position. df2 = df.head (15) Based on the code, only the first 15 rows will be kept in the matrix.

Export the output matrix to Perseus with correct format.
When all the steps of the data processing are done, the final matrix needs to be exported to Perseus in the correct format. For this, the second new function in pandas, to_perseus, can be used.
a. Open Perseus and import the matrix or load a session.
A random matrix is used for testing the plugin in this tutorial.
b. Execute the plugin.
In the "Processing" block, click "External" -> "Matrix -> Python". If the button "select" is green, it means that Perseus recognized your Python installation and perseuspy Yu et al.

of 29
Current Protocols in Bioinformatics (Fig. 6A); otherwise, navigate to your python.exe or add it to your systems PATH variable. Afterwards, specify the Python script that you want to execute and click OK (Fig. 6B).

PYTHON PLUGINS WITH ADDITIONAL ARGUMENTS
For a more elaborate analysis, Python plugins can also be passed additional arguments just like R plugins. The following steps will demonstrate the steps needed for adding parameters to plugins. The example the number of rows to obtain from the top of the matrix can be specified by the user. The script is available at https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ scripts/ head_add_argument.py.

Necessary Resources
Same as Basic Protocol 2 Additionally, the package argparse needs to be installed in the Python environment 1. Import the required packages.
The number of rows stored in "--nrow", can now be used for the extraction. df_head = df.head(arg.nrow) 5. Export the output matrix to Perseus with correct format. df2.to_perseus(arg.output)

Apply the plugin in Perseus.
For using the newly added parameter as an input, the assignment needs to be written in "Additional arguments" in the pop-up window (Fig. 6B). If "Additional arguments" is filled in with "--nrow 10", the output matrix will be the first 10 rows.

BASIC STEPS AND CONSTRUCTION OF C# PLUGINS
Even better integrated plugins with an automatically generated graphical user interface for the parameters can be generated when using C#, which is the original programming language of Perseus. The architecture of Perseus plugins is systematic and Yu et al.

of 29
Current Protocols in Bioinformatics well structured. Numerous C# plugins can be found at https:// github.com/ JurgenCox/ perseus-plugins. All the scripts can be recycled and modified by users. The same basic example as in the previous sections will be used to explain how to generate a C# plugin. The script of the example can be seen at https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ PluginTutorial/ Head_c_sharp.cs. Due to the internal connection between the plugin and Perseus, the project name should use "Plugin" as prefix and the type of project should be "Class Library (.NET framework)." In this demonstration, the Project name was set as "PluginTutorial".

Add the dependencies.
PerseusAPI and BaseLibS need to be installed for generating plugins. For installation of these two packages, right-click on the "PluginTutorial" solution and choose "Manage NuGet Packages…." Afterwards, search for PerseusApi in the "Browse" tab and install it for "PluginTutorial". The PerseusAPI and its dependency BaseLibS will be added.
3. Import packages and define namespace with a class. To customize the plugin, the modification of several parameters and methods is required. Name defines the name of the plugin as it will appear in Perseus (Fig. 7A). Heading defines the name of the drop-down menu the plugin will be added to (Fig. 7A). If the name of the menu does not yet exist, a new one will be created automatically without requiring further changes in other places. Optional parameter changes are the following: the Description of the plugin, which will be shown when hovering over the plugin in Perseus (Fig. 7A); the Url of the plugin's documentation, which can be opened by clicking the ghost icon besides the "OK" button (Fig. 7B); and DisplayImage, which is the icon appearing next to the plugin name in the menu. If more threads need to be used for the plugin, it can be changed in GetMaxThread. The code for actual data processing should be placed inside ProcessData. The additional input parameters required are defined in Parameters. The other parameters defined in the code above are not relevant for custom-generated plugins, but need to be defined for the class to be compiled successfully.
Yu et al.

of 29
Current Protocols in Bioinformatics

Add parameters.
The method GetParameters returns a C# object (Parameters) containing all the parameters that the user has to provide in the interface. In this example, an integer parameter was created (IntParam). The name of the parameter is "Number of rows," and the default is 15. A description of the parameter can be added in Help. This description will appear when hovering over the parameter text (Fig. 7B)

of 29
Current Protocols in Bioinformatics new IntParam("Number of columns", 2) {Help = "The number of columns to retain."} ); } 6. Generate the code for data processing.
The main data processing is defined in ProcessData. In this example, the first n rows of the matrix are extracted.

Compile the plugin and copy the dll.
Since C# is a compiled language, the next step is to build the project, which will generate a .dll file. If the build was successful, PluginTutorial.dll will be saved in the "bin/Debug" folder of the project directory, which you can open by right-clicking the project in the Solution Explorer -> "Open Folder in File Explorer" (PluginTuto-rial\bin\Debug, Fig. 7C). For adding the newly created plugin to Perseus, this dll must be copied to the "bin" folder of Perseus (Perseus/bin, Fig. 7D). Afterwards, the plugin can be used in Perseus after a re-start ( Fig. 7A and 7B).
8. Apply the plugin in Perseus.

a. Open Perseus and import the matrix or open a session.
A random matrix is used for testing the plugin in this tutorial.

b. Execute the plugin.
Click "Tutorial" -> "Head CS only" in "Processing" block (Fig. 7A). Then, specify the number of rows for extraction and click OK (Fig. 7B).

Resource for C# Plugins
For more examples and source codes of C# plugins, please check the repository: https:// github.com/ JurgenCox/ perseus-plugins.

BASIC STEPS OF CONSTRUCTION AND CONNECTION FOR R PLUGINS WITH C# INTERFACE
Although C# can generate a user-friendly interface for the plugins, R and Python packages are still not able to be integrated into Perseus with the native C# interface. To combine the flexibility of R and Python with the graphical user interface generated by C#, the C# package PluginInterop was created (Rudolph & Cox, 2019). Here, the basic methods of PluginInterop needed to create an R plugin with C# interface will be Yu et al.

Necessary Resources
All requirements of Basic Protocols 1 and 3 Additionally, the C# package PluginInterop is required: this can also be installed by using "Manage NuGet Packages" in a Visual Studio project as described in step 2.
1. Create a C# project. 3. Import packages and define namespace with a class. Heading, Name and Description should be changed to match the needs of the project (the details of these methods were mentioned at step 4 of Basic Protocol 3). TryGetCodeFile() is for getting the R script from the project resources. The only thing that needs to be edited here is the name of the R script in (byte[])Resources.ResourceManager.GetObject(), omitting the file extension (head_c_sharpR). GetCommandLineArguments() will convert the parameters specified at SpecificParameters() and filled in by the user to a temporary file which can be read inside the R script. This method definition does not require further editing. SpecificParameters() is similar to GetParameters(), which was introduced at step 5 of Basic Protocol 3. It needs to return an array of parameter definitions, which will be used to generate the interface. For definition of several parameters please refer to Support Protocol 4, which shows a more advanced example.

Generate R script for data processing.
At this point, the C# side of the interface has been established. Next, the R code for the actual data processing is added. The code is very similar to the script presented in Support Protocol 1. The only difference is that the additional parameters are transferred as one file from the C# interface, rather than as individual arguments. The order of the command line arguments is now parameter file, input file and output file.

Afterwards, the user input has to be extracted by a function called "parseParameters" and several type-specific functions like intParamValue(), or boolParam-Value(). Table 1 summarizes the most commonly used functions and their C# counterparts. In this demonstration, the type of the parameter is integer and the name is "Number of rows."
parameters <-parseParameters(paramFile) num_row <-intParamValue(parameters, 'Number of rows') The remainder of the R script is the same as in Support Protocol 1.

ADVANCED EXAMPLE OF R PLUGIN WITH C# INTERFACE: UMAP
UMAP (Becht et al., 2019;McInnes, Healy, & Melville, 2018) is a powerful dimensionality-reduction algorithm that is widely used for many different studies. It will be extremely useful to add UMAP to Perseus. This section will take UMAP as an advanced example to demonstrate how powerful the new Perseus plugin interface is for data analysis. The C# script can be found at https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ PluginTutorial/ UmapAnalysis_with_r.cs, and the R script is saved at https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ PluginTutorial/ Resources/ Umap_R.R.

Necessary Resources
All of the resources listed in Basic Protocol 4 UMAP: a dimensionality-reduction method. The R version of UMAP can be found at CRAN (https:// cran.r-project.org/ web/ packages/ umap/ index.html)

of 29
Current Protocols in Bioinformatics missing values) are all removed from the table. Moreover, the data is well annotated by experimental design. This table can be directly used for the advanced example.

Create a C# project.
Please see step 1 of Basic Protocol 3.

Add the dependencies.
Please see step 2 of Basic Protocol 4.
3. Import packages and define namespace with a class.
Please see step 3 of Basic Protocol 4.

Override methods in the class.
In general, the practical procedures are the same as in step 4 of Basic Protocol 4. The only requirement is to modify several methods and variables to match this example. First, the Head, Name, and Description need to be changed.
public override string Heading => "Tutorial"; public override string Name => "Umap analysis with R"; public override string Description => "Applying Umap to cluster the data"; Secondly, the R script of UMAP analysis has to be assigned properly.
byte[] code = (byte[])Resources.ResourceManager. GetObject("Umap_R"); Third, all the parameters should be added to SpecificParameters() one by one with their corresponding data type.

of 29
Current Protocols in Bioinformatics Help = "Set minimum distance between the data point." }, new SingleChoiceParam("Metric") { Values= new[] { "euclidean", "manhattan", "cosine", "pearson","pearson2"}, Help = "The method of metric for doing clustering." } }; } The structure of SingleChoiceParam() is different from IntParam() or Dou-bleParam(). SingleChoiceParam() has to contain an array called Values to store all the options for the users. The first element of Values is the default one, which will appear on the dropdown list of the Perseus plugin.
5. Generate R script for data processing.
The basic rules for generating an R script are the same as in step 5 of Basic Protocol 4. Hence, the most important thing is to obtain the information of parameters from C#. The other parts of the R script can be done like normal R programming and are not shown here.
6. Store R script to resource folder.
Please see step 6 of Basic Protocol 4.

Build the solution and place the required files to the bin folder of Perseus
Please see step 7 of Basic Protocol 4.

Run UMAP and plot the result.
In this section, the dataset from Bailey, D. J., et al. will be applied to test the newly developed plugin of UMAP (Bailey et al., 2014). a. Open Perseus and load proteinGroup.txt.
Since proteinGroup.txt is already pre-processed and grouped, it can be directly loaded into Perseus by clicking the green icon of arrow in the block of "Load." b. Run R plugin of UMAP.
Yu et al.

Current Protocols in Bioinformatics
Click "Tutorial" −> "Umap analysis with R" to specify the parameters and run the plugin ( Fig. 2A and 2B). After running the plugin of UMAP, the matrix will be transposed and the main values will be changed to components.
c. Plot the result of UMAP.
Use scatter plot (with columns) to view the result of the UMAP analysis. The outcome shows that the data points are clustered based on cell types (Fig. 2C).

BASIC STEPS OF CONSTRUCTION AND CONNECTION FOR PYTHON PLUGINS WITH C# INTERFACE
This protocol will continue to demonstrate how to generate Python plugins with C# interface using the same examples as Basic Protocol 4. The C# script of the basic example can be found at https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ PluginTutorial/ Head_with_py.cs, and the Python code can be found at https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ PluginTutorial/ Res ources/ head_c_sharpPy.py.

Necessary Resources
All requirements of Basic Protocols 2 and 3 Additionally, the C# package PluginInterop is required: this can also be installed by using "Manage NuGet Packages" in a Visual Studio project as described in step 2

Create a C# project.
Please see step 1 of Basic Protocol 3.

Add the dependencies.
Please see step 2 of Basic Protocol 4.
3. Import packages and define namespace with a class.

Build the solution and place the required files to the bin folder of Perseus
Please see step 7 of Basic Protocol 4.
If all the procedures are done, the plugin will be shown in Perseus (Fig. 3)

ADVANCED EXAMPLE OF PYTHON PLUGIN WITH C# INTERFACE: UMAP
Since UMAP is also available in Python, the same analysis can be used as an advanced example to show the power of Perseus Plugins for data analysis. The C# and Python scripts are listed at https: // github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ PluginTutorial/ UmapAnalysis_with_py.cs, and https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ PluginTutorial/ Resources/ Umap_Py.py, respectively.

Necessary Resources
All of the requirements listed in Basic Protocol 5. UMAP: a dimensionality-reduction method. The Python version of UMAP can be found at PyPI (https:// pypi.org/ project/ umap-learn/ ).

Input files
Same as Support Protocol 4 1. Create a C# project.
Please see step 1 of Basic Protocol 3.

Add the dependencies.
Please see step 2 of Basic Protocol 4.
3. Import packages and define namespace with a class.

Please see step 3 of Basic Protocol 5.
Yu et al.

of 29
Current Protocols in Bioinformatics 4. Override methods in the class.
The most important thing is to specify the correct names of plugin and Python script.
Since this part of data processing will be done in Python script, all the parameters need to be transferred to Python variables. n_neighbor = intParam(parameters, "Number of neighbors") n_component = intParam(parameters, "Number of components") seed = intParam(parameters, "Random state") m_dist = doubleParam(parameters, "Minimum distance") metric = singleChoiceParam(parameters, "Metric") As in step 5 of Support Protocol 4, intParam() can be used for handling the doubleprecision data type because Python can automatically adjust for the conversion. Additionally, the Perseus matrix has to be transposed due to the input format of UMAP. Therefore, the category rows need to be extracted for the modification as well. Similar to an-notRows in PerseusR, read_annotation can return a matrix containing all category rows.

annotations = read_annotations(infile)
Furthermore, Perseuspy has a function called main_df(), which is similar to main() in PerseusR, for extracting the main matrix in Perseus. Based on this, only the values of the main matrix will be used for the UMAP analysis, which is not shown here. newDF1 = main_df(infile, df) 6. Store Python script to resource folder. Based on the above protocols, Perseus plugins can be generated according to the user's needs. In order to demonstrate the benefits that Perseus can offer for data analysis, a basic workflow for the analysis of label-free quantification (LFQ) will be presented in this section. The UMAP plugin generated via Support Protocols 4 and 5 can be applied to this analysis. The samples are from a part of the dataset in a Proteome Informatics Research Group (iPRG) 2015 Study (Choi et al., 2017). The proteinGroup table used for this example can be downloaded from https:// github.com/ JurgenCox/ perseus-plugin-programming/ blob/ master/ dataset/ proteinGroups_LFQ.txt.

Necessary Resources
All of the requirements listed in Basic Protocol 5 and Support Protocol 5
The workflow, plugins, and settings for the basic analysis are shown in Figure 8. The results of most commonly used statistics methods-differential expression analysis (ANOVA test is used) and dimensionality reduction (UMAP is applied) are presented in Figure 9 and 10. This example only demonstrates a basic workflow. Perseus contains numerous useful plugins and parameters. The user can change the settings based on different requirements.

GUIDELINES FOR UNDERSTANDING RESULTS
During the development of new Perseus plugins, execution errors may occur. In this case. a window, "Execution halted," will pop up and show the trace-back of the error. If this happens, refer to the troubleshooting information in Table 2 about common mistakes and how to avoid them. If the error stems from the external plug-in, it is recommended to use the two download options provided in the command line−style interfaces. The first one allows you to download a data preview, which is just the regular temporary file written for the data transfer from Perseus to the plugin. The second download option is for the parameters. This allows the developer to generate test data and parameters for debugging the plugin outside of Perseus, without writing the same temporary files multiple times. If the plugin executes smoothly without any errors, it is still recommended to validate correctness of the results, for instance by writing unit tests. For this, the developer should prepare a minimal test data set that allows validation of the computation results.

of 29
Current Protocols in Bioinformatics Figure 8 Workflow and settings of a basic analysis. The rectangle blocks represent the steps for the analysis. The blue paths are the plugins used for the steps. The green statements are the settings that need to be changed and results of the plugins; the rest of the parameters can remain as the default.
Additionally, the returned data types of all columns should be assessed, to seamlessly integrate the resulting matrix into the overall workflow. If everything is correct, a second test data set that challenges the plugin with common error sources like missing values or false column types should be generated. Once the plugin is fully functional, proper documentation of the plug-in's dependencies and parameters will ensure that it can be successfully applied by Perseus users or other developers. Many useful tools have already been integrated into Perseus and made available to the community (Table 1). With this, we hope to enable many developers to add custom functionality to Perseus; we also Yu et al.

of 29
Current Protocols in Bioinformatics Figure 9 Volcano plots of the example LFQ dataset. (A, B, and C) show the volcano plots of sample 1 versus 2, sample 1 versus 3, and sample 2 versus 3, respectively. The red squares represent the differential expressed proteins.
hope that users will soon have an even larger collection of plugins available to use in their research.

Background Information
Perseus was originally developed together with MaxQuant (Cox & Mann, 2008; for quantitative proteomics analysis. MaxQuant is one of the most commonly used software applications for mass-spectrometry-based proteomics data analysis. It can support numerous types of labeling strategies and MS platforms Tyanova, Mann, & Cox, 2014;Yu et al., 2020). Moreover, different quantification methods, false-discovery rate control, and Yu et al.

of 29
Current Protocols in Bioinformatics Figure 10 UMAP plot of the example LFQ dataset. The blue, red, and green squares represent the sample 1, 2, and 3, respectively.

Error Solution
The R or python executable cannot be found by Perseus.
The executables have to be added to the system "Path" environment variable.
To do this, open the "Control Panel," go to "System," and then to "Advanced System Settings." In the new window, click on the "Environment variables" configuration. From the list of environment variables, select the "PATH," click "edit," and check that the entry for the R/Python executable is correct. If it is missing, add the directory as a new entry. These instructions are for Windows 10. If you cannot locate your path variable, please refer to one of many instructions that can be found online. A package (in R) or library (in python) cannot be imported.
If this error occurs, please make sure that your R or Python environment contains the respective library. Perseus cannot install required libraries on the fly. Perseus cannot recognize the output matrix generated after R or Python execution Be sure in which kind of format the output from the R/Python script is defined. Perseus takes the matrix generated by a data.frame

Identification of Annotation Rows in case of possible groups
In plugins where annotation rows are necessary, be sure that your script recognizes the groups defined in the matrix input, adding the if-case as the argument (!length(annotRows(mdata)), and then call it again at the end of script execution if you want to combine your annotation with the results obtained PerseusR package (in R) and/or Perseuspy (in python) are not recognized Before to use the packages, check if the installation is done correctly by the command line In R: library(PerseusR) In Python: import argparse from perseuspy

of 29
Current Protocols in Bioinformatics visualization are also provided in MaxQuant. The output tables of MaxQuant can be directly imported into Perseus for the downstream bioinformatics and statistical analyses.
In past decades, high-throughput sequencing (HTS) has become a potent method in numerous biological research fields. Perseus also provides the ability to import BAM files and genome annotation files for mRNA quantification . Thus, the bioinformatics and statistical analyses can be applied to HTS datasets as well. This makes Perseus a powerful multi-omics data analysis platform (Poulopoulos et al., 2019). Table 2 lists commonly used parameters for R, Python, and C# plugins. Table 3 provides troubleshooting information.