ms2rescore 3.1.0.dev6__tar.gz → 3.1.0.dev8__tar.gz

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ms2rescore
-Version: 3.1.0.dev6
+Version: 3.1.0.dev8
 Summary: MS²Rescore: Sensitive PSM rescoring with predicted MS² peak intensities and retention times.
 Keywords: MS2Rescore,MS2PIP,DeepLC,Percolator,proteomics,mass spectrometry,peptide identification,rescoring,machine learning
 Author: Ana Sílvia C. Silva, Robbin Bouwmeester, Louise Buur
@@ -24,13 +24,12 @@ Requires-Dist: lxml>=4.5
 Requires-Dist: mokapot>=0.9
 Requires-Dist: ms2pip>=4.0.0-dev10
 Requires-Dist: ms2rescore_rs
-Requires-Dist: numpy==1.24.3; python_version == '3.11'
-Requires-Dist: numpy>=1.16.0; python_version != '3.11'
+Requires-Dist: numpy>=1.16.0
+Requires-Dist: scikit-learn==1.5.1; python_version == '3.11'
 Requires-Dist: pandas>=1.0
 Requires-Dist: plotly>=5
-Requires-Dist: psm_utils>=0.8
-Requires-Dist: pydantic>=1.8.2,<2
-Requires-Dist: pyteomics>=4.1.0, <4.7
+Requires-Dist: psm_utils>=0.9
+Requires-Dist: pyteomics>=4.7.2
 Requires-Dist: rich>=12
 Requires-Dist: tomli>=2; python_version < '3.11'
 Requires-Dist: ruff ; extra == "dev"

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/ms2rescore/__init__.py

@@ -1,6 +1,6 @@
 """MS²Rescore: Sensitive PSM rescoring with predicted MS² peak intensities and RTs."""
 
-__version__ = "3.1.0-dev6"
+__version__ = "3.1.0-dev8"
 
 from warnings import filterwarnings
 

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/ms2rescore/core.py

@@ -5,6 +5,7 @@ from typing import Dict, Optional
 
 import numpy as np
 import psm_utils.io
+from mokapot.dataset import LinearPsmDataset
 from psm_utils import PSMList
 
 from ms2rescore import exceptions
@@ -13,6 +14,7 @@ from ms2rescore.parse_psms import parse_psms
 from ms2rescore.parse_spectra import get_missing_values
 from ms2rescore.report import generate
 from ms2rescore.rescoring_engines import mokapot, percolator
+from ms2rescore.rescoring_engines.mokapot import add_peptide_confidence, add_psm_confidence
 
 logger = logging.getLogger(__name__)
 
@@ -45,7 +47,7 @@ def rescore(configuration: Dict, psm_list: Optional[PSMList] = None) -> None:
     psm_list = parse_psms(config, psm_list)
 
     # Log #PSMs identified before rescoring
-    id_psms_before = _log_id_psms_before(psm_list)
+    id_psms_before = _log_id_psms_before(psm_list, max_rank=config["max_psm_rank_output"])
 
     # Define feature names; get existing feature names from PSM file
     feature_names = dict()
@@ -60,7 +62,7 @@ def rescore(configuration: Dict, psm_list: Optional[PSMList] = None) -> None:
     )
 
     # Add missing precursor info from spectrum file if needed
-    _fill_missing_precursor_info(psm_list, config)
+    psm_list = _fill_missing_precursor_info(psm_list, config)
 
     # Add rescoring features
     for fgen_name, fgen_config in config["feature_generators"].items():
@@ -104,8 +106,8 @@ def rescore(configuration: Dict, psm_list: Optional[PSMList] = None) -> None:
         logging.debug(f"Creating USIs for {len(psm_list)} PSMs")
         psm_list["spectrum_id"] = [psm.get_usi(as_url=False) for psm in psm_list]
 
-    # If no rescoring engine is specified, write PSMs and features to PIN file
-    if not config["rescoring_engine"]:
+    # If no rescoring engine is specified or DEBUG, write PSMs and features to PIN file
+    if not config["rescoring_engine"] or config["log_level"] == "debug":
         logger.info(f"Writing added features to PIN file: {output_file_root}.psms.pin")
         psm_utils.io.write_file(
             psm_list,
@@ -113,35 +115,49 @@ def rescore(configuration: Dict, psm_list: Optional[PSMList] = None) -> None:
             filetype="percolator",
             feature_names=all_feature_names,
         )
