Enrichment analyses functions¶

Submodule pyiomica.enrichmentAnalyses

Example of use of a function described in this module:

import pyiomica as pio

# Import functions necessary for this demo
from pyiomica.enrichmentAnalyses import GOAnalysis, ExportEnrichmentReport

# Specify a directory for output
EnrichmentOutputDirectory = pio.os.path.join('results','EnrichmentOutputDirectory')

# Let's do a GO analysis for a group of genes, annotated with their "Gene Symbol":
goExample1 = GOAnalysis(["TAB1", "TNFSF13B", "MALT1", "TIRAP", "CHUK",
                         "TNFRSF13C", "PARP1", "CSNK2A1", "CSNK2A2", "CSNK2B", "LTBR",
                         "LYN", "MYD88", "GADD45B", "ATM", "NFKB1", "NFKB2", "NFKBIA",
                         "IRAK4", "PIAS4", "PLAU"])

# Export enrichment results in to .xlsx file
ExportEnrichmentReport(goExample1,
                       AppendString='goExample1',
                       OutputDirectory=EnrichmentOutputDirectory + 'GOAnalysis/')

Note

Function ExportEnrichmentReport generates “.xlsx” file, described in Examples.

Annotations and Enumerations

Functions:

`internalAnalysisFunction`(data, multiCorr, ...)	Analysis for Multi-Omics or Single-Omics input list The function is used internally and not intended to be used directly by user.
`OBOGODictionary`([FileURL, ImportDirectly, ...])	Generate Open Biomedical Ontologies (OBO) Gene Ontology (GO) vocabulary dictionary.
`GetGeneDictionary`([geneUCSCTable, ...])	Create an ID/accession dictionary from a UCSC search - typically of gene annotations.
`GOAnalysisAssigner`([PyIOmicaDataDirectory, ...])	Download and create gene associations and restrict to required background set.
`obtainConstantGeneDictionary`(GeneDictionary, ...)	Obtain gene dictionary - if it exists can either augment with new information or Species or create new, if not exist then create variable.
`GOAnalysis`(data[, GetGeneDictionaryOptions, ...])	Calculate input data over-representation analysis for Gene Ontology (GO) categories.
`GeneTranslation`(InputList, TargetIDList, ...)	Use geneDictionary to convert inputList IDs to different annotations as indicated by targetIDList.
`KEGGAnalysisAssigner`([...])	Create KEGG: Kyoto Encyclopedia of Genes and Genomes pathway associations, restricted to required background set, downloading the data if necessary.
`KEGGDictionary`([PyIOmicaDataDirectory, ...])	Create a dictionary from KEGG: Kyoto Encyclopedia of Genes and Genomes terms - typically association of pathways and members therein.
`KEGGAnalysis`(data[, AnalysisType, ...])	Calculate input data over-representation analysis for KEGG: Kyoto Encyclopedia of Genes and Genomes pathways.
`MassMatcher`(data, accuracy[, ...])	Assign putative mass identification to input data based on monoisotopic mass (using PyIOmica's mass dictionary).
`MassDictionary`([PyIOmicaDataDirectory])	Load PyIOmica's current mass dictionary.
`ExportEnrichmentReport`(data[, AppendString, ...])	Export results from enrichment analysis to Excel spreadsheets.
`BenjaminiHochbergFDR`(pValues[, ...])	HypothesisTesting BenjaminiHochbergFDR correction
`ReactomeAnalysis`(data[, uploadURL, ...])	Reactome POST-GET-style analysis.
`ExportReactomeEnrichmentReport`(data[, ...])	Export results from enrichment analysis to Excel spreadsheets.

internalAnalysisFunction(data, multiCorr, MultipleList, OutputID, InputID, Species, totalMembers, pValueCutoff, ReportFilterFunction, ReportFilter, TestFunction, HypothesisFunction, FilterSignificant, AssignmentForwardDictionary, AssignmentReverseDictionary, prefix, infoDict)[source]¶

Analysis for Multi-Omics or Single-Omics input list The function is used internally and not intended to be used directly by user.

Usage:: Intended for internal use

OBOGODictionary(FileURL='http://purl.obolibrary.org/obo/go/go-basic.obo', ImportDirectly=False, PyIOmicaDataDirectory=None, OBOFile='goBasicObo.txt')[source]¶

Generate Open Biomedical Ontologies (OBO) Gene Ontology (GO) vocabulary dictionary.

Parameters:

FileURL: str, Default “http://purl.obolibrary.org/obo/go/go-basic.obo”: Provides the location of the Open Biomedical Ontologies (OBO) Gene Ontology (GO) file in case this will be downloaded from the web
ImportDirectly: boolean, Default False: Import from URL regardles is the file already exists
PyIOmicaDataDirectory: str, Default None: Path of directories to data storage
OBOFile: str, Default “goBasicObo.txt”: Name of file to store data in (file will be zipped)

Returns:

dictionary: Dictionary of definitions

Usage:

OBODict = OBOGODictionary()

GetGeneDictionary(geneUCSCTable=None, UCSCSQLString=None, UCSCSQLSelectLabels=None, ImportDirectly=False, Species='human', KEGGUCSCSplit=[True, 'KEGG Gene ID'])[source]¶

Create an ID/accession dictionary from a UCSC search - typically of gene annotations.

Parameters:

geneUCSCTable: str, Default None: Path to a geneUCSCTable file
UCSCSQLString: str, Default None: An association to be used to obtain data from the UCSC Browser tables. The key of the association must match the Species option value used (default: human). The value for the species corresponds to the actual MySQL command used
UCSCSQLSelectLabels: str, Default None: An association to be used to assign key labels for the data imported from the UCSC Browser tables. The key of the association must match the Species option value used (default: human). The value is a multi component string list corresponding to the matrices in the data file, or the tables used in the MySQL query provided by UCSCSQLString
ImportDirectly: boolean, Default False: Import from URL regardles is the file already exists
Species: str, Default “human”: Species considered in the calculation, by default corresponding to human
KEGGUCSCSplit: list, Default [True,”KEGG Gene ID”]: Two component list, {True/False, label}. If the first component is set to True the initially imported KEGG IDs, identified by the second component label, are split on + string to fix nomenclature issues, retaining the string following +

Returns:

dictionary: Gene dictionary

Usage:

geneDict = GetGeneDictionary()

GOAnalysisAssigner(PyIOmicaDataDirectory=None, ImportDirectly=False, BackgroundSet=[], Species='human', LengthFilter=None, LengthFilterFunction=<ufunc 'greater_equal'>, GOFileName=None, GOFileColumns=[2, 5], GOURL='http://current.geneontology.org/annotations/')[source]¶

Download and create gene associations and restrict to required background set.

Parameters:

PyIOmicaDataDirectory: str, Default None: The directory where the default package data is stored
ImportDirectly: boolean, Default False: Import from URL regardles is the file already exists
BackgroundSet: list, Default []: Background list to create annotation projection to limited background space, involves considering pathways/groups/sets and that provides a list of IDs (e.g. gene accessions) that should be considered as the background for the calculation
Species: str, Default “human”: Species considered in the calculation, by default corresponding to human
LengthFilterFunction: function, Default np.greater_equal: Performs computations of membership in pathways/ontologies/groups/sets, that specifies which function to use to filter the number of members a reported category has compared to the number typically provided by LengthFilter
LengthFilter: int, Default None: Argument for LengthFilterFunction
GOFileName: str, Default None: The name for the specific GO file to download from the GOURL if option ImportDirectly is set to True
GOFileColumns: list, Default [2, 5]: Columns to use for IDs and GO:accessions respectively from the downloaded GO annotation file, used when ImportDirectly is set to True to obtain a new GO association file
GOURL: str, Default “http://current.geneontology.org/annotations/”: The location (base URL) where the GO association annotation files are downloaded from

Returns:

dictionary: Dictionary of IDToGO and GOToID dictionaries

Usage:

GOassignment = GOAnalysisAssigner()

obtainConstantGeneDictionary(GeneDictionary, GetGeneDictionaryOptions, AugmentDictionary)[source]¶

Obtain gene dictionary - if it exists can either augment with new information or Species or create new, if not exist then create variable.

Parameters:

GeneDictionary: dictionary or None: An existing variable to use as a gene dictionary in annotations. If set to None the default ConstantGeneDictionary will be used
GetGeneDictionaryOptions: dictionary: A list of options that will be passed to this internal GetGeneDictionary function
AugmentDictionary: boolean: A choice whether or not to augment the current ConstantGeneDictionary global variable or create a new one

Returns:

None

Usage:

obtainConstantGeneDictionary(None, {}, False)

GOAnalysis(data, GetGeneDictionaryOptions={}, AugmentDictionary=True, InputID=['UniProt ID', 'Gene Symbol'], OutputID='UniProt ID', GOAnalysisAssignerOptions={}, BackgroundSet=[], Species='human', OntologyLengthFilter=2, ReportFilter=1, ReportFilterFunction=<ufunc 'greater_equal'>, pValueCutoff=0.05, TestFunction=<function <lambda>>, HypothesisFunction=<function <lambda>>, FilterSignificant=True, OBODictionaryVariable=None, OBOGODictionaryOptions={}, MultipleListCorrection=None, MultipleList=False, GeneDictionary=None)[source]¶

Calculate input data over-representation analysis for Gene Ontology (GO) categories.

Parameters:

data: pd.DataFrame or list: Data to analyze
GetGeneDictionaryOptions: dictionary, Default {}: A list of options that will be passed to this internal GetGeneDictionary function
AugmentDictionary: boolean, Default True: A choice whether or not to augment the current ConstantGeneDictionary global variable or create a new one
InputID: list, Default [“UniProt ID”,”Gene Symbol”]: Kind of identifiers/accessions used as input
OutputID: str, Default “UniProt ID”: Kind of IDs/accessions to convert the input IDs/accession numbers in the function’s analysis
GOAnalysisAssignerOptions: dictionary, Default {}: A list of options that will be passed to the internal GOAnalysisAssigner function
BackgroundSet: list, Default []: Background list to create annotation projection to limited background space, involves considering pathways/groups/sets and that provides a list of IDs (e.g. gene accessions) that should be considered as the background for the calculation
Species: str, Default “human”: The species considered in the calculation, by default corresponding to human
OntologyLengthFilter: int, Default 2: Function that can be used to set the value for which terms to consider in the computation, by excluding GO terms that have fewer items compared to the OntologyLengthFilter value. It is used by the internal GOAnalysisAssigner function
ReportFilter: int, Default 1: Functions that use pathways/ontologies/groups, and provides a cutoff for membership in ontologies/pathways/groups in selecting which terms/categories to return. It is typically used in conjunction with ReportFilterFunction
ReportFilterFunction: function , Default np.greater_equal: Specifies what operator form will be used to compare against ReportFilter option value in selecting which terms/categories to return
pValueCutoff: float, Default 0.05: Significance cutoff
TestFunction: function, Default lambda n, N, M, x: 1. - scipy.stats.hypergeom.cdf(x-1, M, n, N): Test function
HypothesisFunction: function, Default lambda data, SignificanceLevel: BenjaminiHochbergFDR(data, SignificanceLevel=SignificanceLevel)[“Results”]: Allows the choice of function for implementing multiple hypothesis testing considerations
FilterSignificant: boolean, Default True: Can be set to True to filter data based on whether the analysis result is statistically significant, or if set to False to return all membership computations
OBODictionaryVariable: str, Default None: A GO annotation variable. If set to None, OBOGODictionary will be used internally to automatically generate the default GO annotation
OBOGODictionaryOptions: dictionary, Default {}: A list of options to be passed to the internal OBOGODictionary function that provides the GO annotations
MultipleListCorrection: boolean, Default None: Specifies whether or not to correct for multi-omics analysis. The choices are None, Automatic, or a custom number, e.g protein+RNA
MultipleList: boolean, Default False: Specifies whether the input accessions list constituted a multi-omics list input that is annotated so
GeneDictionary: str, Default None: Points to an existing variable to use as a gene dictionary in annotations. If set to None the default ConstantGeneDictionary will be used

Returns:

dictionary: Enrichment dictionary

Usage:

goExample1 = GOAnalysis([“TAB1”, “TNFSF13B”, “MALT1”, “TIRAP”, “CHUK”,: “TNFRSF13C”, “PARP1”, “CSNK2A1”, “CSNK2A2”, “CSNK2B”, “LTBR”, “LYN”, “MYD88”, “GADD45B”, “ATM”, “NFKB1”, “NFKB2”, “NFKBIA”, “IRAK4”, “PIAS4”, “PLAU”])

GeneTranslation(InputList, TargetIDList, GeneDictionary, InputID=None, Species='human')[source]¶

Use geneDictionary to convert inputList IDs to different annotations as indicated by targetIDList.

Parameters:

InputList: list: List of names
TargetIDList: list: Target ID list
GeneDictionary: dictionary: An existing variable to use as a gene dictionary in annotations. If set to None the default ConstantGeneDictionary will be used
InputID: str, Default None: The kind of identifiers/accessions used as input
Species: str, Default “human”: The species considered in the calculation, by default corresponding to human

Returns:

dictionary: Gene dictionary

Usage:

GenDict = GeneTranslation(data, “UniProt ID”, ConstantGeneDictionary, InputID = [“UniProt ID”,”Gene Symbol”], Species = “human”)

KEGGAnalysisAssigner(PyIOmicaDataDirectory=None, ImportDirectly=False, BackgroundSet=[], KEGGQuery1='pathway', KEGGQuery2='hsa', LengthFilter=None, LengthFilterFunction=<ufunc 'greater_equal'>, Labels=['IDToPath', 'PathToID'])[source]¶

Create KEGG: Kyoto Encyclopedia of Genes and Genomes pathway associations, restricted to required background set, downloading the data if necessary.

Parameters:

PyIOmicaDataDirectory: str, Default None: Directory where the default package data is stored
ImportDirectly: boolean, Default False: Import from URL regardles is the file already exists
BackgroundSet: list, Default []: A list of IDs (e.g. gene accessions) that should be considered as the background for the calculation
KEGGQuery1: str, Default “pathway”: Make KEGG API calls, and sets string query1 in http://rest.kegg.jp/link/<> query1 <> / <> query2. Typically this will be used as the target database to find related entries by using database cross-references
KEGGQuery2: str, Default “hsa”: KEGG API calls, and sets string query2 in http://rest.kegg.jp/link/<> query1 <> / <> query2. Typically this will be used as the source database to find related entries by using database cross-references
LengthFilterFunction: function, Default np.greater_equal: Option for functions that perform computations of membership in pathways/ontologies/groups/sets, that specifies which function to use to filter the number of members a reported category has compared to the number typically provided by LengthFilter
LengthFilter: int, Default None: Allows the selection of how many members each category can have, as typically restricted by the LengthFilterFunction
Labels: list, Default [“IDToPath”, “PathToID”]: A string list for how keys in a created association will be named

Returns:

dictionary: IDToPath and PathToID dictionary

Usage:

KEGGassignment = KEGGAnalysisAssigner()

KEGGDictionary(PyIOmicaDataDirectory=None, ImportDirectly=False, KEGGQuery1='pathway', KEGGQuery2='hsa')[source]¶

Create a dictionary from KEGG: Kyoto Encyclopedia of Genes and Genomes terms - typically association of pathways and members therein.

Parameters:

PyIOmicaDataDirectory: str, Default None: directory where the default package data is stored
ImportDirectly: boolean, Default False: import from URL regardles is the file already exists
KEGGQuery1: str, Default “pathway”: make KEGG API calls, and sets string query1 in http://rest.kegg.jp/link/<> query1 <> / <> query2. Typically this will be used as the target database to find related entries by using database cross-references
KEGGQuery2: str, Default “hsa”: KEGG API calls, and sets string query2 in http://rest.kegg.jp/link/<> query1 <> / <> query2. Typically this will be used as the source database to find related entries by using database cross-references

Returns:

dictionary: Dictionary of definitions

Usage:

KEGGDict = KEGGDictionary()

KEGGAnalysis(data, AnalysisType='Genomic', GetGeneDictionaryOptions={}, AugmentDictionary=True, InputID=['UniProt ID', 'Gene Symbol'], OutputID='KEGG Gene ID', MolecularInputID=['cpd'], MolecularOutputID='cpd', KEGGAnalysisAssignerOptions={}, BackgroundSet=[], KEGGOrganism='hsa', KEGGMolecular='cpd', KEGGDatabase='pathway', PathwayLengthFilter=2, ReportFilter=1, ReportFilterFunction=<ufunc 'greater_equal'>, pValueCutoff=0.05, TestFunction=<function <lambda>>, HypothesisFunction=<function <lambda>>, FilterSignificant=True, KEGGDictionaryVariable=None, KEGGDictionaryOptions={}, MultipleListCorrection=None, MultipleList=False, GeneDictionary=None, Species='human', MolecularSpecies='compound', NonUCSC=False, PyIOmicaDataDirectory=None)[source]¶

Calculate input data over-representation analysis for KEGG: Kyoto Encyclopedia of Genes and Genomes pathways. Input can be a list, a dictionary of lists or a clustering object.

Parameters:

data: pandas.DetaFrame or list: Data to analyze
AnalysisType: str, Default “Genomic”: Analysis methods that may be used, “Genomic”, “Molecular” or “All”
GetGeneDictionaryOptions: dictionary, Default {}: A list of options that will be passed to this internal GetGeneDictionary function
AugmentDictionary: boolean, Default True: A choice whether or not to augment the current ConstantGeneDictionary global variable or create a new one
InputID: list, Default [“UniProt ID”, “Gene Symbol”]: The kind of identifiers/accessions used as input
OutputID: str, Default “KEGG Gene ID”: A string value that specifies what kind of IDs/accessions to convert the input IDs/accession numbers in the function’s analysis
MolecularInputID: list, Default [“cpd”]: A string list to indicate the kind of ID to use for the input molecule entries
MolecularOutputID: str, Default “cpd”: A string list to indicate the kind of ID to use for the input molecule entries
KEGGAnalysisAssignerOptions: dictionary, Default {}: A list of options that will be passed to this internal KEGGAnalysisAssigner function
BackgroundSet: list, Default []: A list of IDs (e.g. gene accessions) that should be considered as the background for the calculation
KEGGOrganism: str, Default “hsa”: Indicates which organism (org) to use for “Genomic” type of analysis (default is human analysis: org=”hsa”)
KEGGMolecular: str, Default “cpd”: Which database to use for molecular analysis (default is the compound database: cpd)
KEGGDatabase: str, Default “pathway”: KEGG database to use as the target database
PathwayLengthFilter: int, Default 2: Pathways to consider in the computation, by excluding pathways that have fewer items compared to the PathwayLengthFilter value
ReportFilter: int, Default 1: Provides a cutoff for membership in ontologies/pathways/groups in selecting which terms/categories to return. It is typically used in conjunction with ReportFilterFunction
ReportFilterFunction: function, Default np.greater_equal: Operator form will be used to compare against ReportFilter option value in selecting which terms/categories to return
pValueCutoff: float, Default 0.05: A cutoff p-value for (adjusted) p-values to assess statistical significance
TestFunction: function, Default lambda n, N, M, x: 1. - scipy.stats.hypergeom.cdf(x-1, M, n, N): A function used to calculate p-values
HypothesisFunction: function, Default lambda data, SignificanceLevel: BenjaminiHochbergFDR(data, SignificanceLevel=SignificanceLevel)[“Results”]: Allows the choice of function for implementing multiple hypothesis testing considerations
FilterSignificant: boolean, Default True: Can be set to True to filter data based on whether the analysis result is statistically significant, or if set to False to return all membership computations
KEGGDictionaryVariable: str, Default None: KEGG dictionary, and provides a KEGG annotation variable. If set to None, KEGGDictionary will be used internally to automatically generate the default KEGG annotation
KEGGDictionaryOptions: dictionary, Default {}: A list of options to be passed to the internal KEGGDictionary function that provides the KEGG annotations
MultipleListCorrection: boolean, Default None: Specifies whether or not to correct for multi-omics analysis. The choices are None, Automatic, or a custom number
MultipleList: boolean, Default False: Whether the input accessions list constituted a multi-omics list input that is annotated so
GeneDictionary: str, Default None: Existing variable to use as a gene dictionary in annotations. If set to None the default ConstantGeneDictionary will be used
Species: str, Default “human”: The species considered in the calculation, by default corresponding to human
MolecularSpecies: str, Default “compound”: The kind of molecular input
NonUCSC: , Default: If UCSC browser was used in determining an internal GeneDictionary used in ID translations, where the KEGG identifiers for genes are number strings (e.g. 4790).The NonUCSC option can be set to True if standard KEGG accessions are used in a user provided GeneDictionary variable, in the form OptionValue[KEGGOrganism] <>:<>numberString, e.g. hsa:4790
PyIOmicaDataDirectory: str, Default None: Directory where the default package data is stored

Returns:

dictionary: Enrichment dictionary

Usage:

keggExample1 = KEGGAnalysis([“TAB1”, “TNFSF13B”, “MALT1”, “TIRAP”, “CHUK”, “TNFRSF13C”, “PARP1”, “CSNK2A1”, “CSNK2A2”, “CSNK2B”, “LTBR”, “LYN”, “MYD88”,: “GADD45B”, “ATM”, “NFKB1”, “NFKB2”, “NFKBIA”, “IRAK4”, “PIAS4”, “PLAU”, “POLR3B”, “NME1”, “CTPS1”, “POLR3A”])

MassMatcher(data, accuracy, MassDictionaryVariable=None, MolecularSpecies='cpd')[source]¶

Assign putative mass identification to input data based on monoisotopic mass (using PyIOmica’s mass dictionary). The accuracy in parts per million.

Parameters:

data: np.array: Input data
accuracy: float: Accuracy
MassDictionaryVariable: boolean, Default None: Mass dictionary variable. If set to None, inbuilt mass dictionary (MassDictionary) will be loaded and used
MolecularSpecies: str, Default “cpd”: The kind of molecular input

Returns:

list: List of IDs

Usage:

result = MassMatcher(18.010565, 2)

MassDictionary(PyIOmicaDataDirectory=None)[source]¶

Load PyIOmica’s current mass dictionary.

Parameters:

PyIOmicaDataDirectory: str, Default None: Directory where the default package data is stored

Returns:

dictionary: Mass dictionary

Usage:

MassDict = MassDictionary()

ExportEnrichmentReport(data, AppendString='', OutputDirectory=None)[source]¶

Export results from enrichment analysis to Excel spreadsheets.

Parameters:

data: dictionary: Enrichment results
AppendString: str, Default “”: Custom report name, if empty then time stamp will be used
OutputDirectory: boolean, Default None: Path of directories where the report will be saved

Returns:

None

Usage:

ExportEnrichmentReport(goExample1, AppendString=’goExample1’, OutputDirectory=None)

BenjaminiHochbergFDR(pValues, SignificanceLevel=0.05)[source]¶

HypothesisTesting BenjaminiHochbergFDR correction

Parameters:

pValues: 1d numpy.array: Array of p-values
SignificanceLevel: float, Default 0.05: Significance level

Returns:

dictionary: Corrected p-Values, p- and q-Value cuttoffs

Usage:

result = BenjaminiHochbergFDR(pValues)

ReactomeAnalysis(data, uploadURL='https://reactome.org/AnalysisService/identifiers/projection', preDownloadURL='https://reactome.org/AnalysisService/download/', postDownloadURL='/pathways/TOTAL/result.csv', headersPOST={'accept': 'application/json', 'content-type': 'text/plain'}, headersGET={'accept': 'text/CSV'}, URLparameters=(('interactors', 'false'), ('pageSize', '20'), ('page', '1'), ('sortBy', 'ENTITIES_PVALUE'), ('order', 'ASC'), ('resource', 'TOTAL')))[source]¶

Reactome POST-GET-style analysis.

Parameters:

data: pd.DataFrame or list: Data to analyze
uploadURL: str, Default ‘https://reactome.org/AnalysisService/identifiers/projection’: URL for POST request
preDownloadURL: str, Default ‘https://reactome.org/AnalysisService/download/’: Part 1 of URL for GET request
postDownloadURL: str, Default ‘/pathways/TOTAL/result.csv’: Part 2 of URL for GET request
headersPOST: dict, Default {‘accept’: ‘application/json’, ‘content-type’: ‘text/plain’}: URL headers for POST request
headersGET: dict, Default {‘accept’: ‘text/CSV’}: URL headers for GET request
URLparameters: tuple, Default ((‘interactors’, ‘false’), (‘pageSize’, ‘20’), (‘page’, ‘1’), (‘sortBy’, ‘ENTITIES_PVALUE’), (‘order’, ‘ASC’), (‘resource’, ‘TOTAL’)): Parameters for POST request

Returns:

returning: Enrichment object

Usage:

goExample1 = ReactomeAnalysis([“TAB1”, “TNFSF13B”, “MALT1”, “TIRAP”, “CHUK”,: “TNFRSF13C”, “PARP1”, “CSNK2A1”, “CSNK2A2”, “CSNK2B”, “LTBR”, “LYN”, “MYD88”, “GADD45B”, “ATM”, “NFKB1”, “NFKB2”, “NFKBIA”, “IRAK4”, “PIAS4”, “PLAU”])

ExportReactomeEnrichmentReport(data, AppendString='', OutputDirectory=None)[source]¶

Export results from enrichment analysis to Excel spreadsheets.

Parameters:

data: dictionary or pandas.DataFrame: Reactome pathway enrichment results
AppendString: str, Default “”: Custom report name, if empty then time stamp will be used
OutputDirectory: boolean, Default None: Path of directories where the report will be saved

Returns:

None

Usage:

ExportReactomeEnrichmentReport(example1, AppendString=’example1’, OutputDirectory=None)