msreport 0.0.28__py3-none-any.whl → 0.0.30__py3-none-any.whl

msreport/__init__.py

@@ -8,4 +8,4 @@ from msreport.fasta import import_protein_database
 from msreport.qtable import Qtable
 from msreport.reader import FragPipeReader, MaxQuantReader, SpectronautReader
 
-__version__ = "0.0.28"
+__version__ = "0.0.30"

msreport/analyze.py

@@ -9,10 +9,19 @@ import numpy as np
 import pandas as pd
 
 import msreport.normalize
-import msreport.rinterface
+from msreport.errors import OptionalDependencyError
 from msreport.helper import find_sample_columns
 from msreport.qtable import Qtable
 
+try:
+    import msreport.rinterface
+
+    _rinterface_available = True
+    _rinterface_error = ""
+except OptionalDependencyError as err:
+    _rinterface_available = False
+    _rinterface_error = str(err)
+
 
 class Transformer(Protocol):
     def fit(self, table: pd.DataFrame) -> Transformer:
@@ -528,8 +537,10 @@ def calculate_multi_group_limma(
         ValueError: If all values from qtable.design["Batch"] are identical when 'batch'
             is set to True.
     """
-    _validate_experiment_pairs(qtable, experiment_pairs)
+    if not _rinterface_available:
+        raise OptionalDependencyError(_rinterface_error)
 
+    _validate_experiment_pairs(qtable, experiment_pairs)
     # TODO: not tested #
     if batch and "Batch" not in qtable.get_design():
         raise KeyError(
@@ -618,8 +629,10 @@ def calculate_two_group_limma(
             must have exactly two entries and the two entries must not be the same. Both
             experiments must be present in qtable.design.
     """
-    _validate_experiment_pair(qtable, experiment_pair)
+    if not _rinterface_available:
+        raise OptionalDependencyError(_rinterface_error)
 
+    _validate_experiment_pair(qtable, experiment_pair)
     # TODO: LIMMA function not tested #
     table = qtable.make_expression_table(samples_as_columns=True)
     comparison_tag = " vs "

msreport/errors.py

@@ -7,3 +7,7 @@ class NotFittedError(ValueError, AttributeError):
 
 class ProteinsNotInFastaWarning(UserWarning):
     """Warning raised when queried proteins are absent from a FASTA file."""
+
+
+class OptionalDependencyError(ImportError):
+    """Raised when an optional dependency is required but not installed."""

msreport/plot/distribution.py

@@ -204,7 +204,8 @@ def experiment_ratios(
     mask = np.all([(qtable.data[f"Events {exp}"] > 0) for exp in experiments], axis=0)
     if exclude_invalid:
         mask = mask & qtable["Valid"]
-    experiment_data = experiment_data[mask]
+    # Use `mask.to_numpy` to solve issue with different indices of mask and dataframe
+    experiment_data = experiment_data[mask.to_numpy()]
     pseudo_reference = np.nanmean(experiment_data, axis=1)
     ratio_data = experiment_data.subtract(pseudo_reference, axis=0)
 

msreport/qtable.py

@@ -27,13 +27,11 @@ class Qtable:
         design: A pandas.DataFrame describing the experimental design.
     """
 
-    _default_id_column = "Representative protein"
-
     def __init__(
         self,
         data: pd.DataFrame,
-        design: Optional[pd.DataFrame] = None,
-        id_column: str = "Representative protein",
+        design: pd.DataFrame,
+        id_column: str,
     ):
         """Initializes the Qtable.
 
@@ -42,12 +40,13 @@ class Qtable:
 
         Args:
             data: A dataframe containing quantitative proteomics data in a wide format.
+                The index of the dataframe must contain unique values.
             design: A dataframe describing the experimental design that must at least
                 contain the columns "Sample" and "Experiment". The "Sample" entries
                 should correspond to the Sample names present in the quantitative
                 columns of the data.
             id_column: The name of the column that contains the unique identifiers for
-                the entries in the data table. Default is "Representative protein".
+                the entries in the data table.
 
         Raises:
             KeyError: If the specified id_column is not found in data.
@@ -76,8 +75,7 @@ class Qtable:
         self._id_column = id_column
         if "Valid" not in self.data.columns:
             self.data["Valid"] = True
-        if design is not None:
-            self.add_design(design)
+        self.add_design(design)
 
         self._expression_columns: list[str] = []
         self._expression_features: list[str] = []
@@ -438,6 +436,11 @@ class Qtable:
 
         Returns:
             An instance of Qtable loaded from the specified files.
+
+        Raises:
+            ValueError: If the loaded config file does not contain the
+                "Unique ID column" key. This is due to the qtable being saved with a
+                version of msreport <= 0.0.27.
         """
         filepaths = _get_qtable_export_filepaths(directory, basename)
         with open(filepaths["config"]) as openfile:
@@ -458,13 +461,20 @@ class Qtable:
                 filepaths["design"], sep="\t", index_col=0, keep_default_na=True
             )
 
-        qtable = Qtable(data, design)
+        if "Unique ID column" not in config_data:
+            # Mention that the qtable was likely saved with a version of msreport <= 0.0.27
+            raise ValueError(
+                "The qtable config file does not contain the 'Unique ID column' key. "
+                "This is likely due to the qtable being saved with a version of "
+                "msreport <= 0.0.27."
+            )
+        id_column = config_data["Unique ID column"]
+
+        qtable = Qtable(data, design, id_column)
         qtable._expression_columns = config_data["Expression columns"]
         qtable._expression_features = config_data["Expression features"]
         qtable._expression_sample_mapping = config_data["Expression sample mapping"]
         # This check is required for backwards compatibility with msreport <= 0.0.27
-        if "Unique ID column" in config_data:
-            qtable._id_column = config_data["Unique ID column"]
         return qtable
 
     def to_tsv(self, path: str, index: bool = False):
@@ -570,7 +580,7 @@ class Qtable:
         self._expression_sample_mapping = {}
 
     def __copy__(self) -> Qtable:
-        new_instance = Qtable(self.data, self.design)
+        new_instance = Qtable(self.data, self.design, self.id_column)
         # Copy all private attributes
         for attr in dir(self):
             if (

msreport/reader.py

@@ -343,7 +343,9 @@ class MaxQuantReader(ResultReader):
         Adds new columns to comply with the MsReport convention. "Modified sequence",
         "Modifications columns", "Modification localization string". "Protein reported
         by software" and "Representative protein", both contain the first entry from
-        "Leading razor protein".
+        "Leading razor protein". "Ion ID" contains unique entries for each ion, which
+        are generated by concatenating the "Modified sequence" and "Charge" columns, and
+        if present, the "Compensation voltage" column.
 
         "Modified sequence" entries contain modifications within square brackets.
         "Modification" entries are strings in the form of "position:modification_tag",
@@ -376,15 +378,19 @@ class MaxQuantReader(ResultReader):
             df["Leading razor protein"]
         )
         df["Representative protein"] = df["Protein reported by software"]
+
         if drop_decoy:
             df = self._drop_decoy(df)
         if rename_columns:
-            df = self._rename_columns(
-                df, True
-            )  # Actually there are no column tags as the table is in long format
+            # Actually there are no column tags as the table is in long format
+            df = self._rename_columns(df, prefix_tag=True)
         if rewrite_modifications and rename_columns:
             df = self._add_peptide_modification_entries(df)
             df = self._add_modification_localization_string(df)
+            df["Ion ID"] = df["Modified sequence"] + "_c" + df["Charge"].astype(str)
+            if "Compensation voltage" in df.columns:
+                _cv = df["Compensation voltage"].astype(str)
+                df["Ion ID"] = df["Ion ID"] + "_cv" + _cv
         return df
 
     def _add_protein_entries(self, df: pd.DataFrame) -> pd.DataFrame:
@@ -535,6 +541,8 @@ class FragPipeReader(ResultReader):
     """FragPipe result reader.
 
     Methods:
+        import_design: Reads a "fragpipe-files.fp-manifest" file and returns a
+            processed design dataframe.
         import_proteins: Reads a "combined_protein.tsv" or "protein.tsv" file and
             returns a processed dataframe, conforming to the MsReport naming
             convention.
@@ -576,12 +584,20 @@ class FragPipeReader(ResultReader):
         "peptides": "combined_peptide.tsv",
         "ions": "combined_ion.tsv",
         "ion_evidence": "ion.tsv",
+        "psm_evidence": "psm.tsv",
+        "design": "fragpipe-files.fp-manifest",
     }
     isobar_filenames: dict[str, str] = {
         "proteins": "protein.tsv",
         "peptides": "peptide.tsv",
         "ions": "ion.tsv",
     }
+    sil_filenames: dict[str, str] = {
+        "proteins": "combined_protein_label_quant.tsv",
+        "peptides": "combined_modified_peptide_label_quant.tsv",
+        "ions": "combined_ion_label_quant.tsv",
+    }
+
     protected_columns: list[str] = []
     sample_column_tags: list[str] = [
         "Spectral Count",
@@ -591,10 +607,18 @@ class FragPipeReader(ResultReader):
         "MaxLFQ Intensity",
     ]
     column_mapping: dict[str, str] = {
+        "Peptide": "Peptide sequence",  # PSM
+        "Modified Peptide": "Modified sequence",  # PSM
+        "Protein Start": "Start position",  # PSM
+        "Protein End": "End position",  # PSM
+        "Number of Missed Cleavages": "Missed cleavage",  # PSM
+        "PeptideProphet Probability": "Probability",  # PSM
+        "Compensation Voltage": "Compensation voltage",  # PSM and ion
         "Peptide Sequence": "Peptide sequence",  # Peptide and ion
         "Modified Sequence": "Modified sequence",  # Modified peptide and ion
         "Start": "Start position",  # Peptide and ion
         "End": "End position",  # Peptide and ion
+        "Mapped Proteins": "Mapped proteins",  # All PSM, ion, and peptide tables
         "Combined Total Peptides": "Total peptides",  # From LFQ
         "Total Peptides": "Total peptides",  # From TMT
         "Description": "Protein name",
@@ -624,7 +648,11 @@ class FragPipeReader(ResultReader):
     protein_info_tags: list[str] = []
 
     def __init__(
-        self, directory: str, isobar: bool = False, contaminant_tag: str = "contam_"
+        self,
+        directory: str,
+        isobar: bool = False,
+        sil: bool = False,
+        contaminant_tag: str = "contam_",
     ) -> None:
         """Initializes the FragPipeReader.
 
@@ -632,16 +660,69 @@ class FragPipeReader(ResultReader):
             directory: Location of the FragPipe result folder
             isobar: Set to True if quantification strategy was TMT, iTRAQ or similar;
                 default False.
+            sil: Set to True if the FragPipe result files are from a stable isotope
+                labeling experiment, such as SILAC; default False.
             contaminant_tag: Prefix of Protein ID entries to identify contaminants;
                 default "contam_".
         """
+        if sil and isobar:
+            raise ValueError("Cannot set both 'isobar' and 'sil' to True.")
         self._add_data_directory(directory)
         self._isobar: bool = isobar
+        self._sil: bool = sil
         self._contaminant_tag: str = contaminant_tag
-        if not isobar:
+        if isobar:
+            self.filenames = self.isobar_filenames
+        elif sil:
+            self.filenames = self.sil_filenames
+        else:
             self.filenames = self.default_filenames
+
+    def import_design(
+        self, filename: Optional[str] = None, sort: bool = False
+    ) -> pd.DataFrame:
+        """Reads a 'fp-manifest' file and returns a processed design dataframe.
+
+        Args:
+            filename: Allows specifying an alternative filename, otherwise the default
+                filename is used.
+            sort: If True, the design dataframe is sorted by "Experiment" and
+                "Replicate"; default False.
+
+        Returns:
+            A dataframe containing the processed design table with columns:
+            "Sample", "Experiment", "Replicate", "Rawfile".
+
+        Raises:
+            FileNotFoundError: If the specified manifest file does not exist.
+        """
+        if filename is None:
+            filepath = os.path.join(self.data_directory, self.filenames["design"])
         else:
-            self.filenames = self.isobar_filenames
+            filepath = os.path.join(self.data_directory, filename)
+        if not os.path.exists(filepath):
+            raise FileNotFoundError(
+                f"File '{filepath}' does not exist. Please check the file path."
+            )
+        fp_manifest = pd.read_csv(filepath, sep="\t", header=None, dtype=str)
+        fp_manifest.columns = ["Path", "Experiment", "Bioreplicate", "Data type"]
+
+        design = pd.DataFrame(
+            {
+                "Sample": fp_manifest["Experiment"] + "_" + fp_manifest["Bioreplicate"],
+                "Experiment": fp_manifest["Experiment"],
+                "Replicate": fp_manifest["Bioreplicate"],
+                "Rawfile": fp_manifest["Path"].apply(
+                    # Required to handle Windows and Unix style paths on either system
+                    lambda x: x.replace("\\", "/").split("/")[-1]
+                ),
+            }
+        )
+
+        if sort:
+            design.sort_values(by=["Experiment", "Replicate"], inplace=True)
+            design.reset_index(drop=True, inplace=True)
+        return design
 
     def import_proteins(
         self,
@@ -723,6 +804,7 @@ class FragPipeReader(ResultReader):
         df = self._read_file("peptides" if filename is None else filename)
         df["Protein reported by software"] = _extract_protein_ids(df["Protein"])
         df["Representative protein"] = df["Protein reported by software"]
+        df["Mapped Proteins"] = self._collect_mapped_proteins(df)
         # Note that _add_protein_entries would need to be adapted for the peptide table.
         # df = self._add_protein_entries(df)
         if rename_columns:
@@ -741,7 +823,10 @@ class FragPipeReader(ResultReader):
 
         Adds new columns to comply with the MsReport convention. "Modified sequence"
         and "Modifications columns". "Protein reported by software" and "Representative
-        protein", both contain the first entry from "Leading razor protein".
+        protein", both contain the first entry from "Leading razor protein". "Ion ID"
+        contains unique entries for each ion, which are generated by concatenating the
+        "Modified sequence" and "Charge" columns, and if present, the
+        "Compensation voltage" column.
 
         "Modified sequence" entries contain modifications within square brackets.
         "Modification" entries are strings in the form of "position:modification_text",
@@ -776,11 +861,18 @@ class FragPipeReader(ResultReader):
         #         'Indistinguishable Proteins' to the ion table.
         df["Protein reported by software"] = _extract_protein_ids(df["Protein"])
         df["Representative protein"] = df["Protein reported by software"]
+        df["Mapped Proteins"] = self._collect_mapped_proteins(df)
+
         if rename_columns:
             df = self._rename_columns(df, prefix_column_tags)
         if rewrite_modifications and rename_columns:
             df = self._add_peptide_modification_entries(df)
             df = self._add_modification_localization_string(df, prefix_column_tags)
+            df["Ion ID"] = df["Modified sequence"] + "_c" + df["Charge"].astype(str)
+            if "Compensation voltage" in df.columns:
+                _cv = df["Compensation voltage"].astype(str)
+                df["Ion ID"] = df["Ion ID"] + "_cv" + _cv
+
         return df
 
     def import_ion_evidence(
@@ -795,7 +887,9 @@ class FragPipeReader(ResultReader):
         Adds new columns to comply with the MsReport convention. "Modified sequence",
         "Modifications", and "Modification localization string" columns. "Protein
         reported by software" and "Representative protein", both contain the first entry
-        from "Leading razor protein".
+        from "Leading razor protein". "Ion ID" contains unique entries for each ion,
+        which are generated by concatenating the "Modified sequence" and "Charge"
+        columns, and if present, the "Compensation voltage" column.
 
         "Modified sequence" entries contain modifications within square brackets.
         "Modification" entries are strings in the form of "position:modification_text",
@@ -848,10 +942,15 @@ class FragPipeReader(ResultReader):
         df = pd.concat(ion_tables, ignore_index=True)
 
         # --- Process dataframe --- #
+        df["Ion ID"] = df["Modified Sequence"] + "_c" + df["Charge"].astype(str)
+        if "Compensation Voltage" in df.columns:
+            df["Ion ID"] = df["Ion ID"] + "_cv" + df["Compensation Voltage"].astype(str)
         # FUTURE: replace this by _add_protein_entries(df, False) if FragPipe adds
         #         'Indistinguishable Proteins' to the ion table.
         df["Protein reported by software"] = _extract_protein_ids(df["Protein"])
         df["Representative protein"] = df["Protein reported by software"]
+        df["Mapped Proteins"] = self._collect_mapped_proteins(df)
+
         if rename_columns:
             df = self._rename_columns(df, prefix_column_tags)
         if rewrite_modifications and rename_columns:
@@ -859,6 +958,60 @@ class FragPipeReader(ResultReader):
             df = self._add_modification_localization_string(df, prefix_column_tags)
         return df
 
+    def import_psm_evidence(
+        self,
+        filename: Optional[str] = None,
+        rename_columns: bool = True,
+        rewrite_modifications: bool = True,
+    ):
+        """Concatenate all "psm.tsv" files and return a processed dataframe.
+
+        Args:
+            filename: Allows specifying an alternative filename, otherwise the default
+                filename is used.
+            rename_columns: If True, columns are renamed according to the MsReport
+                convention; default True.
+            rewrite_modifications: If True, the peptide format in "Modified sequence" is
+                changed according to the MsReport convention, and a "Modifications" is
+                added to contains the amino acid position for all modifications.
+                Requires 'rename_columns' to be true. Default True.
+
+        Returns:
+            A DataFrame containing the processed psm evidence tables.
+        """
+        if filename is None:
+            filename = self.default_filenames["psm_evidence"]
+
+        psm_table_paths = []
+        for path in pathlib.Path(self.data_directory).iterdir():
+            psm_table_path = path / filename
+            if path.is_dir() and psm_table_path.exists():
+                psm_table_paths.append(psm_table_path)
+
+        psm_tables = []
+        for filepath in psm_table_paths:
+            table = pd.read_csv(filepath, sep="\t", low_memory=False)
+            str_cols = table.select_dtypes(include=["object"]).columns
+            table.loc[:, str_cols] = table.loc[:, str_cols].fillna("")
+
+            table["Sample"] = filepath.parent.name
+            psm_tables.append(table)
+        df = pd.concat(psm_tables, ignore_index=True)
+
+        df["Protein reported by software"] = _extract_protein_ids(df["Protein"])
+        df["Representative protein"] = df["Protein reported by software"]
+        df["Mapped Proteins"] = self._collect_mapped_proteins(df)
+
+        if rename_columns:
+            df = self._rename_columns(df, prefix_tag=True)
+        if rewrite_modifications and rename_columns:
+            mod_entries = _generate_modification_entries_from_assigned_modifications(
+                df["Peptide sequence"], df["Assigned Modifications"]
+            )
+            df["Modified sequence"] = mod_entries["Modified sequence"]
+            df["Modifications"] = mod_entries["Modifications"]
+        return df
+
     def _add_protein_entries(self, df: pd.DataFrame) -> pd.DataFrame:
         """Adds standardized protein entry columns to the data frame.
 
@@ -883,6 +1036,35 @@ class FragPipeReader(ResultReader):
             df[key] = protein_entry_table[key]
         return df
 
+    def _collect_mapped_proteins(self, df: pd.DataFrame) -> list[str]:
+        """Generates a list of mapped proteins entries.
+
+        This method extracts protein IDs from the 'Representative protein' and the
+        'Mapped Proteins' column and combines them into a single string for each row,
+        where multiple protein IDs are separated by semicolons.
+
+        Args:
+            df: DataFrame containing the 'Mapped Proteins' column.
+
+        Returns:
+            A list of mapped proteins entries.
+        """
+        mapped_proteins_entries = []
+        for protein, mapped_protein_fp in zip(
+            df["Representative protein"],
+            df["Mapped Proteins"].astype(str).replace("nan", ""),
+            strict=True,
+        ):
+            if mapped_protein_fp == "":
+                mapped_proteins = [protein]
+            else:
+                additional_mapped_proteins = msreport.reader._extract_protein_ids(
+                    mapped_protein_fp.split(", ")
+                )
+                mapped_proteins = [protein] + additional_mapped_proteins
+            mapped_proteins_entries.append(";".join(mapped_proteins))
+        return mapped_proteins_entries
+
     def _collect_leading_protein_entries(self, df: pd.DataFrame) -> list[list[str]]:
         """Generates a list of leading protein entries.
 
@@ -898,6 +1080,9 @@ class FragPipeReader(ResultReader):
             A list of the same length as the input dataframe. Each position contains a
             list of leading protein entries, which a minimum of one entry.
         """
+        if self._sil:  # No "Indistinguishable Proteins" columns in 'SIL' data
+            return [[p] for p in df["Protein"]]
+
         leading_protein_entries = []
         for protein_entry, indist_protein_entry in zip(
             df["Protein"], df["Indistinguishable Proteins"].fillna("").astype(str)
@@ -1319,7 +1504,9 @@ class SpectronautReader(ResultReader):
 
         Adds new columns to comply with the MsReport convention. "Protein reported
         by software" and "Representative protein", both contain the first entry from
-        "PG.ProteinAccessions".
+        "PG.ProteinAccessions". "Ion ID" contains unique entries for each ion, which are
+        generated by concatenating the "Modified sequence" and "Charge" columns, and if
+        present, the "Compensation voltage" column.
 
         (!) Note that the modified sequence and modification localization probabilities
         are currently not processed.
@@ -1357,6 +1544,11 @@ class SpectronautReader(ResultReader):
         df = self._add_protein_entries(df)
         if rename_columns:
             df = self._rename_columns(df, True)
+            df["Ion ID"] = df["Modified sequence"] + "_c" + df["Charge"].astype(str)
+            if "Compensation voltage" in df.columns:
+                _cv = df["Compensation voltage"].astype(str)
+                df["Ion ID"] = df["Ion ID"] + "_cv" + _cv
+
         return df
 
     def _tidy_up_sample_columns(self, df: pd.DataFrame) -> pd.DataFrame:
@@ -2141,6 +2333,57 @@ def _generate_modification_entries(
     return entries
 
 
+def _generate_modification_entries_from_assigned_modifications(
+    sequences: Iterable[str],
+    assigned_modifications: Iterable[str],
+) -> dict[str, list[str]]:
+    modified_sequence_entries = []
+    modification_entries = []
+    for sequence, modifications_entry in zip(sequences, assigned_modifications):
+        modifications = _extract_fragpipe_assigned_modifications(
+            modifications_entry, sequence
+        )
+        modified_sequence = helper.modify_peptide(sequence, modifications)
+        modification_entry = ";".join([f"{pos}:{mod}" for pos, mod in modifications])
+        modified_sequence_entries.append(modified_sequence)
+        modification_entries.append(modification_entry)
+
+    entries = {
+        "Modified sequence": modified_sequence_entries,
+        "Modifications": modification_entries,
+    }
+    return entries
+
+
+def _extract_fragpipe_assigned_modifications(
+    modifications_entry: str,
+    sequence: str,
+) -> list[tuple[int, str]]:
+    """Extracts modifications from a FragPipe "Modifications" entry.
+
+    Example for a modification entry: "N-term(42.0106),8C(57.0215)"
+
+    Returns:
+        A list of tuples, where each tuple contains the position of the modification and
+        the modification text. The position is one-indexed, meaning that the first amino
+        acid position is 1. N-term and C-term are represented as 0 and len(sequence)
+        respectively.
+    """
+    if modifications_entry == "":
+        return []
+    modifications = []
+    for mod_entry in modifications_entry.split(","):
+        position_entry, modification = mod_entry.split(")")[0].split("(")
+        if position_entry == "N-term":
+            position = 0
+        elif position_entry == "C-term":
+            position = len(sequence)
+        else:
+            position = int(position_entry[:-1])
+        modifications.append((position, modification))
+    return modifications
+
+
 def extract_maxquant_localization_probabilities(localization_entry: str) -> dict:
     """Extract localization probabilites from a MaxQuant "Probabilities" entry.
 

msreport/rinterface/__init__.py

@@ -1,4 +1,16 @@
 """Python interface to custome R scripts."""
 
-from .limma import multi_group_limma, two_group_limma
-from .rinstaller import r_package_version
+from msreport.errors import OptionalDependencyError
+
+try:
+    from .limma import multi_group_limma, two_group_limma
+    from .rinstaller import r_package_version
+except ImportError as err:
+    raise OptionalDependencyError(
+        "R integration is not available. R must be installed and configured before "
+        "installing optional R dependencies using 'pip install msreport[R]'. For "
+        "more information, see: https://github.com/hollenstein/msreport"
+    ) from err
+
+
+__all__ = ["multi_group_limma", "two_group_limma", "r_package_version"]

msreport-0.0.30.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: msreport
+Version: 0.0.30
+Summary: Post processing and analysis of quantitative proteomics data
+Author-email: "David M. Hollenstein" <hollenstein.david@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: homepage, https://github.com/hollenstein/msreport
+Project-URL: changelog, https://github.com/hollenstein/msreport/blob/main/CHANGELOG.md
+Keywords: mass spectrometry,proteomics,post processing,data analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: adjustText<1.0.0,>=0.7.0
+Requires-Dist: matplotlib>=3.5.2
+Requires-Dist: numpy>=1.21.5
+Requires-Dist: pandas>=1.4.4
+Requires-Dist: profasta>=0.0.4
+Requires-Dist: pyteomics>=4.6.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: scipy>=1.9.1
+Requires-Dist: seaborn>=0.12.0
+Requires-Dist: statsmodels>=0.13.2
+Requires-Dist: typing_extensions>=4
+Provides-Extra: r
+Requires-Dist: rpy2<3.5.13,>=3.5.3; extra == "r"
+Provides-Extra: dev
+Requires-Dist: mypy>=1.15.0; extra == "dev"
+Requires-Dist: pytest>=8.3.5; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=8.3.5; extra == "test"
+Dynamic: license-file
+
+# MsReport
+
+[![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.15309090.svg)](https://doi.org/10.5281/zenodo.15309090)
+![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fhollenstein%2Fmsreport%2Fmain%2Fpyproject.toml)
+[![Run tests](https://github.com/hollenstein/msreport/actions/workflows/run-tests.yml/badge.svg)](https://github.com/hollenstein/msreport/actions/workflows/run-tests.yml)
+
+**MsReport** is a Python library for post-processing quantitative proteomics data from
+bottom-up mass spectrometry experiments.
+
+## Table of Contents
+
+- [What is MsReport?](#what-is-msreport)
+  - [Key features of MsReport](#key-features-of-msreport)
+- [Installation](#installation)
+    - [Installation when using Anaconda](#installation-when-using-anaconda)
+    - [Additional requirements](#additional-requirements)
+    - [Optional Dependencies](#optional-dependencies)
+- [Development status](#development-status)
+- [How to cite](#how-to-cite)
+
+## What is MsReport?
+
+MsReport is a Python library designed to simplify the post-processing and analysis of quantitative proteomics data from bottom-up mass spectrometry experiments. It provides a high-level, abstraction-focused API for efficient and standardized workflows. The modular design of the library provides the flexibility to meet project specific data processing needs and customize workflows as required.
+
+The library supports importing protein and peptide-level quantification results from MaxQuant, FragPipe, and Spectronaut, as well as post-translational modification (PTM) data from MaxQuant and FragPipe. MsReport provides tools for data annotation, normalization and transformation, statistical testing, and data visualization.
+
+### Key features of MsReport
+
+#### Data Import and Standardization
+
+The `reader` module provides software-specific reader classes for importing data from MaxQuant, FragPipe, and Spectronaut that enable the import of protein, peptide and ion tables. During the import process, these classes transform tables column names and table values into a standardized format to ensure that the rest of the library can operate in a tool-agnostic manner.
+
+#### Data management
+
+The `qtable` module provides a structured approach to managing quantitative data through its central `Qtable` class. This class combines quantitative data with an experimental design table that defines the relationship between samples and experimental conditions. The quantitative data is stored in a wide format, where each sample's measurements are stored in separate columns. The `Qtable` class serves as the foundation for data analysis workflows in MsReport, providing the standardized data structure used by the `analyze`, `plot`, and `export` modules.
+
+#### Data processing and analysis
+
+The `analyze` module provides tools for post-processing of mass spectrometry data generated by software such as MaxQuant, FragPipe, or Spectronaut. It includes functions for filtering, normalization, imputation of missing values, and statistical testing. The library integrates with the R package LIMMA to enable differential expression analysis.
+
+> [!NOTE]  
+> In order to use the R integration you need to install msreport with optional dependencies, see [Optional Dependencies](#optional-dependencies) for more information.
+
+#### Data visualization
+
+The `plot` module supports the generation of visualizations for quality control and data analysis. It includes functions for creating various plots, such as intensity and ratio distributions, heatmaps, volcano plots, and PCA plots.
+
+#### Data export
+
+Finally, the `export` module enables the conversion and export into formats compatible with external tools. This includes generating input files for [Amica](https://bioapps.maxperutzlabs.ac.at/app/amica) and exporting tables for easier integration with Perseus. 
+
+## Installation
+
+If you do not already have a Python installation, we recommend installing the [Anaconda distribution](https://www.anaconda.com/download) or [Miniconda](https://docs.anaconda.com/free/miniconda/index.html) distribution from Continuum Analytics, which already contains a large number of popular Python packages for Data Science. Alternatively, you can also get Python from the [Python homepage](https://www.python.org/downloads/windows). Note that MsReport requires Python version 3.10 or higher.
+
+The following command will install MsReport and its dependencies by using a wheel file.
+
+```shell
+pip install msreport
+```
+
+To uninstall the MsReport library use:
+
+```shell
+pip uninstall msreport
+```
+
+### Installation when using Anaconda
+
+To install the MsReport library using Anaconda, you need to either activate a custom conda environment or install it into the default base environment. Open the Anaconda Navigator, activate the desired conda environment or use the base environment, and then open a command line by running the "CMD.exe" application. Finally, use the `pip install` command as before.
+
+### Optional Dependencies
+
+#### R Integration
+
+MsReport provides an interface to the R package LIMMA for differential expression analysis. To use this functionality, you need:
+
+- A local installation of **R (version 4.0 or higher)**.
+- The system environment variable R_HOME set to the R home directory.
+- To install msreport with the optional dependencies for R integration.
+
+```shell
+pip install msreport[R]
+```
+
+#### Setting the R_HOME environment variable
+
+On Windows, you may need to restart your computer after modifying the system environment variables for the changes to take effect. To find the R home directory, you can run the following command in R:
+
+```R
+normalizePath(R.home("home"))
+```
+
+For example, the R home directory might look like this on Windows: `C:\Program Files\R\R-4.2.1`
+
+## Development status
+
+MsReport is a stable and reliable library that has been used on a daily basis for over two years in the Mass Spectrometry Facility at the Max Perutz Labs and the Mass Spectrometry Facility of IMP/IMBA/GMI. While the current interface of MsReport is stable, the library is still under active development, with new features being added regularly. Please note that a major rewrite is planned, which may introduce changes to the API in the future.
+
+## How to cite
+
+If you use MsReport for your research or publications, please include the following citation and consider giving the project a star on GitHub.
+
+> Hollenstein, D. M., & Hartl, M. (2025). hollenstein/msreport: v0.0.29 (0.0.29). Zenodo. https://doi.org/10.5281/zenodo.15309090

{msreport-0.0.28.dist-info → msreport-0.0.30.dist-info}/RECORD

@@ -1,14 +1,14 @@
-msreport/__init__.py,sha256=5-d_i-t9A3MV7hC-3z_vcWzaSAJSGY5T6McCBr4UGfc,339
-msreport/analyze.py,sha256=zNs0Vc2ODTfdiX6rSr79jXLJIh-6N11WH-vZpQzKDTE,30889
-msreport/errors.py,sha256=algGlR5iD9Q0U6Q3m25IwZryl9smtlPHsfhAL35PChc,295
+msreport/__init__.py,sha256=ajNIgBNRP06cDKDl6tsTeDhWSlJQw922QAxoJFd8Mhs,339
+msreport/analyze.py,sha256=I1sfxvXy02AjFcfLRlvC-F_bg0J8ePKoSIU8yDWxLs0,31313
+msreport/errors.py,sha256=X9yFxMiIOCWQdxuqBGr8L7O3vRV2KElXdX1uHbFcZMk,421
 msreport/export.py,sha256=YvY3Nly5JC2CUM-JY1gydU1g2eqnennzToZfQQ5phO0,20156
 msreport/fasta.py,sha256=eXTmA4WGX4dT9wcTw7AdrvybLWG47p7ur48CxIjxjfg,1161
 msreport/impute.py,sha256=bf2Zy8VQNJ0Oh1sKn84Xp9iV5svi_Hp7iHxwRrFBwsI,10327
 msreport/isobar.py,sha256=m6NhLaKBiItIXuBhly_z2wEslxQGFC2f3-e1bzYXB78,6575
 msreport/normalize.py,sha256=K1x3DjL5Rep3t_eDIKIghMr0sAJiROnX6skHnOMPZ_k,20160
 msreport/peptidoform.py,sha256=26USj6WPrMgMIc7LttQ2n6Oq5jo1o7ayUQLR6gsRmZY,12015
-msreport/qtable.py,sha256=0e-TXmuiKBU6W5TL3tz06nNrjtEyT-CI9bvUq8W6qME,26768
-msreport/reader.py,sha256=ja4q8XtOHR_A6RL8ho-c6aGCVu1kzyhvil8ymiPx3PY,104612
+msreport/qtable.py,sha256=4bJaWac1ePDZB1q7ssINWPdciqx4BIc6tiYUx5xrCsY,27265
+msreport/reader.py,sha256=ozw6QJ22aC0B3kSeb_frIIjkzGLx2yIV-1ZI9w8WffI,115638
 msreport/aggregate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 msreport/aggregate/condense.py,sha256=eIh5A3RUvXrmoFUjRXagiPl0m-ucuRwYD8kDBI7voVs,5862
 msreport/aggregate/pivot.py,sha256=rn8li-FrtOZS4oWA8COk0uV2m71GCEbNu1ALNoMuHOA,5081
@@ -21,18 +21,18 @@ msreport/helper/temp.py,sha256=jNulgDATf9sKXEFWMXAhjflciOZPAqlxg_7QZS7IkW8,3736
 msreport/plot/__init__.py,sha256=SnoQORfrjgz9SmqPZ-1J1aeVC5xu-cFfZINP4aYVCmY,1488
 msreport/plot/_partial_plots.py,sha256=tqZTSXEPuruMgVakaGR2tUQl5OrHgo2cROJ0S4cqkR0,5598
 msreport/plot/comparison.py,sha256=J8zWyQrzx7rxDLxeZQkfAlcSmLY3e_7wwPG-cGuWo2M,18564
-msreport/plot/distribution.py,sha256=a2Rw6HxQwGfDwRSy8dwpT7zvEQ968wYHjcVPOdXI3l8,10150
+msreport/plot/distribution.py,sha256=QNFL5vG9p-vqhwEk5WcCSXa2B8u5QgySZlAQIPys0-0,10248
 msreport/plot/multivariate.py,sha256=0xzxggqbIGQYOfgiij93DTRWfG6GvvhqI9u1GNPHarY,13111
 msreport/plot/quality.py,sha256=dIo_dpdexEN_vp35WpUTt626E-QJ2qNbJmjUai_8uck,15861
 msreport/plot/style.py,sha256=67jWf4uA1ub9RJDu4xhuSoXAW0lbLj6SMP4QXQO76Pc,10591
 msreport/plot/style_sheets/msreport-notebook.mplstyle,sha256=SPYO_7vYT8Ha7tQ0KCTLtykiRQ13-_igAm7kyvsZj1I,1266
 msreport/plot/style_sheets/seaborn-whitegrid.mplstyle,sha256=eC8Zboy8R7ybBwbHPKvKbMIHACystN6X6I0lqm7B80U,833
-msreport/rinterface/__init__.py,sha256=g29j2cIrc71qBdF4Zys51feoXlC0dP6YcTIscPTqPdI,146
+msreport/rinterface/__init__.py,sha256=Zs6STvbDqaVZVPRM6iU0kKjq0TWz_2p2ChvNAveRdTA,616
 msreport/rinterface/limma.py,sha256=fxYRUkkJKI-JpDvivjWj8bUS0ug7RRTMnaf2UOgRsXQ,5421
 msreport/rinterface/rinstaller.py,sha256=AGs6NFMSwTLrzrIJz1E5BE5jFUz8eQBHlpM_MWVChzA,1370
 msreport/rinterface/rscripts/limma.R,sha256=gr_yjMm_YoG45irDhWOo6gkRQSTwj_7uU_p3NBRHPm8,4331
-msreport-0.0.28.dist-info/licenses/LICENSE.txt,sha256=Pd-b5cKP4n2tFDpdx27qJSIq0d1ok0oEcGTlbtL6QMU,11560
-msreport-0.0.28.dist-info/METADATA,sha256=IVyUd3ZATwccffCWbgYYmUmPe8Y4vJvwZC6oMFuBBfw,5497
-msreport-0.0.28.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-msreport-0.0.28.dist-info/top_level.txt,sha256=Drl8mCckJHFIw-Ovh5AnyjKnqvLJltDOBUr1JAcHAlI,9
-msreport-0.0.28.dist-info/RECORD,,
+msreport-0.0.30.dist-info/licenses/LICENSE.txt,sha256=Pd-b5cKP4n2tFDpdx27qJSIq0d1ok0oEcGTlbtL6QMU,11560
+msreport-0.0.30.dist-info/METADATA,sha256=FO20yj_zTnw7F6pcWrWDbLLFwo_0Bz8Qm8djt1eOcWs,8444
+msreport-0.0.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+msreport-0.0.30.dist-info/top_level.txt,sha256=Drl8mCckJHFIw-Ovh5AnyjKnqvLJltDOBUr1JAcHAlI,9
+msreport-0.0.30.dist-info/RECORD,,

{msreport-0.0.28.dist-info → msreport-0.0.30.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

msreport-0.0.28.dist-info/METADATA

@@ -1,132 +0,0 @@
-Metadata-Version: 2.4
-Name: msreport
-Version: 0.0.28
-Summary: Post processing and analysis of quantitative proteomics data
-Author-email: "David M. Hollenstein" <hollenstein.david@gmail.com>
-License: Apache-2.0
-Keywords: mass spectrometry,proteomics,post processing,data analysis
-Classifier: Development Status :: 3 - Alpha
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: adjustText<1.0.0,>=0.7.0
-Requires-Dist: matplotlib>=3.5.2
-Requires-Dist: numpy>=1.21.5
-Requires-Dist: pandas>=1.4.4
-Requires-Dist: profasta>=0.0.4
-Requires-Dist: pyteomics>=4.6.0
-Requires-Dist: pyyaml>=6.0.0
-Requires-Dist: rpy2!=3.5.13,>=3.5.3
-Requires-Dist: scikit-learn>=1.0.0
-Requires-Dist: scipy>=1.9.1
-Requires-Dist: seaborn>=0.12.0
-Requires-Dist: statsmodels>=0.13.2
-Requires-Dist: typing_extensions>=4
-Provides-Extra: dev
-Requires-Dist: mypy>=1.15.0; extra == "dev"
-Requires-Dist: pytest>=8.3.5; extra == "dev"
-Dynamic: license-file
-
-[![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)
-
-
-# MsReport
-
-
-## Introduction
-
-MsReport is a python library that allows simple and standardized post processing of
-quantitative proteomics data from bottom up, mass spectrometry experiments. Currently
-working with label free protein quantification reports from MaxQuant and FragPipe is
-fully supported. Other data analysis pipelines can be added by writing a software
-specific reader function.
-
-MsReport is primarily developed as a tool for the Mass Spectrometry Facility at the Max
-Perutz Labs (University of Vienna), to allow the generation of Quantitative Protein and
-PTM reports, and to facilitate project specific data analysis tasks.
-
-
-## Release
-
-Development is currently in early alpha and the interface is not yet stable.
-
-
-## Scope
-
-The `reader` module contains software specific reader classes that provide access to the
-outputs of the respective software. Reader instances allow importing protein and ion
-tables, and provide the ability to standardize column names and data formats during the
-import. To do so, reader classes must know the file structure and naming conventions of
-the respective software.
-
-The `qtable` class allows storing and accessing quantitative data from a particular
-level of abstraction, such as proteins or ions, and an experimental design table that
-describes to which experiment a sample belongs to. The quantitative data are in the wide
-format, i.e. the quantification data of each sample is stored in a separate column. The
-`Qtable` allows convenient handling and access to quantitative data through information
-from the experimental design, and represents the data structure used by the `analyze`,
-`plot`, and `export` modules.
-
-The `analyze` module provides a high-level interface for post-processing of quantitative
-data, such as filtering valid values, normalization between samples, imputation of
-missing values, and statistical testing with the R package LIMMA.
-
-The `plot` module allows generation of quality control and data analysis plots.
-
-Using methods from the `export` module allows conversion and export of quantitative data
-into the Amica input format, and generating contaminant tables for the inspection of
-potential contaminants.
-
-Additional scripts
-
-- The `excel_report` module enables the creation of a formatted excel protein report
-  by using the XlsxReport library.
-- The `benchmark` module contains functions to generate benchmark plots from multiple
-  `Qtable` instances, and can be used for method or software comparison.
-
-
-## Install
-
-If you do not already have a Python installation, we recommend installing the
-[Anaconda distribution](https://www.continuum.io/downloads) of Continuum Analytics,
-which already contains a large number of popular Python packages for Data Science.
-Alternatively, you can also get Python from the
-[Python homepage](https://www.python.org/downloads/windows). MsReport requires Python
-version 3.9 or higher.
-
-You can use pip to install MsReport from the distribution file with the following
-command:
-
-```
-pip install msreport-X.Y.Z-py3-none-any.whl
-```
-
-To uninstall the MsReport library type:
-
-```
-pip uninstall msreport
-```
-
-
-### Installation when using Anaconda
-If you are using Anaconda, you will need to install the MsReport package into a conda
-environment. Open the Anaconda navigator, activate the conda environment you want to
-use, run the "CMD.exe" application to open a terminal, and then use the pip install
-command as described above.
-
-
-### Additional requirements
-
-MsReport provides an interface to the R package LIMMA for differential expression
-analysis, which requires a local installation of R (R version 4.0 or higher) and the
-system environment variable "R_HOME" to be set to the R home directory. Note that it
-might be necessary to restart the computer after adding the "R_HOME" variable. The R
-home directory can also be found from within R by using the command below, and might
-look similar to "C:\Program Files\R\R-4.2.1" on windows.
-
-```
-normalizePath(R.home("home"))
-```