+
+    if not config["rescoring_engine"]:
+        logger.info("No rescoring engine specified. Skipping rescoring.")
         return None
 
     # Rescore PSMs
-    if "percolator" in config["rescoring_engine"]:
-        percolator.rescore(
-            psm_list,
-            output_file_root=output_file_root,
-            log_level=config["log_level"],
-            processes=config["processes"],
-            percolator_kwargs=config["rescoring_engine"]["percolator"],
-        )
-    elif "mokapot" in config["rescoring_engine"]:
-        if "fasta_file" not in config["rescoring_engine"]["mokapot"]:
-            config["rescoring_engine"]["mokapot"]["fasta_file"] = config["fasta_file"]
-        if "protein_kwargs" in config["rescoring_engine"]["mokapot"]:
-            protein_kwargs = config["rescoring_engine"]["mokapot"].pop("protein_kwargs")
-        else:
-            protein_kwargs = dict()
-
-        mokapot.rescore(
-            psm_list,
-            output_file_root=output_file_root,
-            protein_kwargs=protein_kwargs,
-            **config["rescoring_engine"]["mokapot"],
-        )
-    else:
-        logger.info("No known rescoring engine specified. Skipping rescoring.")
+    try:
+        if "percolator" in config["rescoring_engine"]:
+            percolator.rescore(
+                psm_list,
+                output_file_root=output_file_root,
+                log_level=config["log_level"],
+                processes=config["processes"],
+                percolator_kwargs=config["rescoring_engine"]["percolator"],
+            )
+        elif "mokapot" in config["rescoring_engine"]:
+            if "fasta_file" not in config["rescoring_engine"]["mokapot"]:
+                config["rescoring_engine"]["mokapot"]["fasta_file"] = config["fasta_file"]
+            if "protein_kwargs" in config["rescoring_engine"]["mokapot"]:
+                protein_kwargs = config["rescoring_engine"]["mokapot"].pop("protein_kwargs")
+            else:
+                protein_kwargs = dict()
+
+            mokapot.rescore(
+                psm_list,
+                output_file_root=output_file_root,
+                protein_kwargs=protein_kwargs,
+                **config["rescoring_engine"]["mokapot"],
+            )
+    except exceptions.RescoringError as e:
+        # Write output
+        logger.info(f"Writing intermediary output to {output_file_root}.psms.tsv...")
+        psm_utils.io.write_file(psm_list, output_file_root + ".psms.tsv", filetype="tsv")
+
+        # Reraise exception
+        raise e
 
-    _log_id_psms_after(psm_list, id_psms_before)
+    # Post-rescoring processing
+    if all(psm_list["pep"] == 1.0):
+        psm_list = _fix_constant_pep(psm_list)
+    psm_list = _filter_by_rank(psm_list, config["max_psm_rank_output"], False)
+    psm_list = _calculate_confidence(psm_list)
+    _ = _log_id_psms_after(psm_list, id_psms_before, max_rank=config["max_psm_rank_output"])
 
     # Write output
     logger.info(f"Writing output to {output_file_root}.psms.tsv...")
@@ -157,7 +173,7 @@ def rescore(configuration: Dict, psm_list: Optional[PSMList] = None) -> None:
             logger.exception(e)
 
 
-def _fill_missing_precursor_info(psm_list, config):
+def _fill_missing_precursor_info(psm_list: PSMList, config: Dict) -> PSMList:
     """Fill missing precursor info from spectrum file if needed."""
     # Check if required
     # TODO: avoid hard coding feature generators in some way
@@ -199,6 +215,16 @@ def _fill_missing_precursor_info(psm_list, config):
                     [v is not None and not np.isnan(v) for v in psm_list[value_name]]
                 ]
 
+    return psm_list
+
+
+def _filter_by_rank(psm_list: PSMList, max_rank: int, lower_score_better: bool) -> PSMList:
+    """Filter PSMs by rank."""
+    psm_list.set_ranks(lower_score_better=lower_score_better)
+    rank_filter = psm_list["rank"] <= max_rank
+    logger.info(f"Removed {sum(~rank_filter)} PSMs with rank >= {max_rank}.")
+    return psm_list[rank_filter]
+
 
 def _write_feature_names(feature_names, output_file_root):
     """Write feature names to file."""
@@ -209,25 +235,80 @@ def _write_feature_names(feature_names, output_file_root):
                 f.write(f"{fgen}\t{feature}\n")
 
 
-def _log_id_psms_before(psm_list):
+def _log_id_psms_before(psm_list: PSMList, fdr: float = 0.01, max_rank: int = 1) -> int:
     """Log #PSMs identified before rescoring."""
     id_psms_before = (
-        (psm_list["qvalue"] <= 0.01) & (psm_list["is_decoy"] == False)  # noqa: E712
+        (psm_list["qvalue"] <= 0.01) & (psm_list["rank"] <= max_rank) & (~psm_list["is_decoy"])
     ).sum()
-    logger.info("Found %i identified PSMs at 1%% FDR before rescoring.", id_psms_before)
+    logger.info(
+        f"Found {id_psms_before} identified PSMs with rank <= {max_rank} at {fdr} FDR before "
+        "rescoring."
+    )
     return id_psms_before
 
 
-def _log_id_psms_after(psm_list, id_psms_before):
+def _log_id_psms_after(
+    psm_list: PSMList, id_psms_before: int, fdr: float = 0.01, max_rank: int = 1
+) -> int:
     """Log #PSMs identified after rescoring."""
     id_psms_after = (
-        (psm_list["qvalue"] <= 0.01) & (psm_list["is_decoy"] == False)  # noqa: E712
+        (psm_list["qvalue"] <= 0.01) & (psm_list["rank"] <= max_rank) & (~psm_list["is_decoy"])
     ).sum()
     diff = id_psms_after - id_psms_before
     diff_perc = diff / id_psms_before if id_psms_before > 0 else None
 
     diff_numbers = f"{diff} ({diff_perc:.2%})" if diff_perc is not None else str(diff)
     diff_word = "more" if diff > 0 else "less"
-    logger.info(f"Identified {diff_numbers} {diff_word} PSMs at 1% FDR after rescoring.")
+    logger.info(
+        f"Identified {diff_numbers} {diff_word} PSMs with rank <= {max_rank} at {fdr} FDR after "
+        "rescoring."
+    )
 
     return id_psms_after
+
+
+def _fix_constant_pep(psm_list: PSMList) -> PSMList:
+    """Workaround for broken PEP calculation if best PSM is decoy."""
+    logger.warning(
+        "Attempting to fix constant PEP values by removing decoy PSMs that score higher than the "
+        "best target PSM."
+    )
+    max_target_score = psm_list["score"][~psm_list["is_decoy"]].max()
+    higher_scoring_decoys = psm_list["is_decoy"] & (psm_list["score"] > max_target_score)
+
+    if not higher_scoring_decoys.any():
+        logger.warning("No decoys scoring higher than the best target found. Skipping fix.")
+    else:
+        psm_list = psm_list[~higher_scoring_decoys]
+        logger.warning(f"Removed {higher_scoring_decoys.sum()} decoy PSMs.")
+
+    return psm_list
+
+
+def _calculate_confidence(psm_list: PSMList) -> PSMList:
+    """
+    Calculate scores, q-values, and PEPs for PSMs and peptides and add them to PSMList.
+    """
+    # Minimal conversion to LinearPsmDataset
+    psm_df = psm_list.to_dataframe()
+    psm_df = psm_df.reset_index(drop=True).reset_index()
+    psm_df["peptide"] = (
+        psm_df["peptidoform"].astype(str).str.replace(r"(/\d+$)", "", n=1, regex=True)
+    )
+    psm_df["is_target"] = ~psm_df["is_decoy"]
+    lin_psm_data = LinearPsmDataset(
+        psms=psm_df[["index", "peptide", "score", "is_target"]],
+        target_column="is_target",
+        spectrum_columns="index",  # Use artificial index to allow multi-rank rescoring
+        peptide_column="peptide",
+        feature_columns=["score"],
+    )
+
+    # Recalculate confidence
+    new_confidence = lin_psm_data.assign_confidence()
+
+    # Add new confidence estimations to PSMList
+    add_psm_confidence(psm_list, new_confidence)
+    add_peptide_confidence(psm_list, new_confidence)
+
+    return psm_list

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/ms2rescore/exceptions.py

@@ -35,3 +35,9 @@ class ReportGenerationError(MS2RescoreError):
     """Error while generating report."""
 
     pass
+
+
+class RescoringError(MS2RescoreError):
+    """Error while rescoring PSMs."""
+
+    pass

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/ms2rescore/package_data/config_default.json

@@ -14,6 +14,7 @@
         },
         "rescoring_engine": {
             "mokapot": {
+                "train_fdr": 0.01,
                 "write_weights": true,
                 "write_txt": true,
                 "write_flashlfq": true
@@ -32,6 +33,8 @@
         "psm_id_rt_pattern": null,
         "psm_id_im_pattern": null,
         "lower_score_is_better": false,
+        "max_psm_rank_input": 10,
+        "max_psm_rank_output": 1,
         "modification_mapping": {},
         "fixed_modifications": {},
         "processes": -1,

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/ms2rescore/package_data/config_schema.json

@@ -68,7 +68,11 @@
                 },
                 "psm_file": {
                     "description": "Path to file with peptide-spectrum matches.",
-                    "oneOf": [{ "type": "string" }, { "type": "null" }, { "type": "array", "items": { "type": "string" } }]
+                    "oneOf": [
+                        { "type": "string" },
+                        { "type": "null" },
+                        { "type": "array", "items": { "type": "string" } }
+                    ]
                 },
                 "psm_file_type": {
                     "description": "PSM file type. By default inferred from file extension.",
@@ -127,6 +131,18 @@
                     "type": "boolean",
                     "default": false
                 },
+                "max_psm_rank_input": {
+                    "description": "Maximum rank of PSMs to use as input for rescoring",
+                    "type": "number",
+                    "default": 10,
+                    "minimum": 1
+                },
+                "max_psm_rank_output": {
+                    "description": "Maximum rank of PSMs to return after rescoring, before final FDR calculation",
+                    "type": "number",
+                    "default": 1,
+                    "minimum": 1
+                },
                 "modification_mapping": {
                     "description": "Mapping of modification labels to each replacement label.",
                     "type": "object",
@@ -159,7 +175,7 @@
                     "default": false
                 },
                 "profile": {
-                    "description": "Write an txt report using cProfile for profiling",
+                    "description": "Write a txt report using cProfile for profiling",
                     "type": "boolean",
                     "default": false
                 }
@@ -263,6 +279,13 @@
             "type": "object",
             "additionalProperties": true,
             "properties": {
+                "train_fdr": {
+                    "description": "FDR threshold for training Mokapot",
+                    "type": "number",
+                    "minimum": 0,
+                    "maximum": 1,
+                    "default": 0.01
+                },
                 "write_weights": {
                     "description": "Write Mokapot weights to a text file",
                     "type": "boolean",

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/ms2rescore/parse_psms.py

@@ -1,7 +1,8 @@
 import logging
 import re
-from typing import Dict, Union
+from typing import Dict, Optional, Union
 
+import numpy as np
 import psm_utils.io
 from psm_utils import PSMList
 
@@ -23,13 +24,30 @@ def parse_psms(config: Dict, psm_list: Union[PSMList, None]) -> PSMList:
         PSMList object containing PSMs. If None, PSMs will be read from ``psm_file``.
 
     """
-    # Read PSMs, find decoys, calculate q-values
-    psm_list = _read_psms(config, psm_list)
-    _find_decoys(config, psm_list)
-    _calculate_qvalues(config, psm_list)
+    # Read PSMs
+    try:
+        psm_list = _read_psms(config, psm_list)
+    except psm_utils.io.PSMUtilsIOException:
+        raise MS2RescoreConfigurationError(
+            "Error occurred while reading PSMs. Please check the 'psm_file' and "
+            "'psm_file_type' settings. See "
+            "https://ms2rescore.readthedocs.io/en/latest/userguide/input-files/"
+            " for more information."
+        )
+
+    # Filter by PSM rank
+    psm_list.set_ranks(config["lower_score_is_better"])
+    rank_filter = psm_list["rank"] <= config["max_psm_rank_input"]
+    psm_list = psm_list[rank_filter]
+    logger.info(f"Removed {sum(~rank_filter)} PSMs with rank >= {config['max_psm_rank_input']}.")
+
+    # Remove invalid AAs, find decoys, calculate q-values
+    psm_list = _remove_invalid_aa(psm_list)
+    _find_decoys(psm_list, config["id_decoy_pattern"])
+    _calculate_qvalues(psm_list, config["lower_score_is_better"])
     if config["psm_id_rt_pattern"] or config["psm_id_im_pattern"]:
         logger.debug("Parsing retention time and/or ion mobility from PSM identifier...")
-        _parse_values_spectrum_id(config, psm_list)
+        _parse_values_from_spectrum_id(config, psm_list)
 
     # Store scoring values for comparison later
     for psm in psm_list:
@@ -70,10 +88,6 @@ def parse_psms(config: Dict, psm_list: Union[PSMList, None]) -> PSMList:
         new_ids = [_match_psm_ids(old_id, pattern) for old_id in psm_list["spectrum_id"]]
         psm_list["spectrum_id"] = new_ids
 
-    # TODO: Temporary fix until implemented in psm_utils
-    # Ensure that spectrum IDs are strings (Pydantic 2.0 does not coerce int to str)
-    psm_list["spectrum_id"] = [str(spec_id) for spec_id in psm_list["spectrum_id"]]
-
     return psm_list
 
 
@@ -81,49 +95,30 @@ def _read_psms(config, psm_list):
     if isinstance(psm_list, PSMList):
         return psm_list
     else:
-        logger.info("Reading PSMs from file...")
-        current_file = 1
         total_files = len(config["psm_file"])
-        valid_psms_list = []
-        total_psms = 0
-        valid_psms = 0
-        for psm_file in config["psm_file"]:
+        psm_list = []
+        for current_file, psm_file in enumerate(config["psm_file"]):
             logger.info(
-                f"Reading PSMs from PSM file ({current_file}/{total_files}): '{psm_file}'..."
+                f"Reading PSMs from PSM file ({current_file+1}/{total_files}): '{psm_file}'..."
             )
-            try:
-                id_file_psm_list = psm_utils.io.read_file(
+            psm_list.extend(
+                psm_utils.io.read_file(
                     psm_file,
                     filetype=config["psm_file_type"],
                     show_progressbar=True,
                     **config["psm_reader_kwargs"],
                 )
-            except psm_utils.io.PSMUtilsIOException:
-                raise MS2RescoreConfigurationError(
-                    "Error occurred while reading PSMs. Please check the 'psm_file' and "
-                    "'psm_file_type' settings. See "
-                    "https://ms2rescore.readthedocs.io/en/latest/userguide/input-files/"
-                    " for more information."
-                )
-
-            total_psms += len(id_file_psm_list.psm_list)
-            for psm in id_file_psm_list.psm_list:
-                if not _has_invalid_aminoacids(psm):
-                    valid_psms_list.append(psm)
-                    valid_psms += 1
-            current_file += 1
-        if total_psms - valid_psms > 0:
-            logger.warning(
-                f"{total_psms - valid_psms} PSMs with invalid amino acids were removed."
             )
-        return PSMList(psm_list=valid_psms_list)
+            logger.debug(f"Read {len(psm_list)} PSMs from '{psm_file}'.")
+
+        return PSMList(psm_list=psm_list)
 
 
-def _find_decoys(config, psm_list):
+def _find_decoys(psm_list: PSMList, id_decoy_pattern: Optional[str] = None):
     """Find decoys in PSMs, log amount, and raise error if none found."""
     logger.debug("Finding decoys...")
-    if config["id_decoy_pattern"]:
-        psm_list.find_decoys(config["id_decoy_pattern"])
+    if id_decoy_pattern:
+        psm_list.find_decoys(id_decoy_pattern)
 
     n_psms = len(psm_list)
     percent_decoys = sum(psm_list["is_decoy"]) / n_psms * 100
@@ -138,12 +133,12 @@ def _find_decoys(config, psm_list):
         )
 
 
-def _calculate_qvalues(config, psm_list):
+def _calculate_qvalues(psm_list: PSMList, lower_score_is_better: bool):
     """Calculate q-values for PSMs if not present."""
     # Calculate q-values if not present
     if None in psm_list["qvalue"]:
         logger.debug("Recalculating q-values...")
-        psm_list.calculate_qvalues(reverse=not config["lower_score_is_better"])
+        psm_list.calculate_qvalues(reverse=not lower_score_is_better)
 
 
 def _match_psm_ids(old_id, regex_pattern):
@@ -158,47 +153,45 @@ def _match_psm_ids(old_id, regex_pattern):
         )
 
 
-def _parse_values_spectrum_id(config, psm_list):
+def _parse_values_from_spectrum_id(
+    psm_list: PSMList,
+    psm_id_rt_pattern: Optional[str] = None,
+    psm_id_im_pattern: Optional[str] = None,
+):
     """Parse retention time and or ion mobility values from the spectrum_id."""
-
-    if config["psm_id_rt_pattern"]:
-        logger.debug(
-            "Parsing retention time from spectrum_id with regex pattern "
-            f"{config['psm_id_rt_pattern']}"
-        )
-        try:
-            rt_pattern = re.compile(config["psm_id_rt_pattern"])
-            psm_list["retention_time"] = [
-                float(rt_pattern.search(psm.spectrum_id).group(1)) for psm in psm_list
-            ]
-        except AttributeError:
-            raise MS2RescoreConfigurationError(
-                f"Could not parse retention time from spectrum_id with the "
-                f"{config['psm_id_rt_pattern']} regex pattern. "
-                "Please make sure the retention time key is present in the spectrum_id "
-                "and the value is in a capturing group or disable the relevant feature generator."
-            )
-
-    if config["psm_id_im_pattern"]:
-        logger.debug(
-            "Parsing ion mobility from spectrum_id with regex pattern "
-            f"{config['psm_id_im_pattern']}"
-        )
-        try:
-            im_pattern = re.compile(config["psm_id_im_pattern"])
-            psm_list["ion_mobility"] = [
-                float(im_pattern.search(psm.spectrum_id).group(1)) for psm in psm_list
-            ]
-        except AttributeError:
-            raise MS2RescoreConfigurationError(
-                f"Could not parse ion mobility from spectrum_id with the "
-                f"{config['psm_id_im_pattern']} regex pattern. "
-                "Please make sure the ion mobility key is present in the spectrum_id "
-                "and the value is in a capturing group or disable the relevant feature generator."
+    for pattern, label, key in zip(
+        [psm_id_rt_pattern, psm_id_im_pattern],
+        ["retention time", "ion mobility"],
+        ["retention_time", "ion_mobility"],
+    ):
+        if pattern:
+            logger.debug(
+                f"Parsing {label} from spectrum_id with regex pattern " f"{psm_id_rt_pattern}"
             )
+            try:
+                pattern = re.compile(pattern)
+                psm_list[key] = [
+                    float(pattern.search(psm.spectrum_id).group(1)) for psm in psm_list
+                ]
+            except AttributeError:
+                raise MS2RescoreConfigurationError(
+                    f"Could not parse {label} from spectrum_id with the "
+                    f"{pattern} regex pattern. "
+                    f"Example spectrum_id: '{psm_list[0].spectrum_id}'\n. "
+                    f"Please make sure the {label} key is present in the spectrum_id "
+                    "and the value is in a capturing group or disable the relevant feature generator."
+                )
 
 
-def _has_invalid_aminoacids(psm):
-    """Check if a PSM contains invalid amino acids."""
+def _remove_invalid_aa(psm_list: PSMList) -> PSMList:
+    """Remove PSMs with invalid amino acids."""
+    invalid_psms = np.array(
+        [any(aa in "BJOUXZ" for aa in psm.peptidoform.sequence) for psm in psm_list]
+    )
 
-    return any(aa not in "ACDEFGHIKLMNPQRSTVWY" for aa in psm.peptidoform.sequence)
+    if any(invalid_psms):
+        logger.warning(f"Removed {sum(invalid_psms)} PSMs with invalid amino acids.")
+        return psm_list[~invalid_psms]
+    else:
+        logger.debug("No PSMs with invalid amino acids found.")
+        return psm_list

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/ms2rescore/report/charts.py

@@ -198,6 +198,7 @@ def score_scatter_plot(
     after: mokapot.LinearConfidence,
     level: str = "psms",
     indexer: str = "index",
+    fdr_threshold: float = 0.01,
 ) -> go.Figure:
     """
     Plot PSM scores before and after rescoring.
@@ -241,16 +242,22 @@ def score_scatter_plot(
     ce_psms = pd.concat([ce_psms_targets, ce_psms_decoys], axis=0)
 
     # Get score thresholds
-    score_threshold_before = (
-        ce_psms[ce_psms["mokapot q-value before"] <= 0.01]
-        .sort_values("mokapot q-value before", ascending=False)["mokapot score before"]
-        .iloc[0]
-    )
-    score_threshold_after = (
-        ce_psms[ce_psms["mokapot q-value after"] <= 0.01]
-        .sort_values("mokapot q-value after", ascending=False)["mokapot score after"]
-        .iloc[0]
-    )
+    try:
+        score_threshold_before = (
+            ce_psms[ce_psms["mokapot q-value before"] <= fdr_threshold]
+            .sort_values("mokapot q-value before", ascending=False)["mokapot score before"]
+            .iloc[0]
+        )
+    except IndexError:  # No PSMs below threshold
+        score_threshold_before = None
+    try:
+        score_threshold_after = (
+            ce_psms[ce_psms["mokapot q-value after"] <= fdr_threshold]
+            .sort_values("mokapot q-value after", ascending=False)["mokapot score after"]
+            .iloc[0]
+        )
+    except IndexError:  # No PSMs below threshold
+        score_threshold_after = None
 
     # Plot
     fig = px.scatter(
@@ -267,10 +274,12 @@ def score_scatter_plot(
         },
     )
     # draw FDR thresholds
-    fig.add_vline(x=score_threshold_before, line_dash="dash", row=1, col=1)
-    fig.add_hline(y=score_threshold_after, line_dash="dash", row=1, col=1)
-    fig.add_vline(x=score_threshold_before, line_dash="dash", row=2, col=1)
-    fig.add_hline(y=score_threshold_after, line_dash="dash", row=1, col=2)
+    if score_threshold_before:
+        fig.add_vline(x=score_threshold_before, line_dash="dash", row=1, col=1)
+        fig.add_vline(x=score_threshold_before, line_dash="dash", row=2, col=1)
+    if score_threshold_after:
+        fig.add_hline(y=score_threshold_after, line_dash="dash", row=1, col=1)
+        fig.add_hline(y=score_threshold_after, line_dash="dash", row=1, col=2)
 
     return fig
 

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/ms2rescore/rescoring_engines/mokapot.py

@@ -29,8 +29,11 @@ import pandas as pd
 import psm_utils
 from mokapot.brew import brew
 from mokapot.dataset import LinearPsmDataset
+from mokapot.model import PercolatorModel
 from pyteomics.mass import nist_mass
 
+from ms2rescore.exceptions import RescoringError
+
 logger = logging.getLogger(__name__)
 logging.getLogger("numba").setLevel(logging.WARNING)
 
@@ -39,6 +42,7 @@ def rescore(
     psm_list: psm_utils.PSMList,
     output_file_root: str = "ms2rescore",
     fasta_file: Optional[str] = None,
+    train_fdr: float = 0.01,
     write_weights: bool = False,
     write_txt: bool = False,
     write_flashlfq: bool = False,
@@ -65,6 +69,8 @@ def rescore(
     fasta_file
         Path to FASTA file with protein sequences to use for protein inference. Defaults to
         ``None``.
+    train_fdr
+        FDR to use for training the Mokapot model. Defaults to ``0.01``.
     write_weights
         Write model weights to a text file. Defaults to ``False``.
     write_txt
@@ -91,46 +97,15 @@ def rescore(
 
     # Rescore
     logger.debug(f"Mokapot brew options: `{kwargs}`")
-    confidence_results, models = brew(lin_psm_data, rng=8, **kwargs)
-
-    # Reshape confidence estimates to match PSMList
-    keys = ["mokapot score", "mokapot q-value", "mokapot PEP"]
-    mokapot_values_targets = (
-        confidence_results.confidence_estimates["psms"].set_index("index").sort_index()[keys]
-    )
-    mokapot_values_decoys = (
-        confidence_results.decoy_confidence_estimates["psms"].set_index("index").sort_index()[keys]
-    )
-    q = np.full((len(psm_list), 3), np.nan)
-    q[mokapot_values_targets.index] = mokapot_values_targets.values
-    q[mokapot_values_decoys.index] = mokapot_values_decoys.values
-
-    # Add Mokapot results to PSMList
-    psm_list["score"] = q[:, 0]
-    psm_list["qvalue"] = q[:, 1]
-    psm_list["pep"] = q[:, 2]
-
-    # Repeat for peptide-level scores
-    peptides_targets = confidence_results.confidence_estimates["peptides"].set_index(["peptide"])[
-        keys
-    ]
-    peptides_decoys = confidence_results.decoy_confidence_estimates["peptides"].set_index(
-        ["peptide"]
-    )[keys]
-    peptide_info = pd.concat([peptides_targets, peptides_decoys], axis=0).to_dict(orient="index")
-
-    # Add peptide-level scores to PSM metadata
-    # run_key = "na" if not all(psm.run for psm in psm_list) else None
-    no_charge_pattern = re.compile(r"(/\d+$)")
-    for psm in psm_list:
-        peptide_scores = peptide_info[(no_charge_pattern.sub("", str(psm.peptidoform), 1))]
-        psm.metadata.update(
-            {
-                "peptide_score": peptide_scores["mokapot score"],
-                "peptide_qvalue": peptide_scores["mokapot q-value"],
-                "peptide_pep": peptide_scores["mokapot PEP"],
-            }
+    try:
+        confidence_results, models = brew(
+            lin_psm_data, model=PercolatorModel(train_fdr=train_fdr), rng=8, **kwargs
         )
+    except RuntimeError as e:
+        raise RescoringError("Mokapot could not be run. Please check the input data.") from e
+
+    add_psm_confidence(psm_list, confidence_results)
+    add_peptide_confidence(psm_list, confidence_results)
 
     # Write results
     if write_weights:
@@ -245,6 +220,58 @@ def save_model_weights(
     )
 
 
+def add_psm_confidence(
+    psm_list: psm_utils.PSMList, confidence_results: mokapot.confidence.Confidence
+) -> None:
+    """Add PSM-level confidence estimates to PSM list, updating score, qvalue, pep, and rank."""
+    # Reshape confidence estimates to match PSMList
+    keys = ["mokapot score", "mokapot q-value", "mokapot PEP"]
+    mokapot_values_targets = (
+        confidence_results.confidence_estimates["psms"].set_index("index").sort_index()[keys]
+    )
+    mokapot_values_decoys = (
+        confidence_results.decoy_confidence_estimates["psms"].set_index("index").sort_index()[keys]
+    )
+    q = np.full((len(psm_list), 3), np.nan)
+    q[mokapot_values_targets.index] = mokapot_values_targets.values
+    q[mokapot_values_decoys.index] = mokapot_values_decoys.values
+
+    # Add Mokapot results to PSMList
+    psm_list["score"] = q[:, 0]
+    psm_list["qvalue"] = q[:, 1]
+    psm_list["pep"] = q[:, 2]
+
+    # Reset ranks to match new scores
+    psm_list.set_ranks(lower_score_better=False)
+
+
+def add_peptide_confidence(
+    psm_list: psm_utils.PSMList, confidence_results: mokapot.confidence.Confidence
+) -> None:
+    """Add Mokapot peptide-level confidence estimates to PSM list."""
+    keys = ["mokapot score", "mokapot q-value", "mokapot PEP"]
+    peptide_info = pd.concat(
+        [
+            confidence_results.confidence_estimates["peptides"].set_index("peptide")[keys],
+            confidence_results.decoy_confidence_estimates["peptides"].set_index("peptide")[keys],
+        ],
+        axis=0,
+    ).to_dict(orient="index")
+
+    # Add peptide-level scores to PSM metadata
+    # run_key = "na" if not all(psm.run for psm in psm_list) else None
+    no_charge_pattern = re.compile(r"(/\d+$)")
+    for psm in psm_list:
+        peptide_scores = peptide_info[(no_charge_pattern.sub("", str(psm.peptidoform), 1))]
+        psm.metadata.update(
+            {
+                "peptide_score": peptide_scores["mokapot score"],
+                "peptide_qvalue": peptide_scores["mokapot q-value"],
+                "peptide_pep": peptide_scores["mokapot PEP"],
+            }
+        )
+
+
 def _mz_to_mass(mz: float, charge: int) -> float:
     """Convert m/z to mass."""
     return mz * charge - charge * nist_mass["H"][1][0]

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/ms2rescore/rescoring_engines/percolator.py

@@ -175,6 +175,8 @@ def _update_psm_scores(
         original_psm["qvalue"] = new_psm["qvalue"]
         original_psm["pep"] = new_psm["pep"]
 
+    psm_list.set_ranks(lower_score_better=False)
+
 
 def _write_pin_file(psm_list: psm_utils.PSMList, filepath: str):
     """Write PIN file for rescoring."""

{ms2rescore-3.1.0.dev6 → ms2rescore-3.1.0.dev8}/pyproject.toml

@@ -43,13 +43,14 @@ dependencies = [
     "mokapot>=0.9",
     "ms2pip>=4.0.0-dev10",
     "ms2rescore_rs",
-    "numpy==1.24.3; python_version == '3.11'", # Incompatibility with sklearn, pygam, and TF...
-    "numpy>=1.16.0; python_version != '3.11'",
+    # "numpy==1.24.3; python_version == '3.11'", # Incompatibility with sklearn, pygam, and TF...
+    # "numpy>=1.16.0; python_version != '3.11'",
+    "numpy>=1.16.0",
+    "scikit-learn==1.5.1; python_version == '3.11'",
     "pandas>=1.0",
     "plotly>=5",
-    "psm_utils>=0.8",
-    "pydantic>=1.8.2,<2",                      # Fix compatibility with v2 in psm_utils
-    "pyteomics>=4.1.0, <4.7",
+    "psm_utils>=0.9",
+    "pyteomics>=4.7.2",
     "rich>=12",
     "tomli>=2; python_version < '3.11'",
 ]