peppy-sage 0.1.0__tar.gz

peppy_sage-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: peppy_sage
+Version: 0.1.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Operating System :: OS Independent
+Summary: Hybrid Rust/Python peptide scoring library
+Author: Daniel Geiszler
+License: MIT
+Requires-Python: >=3.8

peppy_sage-0.1.0/peppy_sage/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "peppy_sage"
+version = "0.1.0"

peppy_sage-0.1.0/peppy_sage/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "peppy_sage"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+name = "peppy_sage"
+crate-type = ["cdylib"]
+
+[dependencies]
+sage_core = { path = "../sage_core", package = "sage-core" }
+rayon = "1.5"
+pyo3 = { version = "0.22", features = ["extension-module", "abi3-py311"] }
+dashmap = "5.5.3"
+fnv = "1.0.7"
+
+[profile.release]
+opt-level = 3
+lto = "fat"
+codegen-units = 1
+debug = true        # ← KEEP THIS
+strip = "none"      # ← KEEP THIS

peppy_sage-0.1.0/peppy_sage/peppy_sage/__init__.py

@@ -0,0 +1,43 @@
+# peppy_sage/__init__.py
+
+# Import the compiled PyO3 extension module
+# (the same name as your PyO3 crate, built by maturin)
+from .peppy_sage import (
+    PyPeptide,
+    PyIndexedDatabase,
+    PyProcessedSpectrum,
+    PyScorer,
+    PyTolerance,
+    PyPrecursor,
+    PyKind,
+)
+
+# Import the high-level Python wrappers
+from .core import Peptide, Spectrum, Precursor
+from .indexing import IndexedDatabase
+from .scoring import Scorer
+
+__all__ = [
+    # Low-level bindings
+    "PyPeptide",
+    "PyIndexedDatabase",
+    "PyProcessedSpectrum",
+    "PyScorer",
+    "PyTolerance",
+    "PyPrecursor",
+    "PyKind",
+    # High-level Python API
+    "Peptide",
+    "IndexedDatabase",
+    "Spectrum",
+    "Precursor",
+    "Scorer",
+]
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("peppy_sage")
+except PackageNotFoundError:
+    # Package is not installed (e.g. running from source tree)
+    __version__ = "0.0.0"

peppy_sage-0.1.0/peppy_sage/peppy_sage/core.py

@@ -0,0 +1,235 @@
+from typing import List, Optional, Tuple, Union
+import numpy as np
+from pyteomics import mass
+import peppy_sage as _rust  # your compiled PyO3 module
+
+
+PROTON_MASS = 1.0072764
+
+
+class Precursor:
+    """
+    Lightweight Python wrapper for PyPrecursor (MS1 parent ion).
+    """
+
+    def __init__(
+            self,
+            mz: float,
+            charge: int,
+            isolation_window: Union[_rust.PyTolerance, Tuple[float, float]] = (0.5, 0.5),
+    ):
+        """
+        Args:
+            mz: The m/z of the precursor ion.
+            charge: The precursor charge state.
+            isolation_window: Either a PyTolerance object or a (low, high) Da tuple.
+        """
+        if isinstance(isolation_window, tuple):
+            isolation_window = _rust.PyTolerance.Da(*isolation_window)
+
+        self._inner = _rust.PyPrecursor(
+            mz=mz,
+            charge=charge,
+            isolation_window=isolation_window,
+        )
+
+    @property
+    def mz(self) -> float:
+        return self._inner.mz
+
+    @property
+    def charge(self) -> int:
+        return self._inner.charge
+
+    @property
+    def isolation_window(self) -> _rust.PyTolerance:
+        return self._inner.isolation_window
+
+    def __repr__(self) -> str:
+        return f"<Precursor mz={self.mz:.4f}, z={self.charge}>"
+
+
+class Spectrum:
+    """
+    High-level Python wrapper around Rust's PyProcessedSpectrum.
+    """
+
+    def __init__(
+            self,
+            id: str,
+            file_id: int,
+            scan_start_time: float,
+            mz_array: Union[List[float], np.ndarray],
+            intensity_array: Union[List[float], np.ndarray],
+            precursors: List[Precursor],
+            total_ion_current: Optional[float] = None,
+    ):
+        """
+        Create a spectrum from arrays of m/z and intensities.
+
+        Args:
+            id: Spectrum identifier (e.g. 'Scan_1234')
+            file_id: Numeric file index (if multiple files are loaded)
+            scan_start_time: Retention time (in minutes)
+            mz_array: List or numpy array of fragment m/z values
+            intensity_array: List or numpy array of corresponding intensities
+            precursors: List of Precursor objects
+            total_ion_current: Optional total ion current; computed automatically if None
+        """
+
+        mz_array = np.asarray(mz_array, dtype=float)
+        intensity_array = np.asarray(intensity_array, dtype=float)
+
+        if mz_array.shape != intensity_array.shape:
+            raise ValueError("mz_array and intensity_array must be the same length.")
+
+        if total_ion_current is None:
+            total_ion_current = float(np.sum(intensity_array))
+
+        mz_array   = np.asarray(mz_array, dtype=np.float32, order="C")
+        intensity_array = np.asarray(intensity_array, dtype=np.float32, order="C")
+
+        self._inner = _rust.PyProcessedSpectrum(
+            id,
+            file_id,
+            scan_start_time,
+            mz_array,
+            intensity_array,
+            [p._inner for p in precursors],
+            total_ion_current,
+        )
+
+    # -------------------------------------------------------------------------
+    # Properties
+    # -------------------------------------------------------------------------
+    @property
+    def id(self) -> str:
+        return self._inner.id
+
+    @property
+    def scan_start_time(self) -> float:
+        return self._inner.scan_start_time
+
+    @property
+    def precursors(self) -> List[Precursor]:
+        """Return a list of precursor ions."""
+        return [Precursor(p.mz, p.charge, p.isolation_window) for p in self._inner.precursors]
+
+    @property
+    def peaks(self) -> List[Tuple[float, float]]:
+        """Return list of (m/z, intensity) tuples."""
+        return [(m, i) for (m, i) in self._inner.peaks]
+
+    @property
+    def total_ion_current(self) -> float:
+        return self._inner.total_ion_current
+
+    # -------------------------------------------------------------------------
+    # Utilities
+    # -------------------------------------------------------------------------
+    def sort_peaks(self, inplace: bool = True) -> "Spectrum":
+        """Sort peaks by m/z value."""
+        peaks = sorted(self.peaks, key=lambda x: x[0])
+        if inplace:
+            mz, ints = zip(*peaks)
+            self._inner = _rust.PyProcessedSpectrum(
+                self.id,
+                self._inner.file_id,
+                self.scan_start_time,
+                list(mz),
+                list(ints),
+                [p._inner for p in self.precursors],
+                self.total_ion_current,
+            )
+            return self
+        else:
+            mz, ints = zip(*peaks)
+            return Spectrum(
+                id=self.id,
+                file_id=self._inner.file_id,
+                scan_start_time=self.scan_start_time,
+                mz_array=mz,
+                intensity_array=ints,
+                precursors=self.precursors,
+                total_ion_current=self.total_ion_current,
+            )
+
+    def __repr__(self):
+        n_peaks = len(self._inner.peaks)
+        return f"<Spectrum id={self.id!r}, peaks={n_peaks}, precursors={len(self.precursors)}>"
+
+
+class Peptide:
+    """
+    High-level Python wrapper for a Rust PyPeptide.
+    Handles sequence, modifications, and mass calculation.
+    """
+
+    def __init__(self, sequence: str, mods: List[float] | None = None): #TODO handle n-term and c-term
+        """
+        Parameters
+        ----------
+        sequence : str
+            Peptide amino acid sequence (e.g., "PEPTIDEK")
+        mods : List[float], optional
+            Array of modification masses (length of sequence + 2).
+            Default is zeros (no mods).
+        """
+        self.sequence = sequence
+
+        if mods is None:
+            mods = [0.0] * (len(sequence) + 2)
+        elif len(mods) != (len(sequence) + 2):
+            raise ValueError(
+                f"Modification array must have length sequence ({len(sequence)}) + 2."
+            )
+
+        self.mods = mods
+
+        # --- Calculate precursor mass using pyteomics ---
+        self.monoisotopic_mass = mass.calculate_mass(sequence=sequence)
+        self.monoisotopic_mass += sum(mods)
+
+        # --- Create the Rust-side PyPeptide object ---
+        self._inner = _rust.PyPeptide(sequence, self.monoisotopic_mass, mods, mods[0], mods[-1])
+
+    @classmethod
+    def from_rust(cls, rust_peptide: _rust.PyPeptide) -> "Peptide":
+        """Construct a Python Peptide from a Rust PyPeptide object."""
+        sequence = rust_peptide.sequence
+        # Rust mods are floats
+        mods = rust_peptide.modifications.copy()
+        return cls(sequence, mods)
+
+    def calculate_theoretical_mz(self, z=1):
+        return (self.monoisotopic_mass + (PROTON_MASS * z)) / z
+
+    @staticmethod
+    def calculate_theoretical_mz(seq, mods, z) -> float:
+        """
+        Compute the theoretical m/z for a peptide.
+
+        Parameters
+        ----------
+        monoisotopic_mass : float
+            Mass of the peptide (including modifications if any)
+        charge : int
+            Charge state
+
+        Returns
+        -------
+        float
+            Theoretical m/z
+        """
+        monoisotopic_mass = mass.calculate_mass(sequence=seq)
+        monoisotopic_mass += sum(mods)
+
+        return (monoisotopic_mass + PROTON_MASS * z) / z
+
+    def __repr__(self):
+        mods_str = ", ".join(f"{m:.2f}" for m in self.mods)
+        return (
+            f"<Peptide seq='{self.sequence}' "
+            f"mass={self.monoisotopic_mass:.4f} "
+            f"mods=[{mods_str}]>"
+        )

peppy_sage-0.1.0/peppy_sage/peppy_sage/indexing.py

@@ -0,0 +1,124 @@
+# indexed_database.py
+
+from . import peppy_sage as _rust  # your compiled PyO3 module
+from typing import List, Optional, Tuple, Union
+from .core import Peptide
+
+ION_KIND_MAP = {
+    #"a": _rust.PyKind.A, #TODO other ion types
+    "b": _rust.PyKind.B,
+    #"c": _rust.PyKind.C,
+    #"x": _rust.PyKind.X,
+    "y": _rust.PyKind.Y,
+    #"z": _rust.PyKind.Z,
+}
+
+def _to_rust_peptide(x: Union[Peptide, _rust.PyPeptide, str]) -> _rust.PyPeptide:
+    if isinstance(x, _rust.PyPeptide):
+        return x
+    if isinstance(x, Peptide):
+        # assuming your wrapper keeps the raw object on ._inner (or similar)
+        return x._inner
+    if isinstance(x, str):
+        return _rust.PyPeptide(x)
+    raise TypeError(
+        f"Expected Peptide | PyPeptide | str, got {type(x).__name__}"
+    )
+
+class IndexedDatabase:
+    """
+    Pythonic wrapper around the Rust-backed PyIndexedDatabase.
+
+    Example:
+        >>> db = IndexedDatabase.from_peptides(
+        ...     peptides=my_peptides,
+        ...     ion_kinds=["b", "y"],
+        ...     bucket_size=50,
+        ...     generate_decoys=True,
+        ...     decoy_tag="DECOY_"
+        ... )
+        >>> print(len(db.peptides))
+        >>> print(db.fragment_count)
+    """
+
+    def __init__(self, _inner: _rust.PyIndexedDatabase):
+        self._inner = _inner
+
+    # -------------------------------------------------------------------------
+    # Constructors
+    # -------------------------------------------------------------------------
+    @classmethod
+    def from_peptides(
+            cls,
+            peptides: List[Union[Peptide, "_rust.PyPeptide"]],
+            ion_kinds: List[str],
+            bucket_size: int = 8192,
+            min_ion_index: int = 1,
+            generate_decoys: bool = False,
+            decoy_tag: str = "rev_",
+            peptide_min_mass: float = 500,
+            peptide_max_mass: float = 5000.0,
+    ) -> "IndexedDatabase":
+        """
+        Build an indexed database from a list of peptides and configuration.
+
+        Args:
+            peptides: List of PyPeptide objects (from Rust layer).
+            ion_kinds: List of ion types to include, e.g. ["b", "y"].
+            bucket_size: Number of fragments per mass bucket.
+            min_ion_index: Minimum ion index to include.
+            generate_decoys: Whether to generate decoy peptides.
+            decoy_tag: Prefix used to label decoy peptides.
+            peptide_min_mass: Minimum peptide monoisotopic mass to include.
+            peptide_max_mass: Maximum peptide monoisotopic mass to include.
+        """
+
+        try:
+            ion_enum_list = [ION_KIND_MAP[k.lower()]() for k in ion_kinds]
+        except KeyError as e:
+            raise ValueError(f"Invalid ion kind: {e.args[0]}. Must be one of {list(ION_KIND_MAP)}")
+
+        rust_peptides = [_to_rust_peptide(p) for p in peptides]
+
+        inner = _rust.PyIndexedDatabase.from_peptides_and_config(
+            peptides=rust_peptides,
+            bucket_size=bucket_size,
+            ion_kinds=ion_enum_list,
+            min_ion_index=min_ion_index,
+            generate_decoys=generate_decoys,
+            decoy_tag=decoy_tag,
+            peptide_min_mass=peptide_min_mass,
+            peptide_max_mass=peptide_max_mass,
+        )
+
+        return cls(inner)
+
+    # -------------------------------------------------------------------------
+    # Properties
+    # -------------------------------------------------------------------------
+    @property
+    def peptides(self) -> List["_rust.PyPeptide"]:
+        """Return the list of peptides stored in this indexed database."""
+        return self._inner.peptides
+
+    @property
+    def fragment_count(self) -> int:
+        """Return the total number of fragments indexed."""
+        return self._inner.fragment_count()
+
+    # -------------------------------------------------------------------------
+    # Debug / Inspection
+    # -------------------------------------------------------------------------
+    def debug_fragment_summary(self) -> List[Tuple[float, int]]:
+        """
+        Return a summary of (fragment_mz, peptide_index) tuples for debugging.
+        """
+        return self._inner.debug_fragment_summary()
+
+    def summary(self, limit: Optional[int] = 10) -> None:
+        """Print a short summary of fragments for inspection."""
+        summary = self.debug_fragment_summary()
+        print(f"Indexed fragments: {self.fragment_count}")
+        print("Example fragments:")
+        for mz, pep_idx in summary[:limit]:
+            print(f"  - m/z={mz:.4f}, peptide_index={pep_idx}")

peppy_sage-0.1.0/peppy_sage/peppy_sage/scoring.py

@@ -0,0 +1,59 @@
+from peppy_sage import PyScorer, PyTolerance, Peptide
+
+class Scorer:
+    """
+    High-level scoring interface for peppy_sage.
+    Wraps the underlying Rust-based PyScorer for convenience.
+    """
+
+    def __init__(
+            self,
+            precursor_tol_da: tuple[float, float] = (-1.0, 1.0),
+            fragment_tol_ppm: tuple[float, float] = (-5.0, 5.0),
+            wide_window: bool = False,
+            chimera: bool = True,
+            report_psms: int = 10,
+            min_isotope_err: int = -1,
+            max_isotope_err: int = 3,
+            min_precursor_charge: int = 1,
+            max_precursor_charge: int = 4,
+            min_matched_peaks: int = 0,
+            annotate_matches: bool = True,
+            max_fragment_charge: int = 1,
+    ):
+        """Initialize the high-level scoring object."""
+        precursor_tol = PyTolerance.Da(*precursor_tol_da)
+        fragment_tol = PyTolerance.Ppm(*fragment_tol_ppm)
+
+        self._scorer = PyScorer(
+            precursor_tol,
+            fragment_tol,
+            wide_window,
+            chimera,
+            report_psms,
+            min_isotope_err,
+            max_isotope_err,
+            min_precursor_charge,
+            max_precursor_charge,
+            min_matched_peaks,
+            annotate_matches,
+            max_fragment_charge,
+        )
+
+    def score(self, db, spectrum):
+        """
+        Score a single spectrum (or a list of spectra) against the given database.
+        Returns a list of features (PSMs).
+        """
+        features = self._scorer.score_spectra(db._inner, spectrum._inner)
+
+        return features
+
+    def score_many(self, db, spectra):
+        """
+        Score many spectra and convert Rust peptides to Python Peptide.
+        """
+        rust_spectra = [s._inner for s in spectra]
+        all_hits = self._scorer.score_many_spectra(db._inner, rust_spectra)
+
+        return all_hits

peppy_sage-0.1.0/peppy_sage/src/index_logic.rs

@@ -0,0 +1,143 @@
+use sage_core::database::{IndexedDatabase, PeptideIx, Theoretical};
+use sage_core::peptide::Peptide;
+use sage_core::ion_series::{IonSeries, Kind};
+use sage_core::modification::ModificationSpecificity;
+use std::sync::Arc;
+use dashmap::DashSet;
+use fnv::FnvBuildHasher;
+use rayon::prelude::*;
+// Add imports for types used in the original logic (e.g., DashSet, FnvBuildHasher, etc. if you copied that part)
+
+// 1. Define the minimal configuration struct
+pub struct IndexingConfig {
+    pub bucket_size: usize,
+    pub ion_kinds: Vec<Kind>,
+    pub min_ion_index: usize,
+    pub generate_decoys: bool,
+    pub decoy_tag: String,
+    //pub potential_mods: Vec<(ModificationSpecificity, f32)>,
+    pub peptide_min_mass: f32,
+    pub peptide_max_mass: f32,
+}
+
+// 2. Define the core indexing function (pasting the adapted logic)
+pub fn build_indexed_database(config: IndexingConfig, targets: Vec<Peptide>) -> IndexedDatabase {
+    // NOTE: This is where you paste the full, adapted logic from
+    // the original Parameters::build_from_peptides method.
+
+    let peptides = if config.generate_decoys {
+        // gather target sequences for collision checks
+        let target_seqs: DashSet<Arc<[u8]>, FnvBuildHasher> = DashSet::default();
+        targets
+            .par_iter()
+            .filter(|p| !p.decoy)
+            .for_each(|p| {
+                target_seqs.insert(p.sequence.clone());
+            });
+
+        // build output = targets (+ valid reversed decoys)
+        let out: Vec<Peptide> = targets
+            .into_par_iter()
+            .flat_map_iter(|p| {
+                // always keep the target
+                let mut v = Vec::with_capacity(2);
+                v.push(p.clone());
+
+                // reversed decoy; skip if reversed equals a real target sequence
+                let rev = p.reverse();
+                if !target_seqs.contains(&rev.sequence) {
+                    v.push(rev);
+                }
+                v.into_iter()
+            })
+            .collect(); // CHANGE: collect the parallel stream directly
+        out
+    } else {
+        targets
+    };
+
+    // --- Adapted Fragmentation Logic ---
+    let mut fragments = peptides
+        .par_iter()
+        .enumerate()
+        .flat_map(|(idx, peptide)| {
+            // ... (mass filter logic remains the same) ...
+
+            // Generate ions (using config fields)
+            config.ion_kinds
+                .iter()
+                .flat_map(|kind| IonSeries::new(peptide, *kind).enumerate())
+                .filter(|(ion_idx, ion)| {
+                    // ... (filtering logic remains the same) ...
+                    match ion.kind {
+                        Kind::A | Kind::B | Kind::C => (ion_idx + 1) > config.min_ion_index,
+                        Kind::X | Kind::Y | Kind::Z => {
+                            peptide.sequence.len().saturating_sub(1) - ion_idx > config.min_ion_index
+                        }
+                    }
+                })
+                .map(move |(_, ion)| Theoretical {
+                    peptide_index: PeptideIx(idx as u32),
+                    fragment_mz: ion.monoisotopic_mass,
+                })
+                // FIX: Collect into a Vec, and immediately convert that Vec
+                // into a parallel iterator (`IntoParallelIterator`) for Rayon.
+                .collect::<Vec<Theoretical>>()
+                .into_par_iter() // <--- THIS IS THE KEY CHANGE
+        })
+        // Final collect is now correct because flat_map returns a ParallelIterator
+        .collect::<Vec<_>>();
+
+    // --- Sorting and Bucketing Logic ---
+    fragments.par_sort_unstable_by(|a, b| a.fragment_mz.total_cmp(&b.fragment_mz));
+
+    let min_value = fragments
+        .par_chunks_mut(config.bucket_size)
+        .map(|chunk| {
+            let min = chunk[0].fragment_mz;
+            chunk.par_sort_unstable_by(|a, b| a.peptide_index.cmp(&b.peptide_index));
+            min
+        })
+        .collect::<Vec<_>>();
+
+    // 3. Final Struct Return
+    IndexedDatabase {
+        peptides: peptides,
+        fragments,
+        min_value,
+        bucket_size: config.bucket_size,
+        ion_kinds: config.ion_kinds,
+        generate_decoys: config.generate_decoys,
+        potential_mods: Vec::new(), // inserting dummy values here since they won't be used
+        decoy_tag: config.decoy_tag,
+    }
+}
+
+/// Local sort+dedup that mirrors `Parameters::reorder_peptides`.
+fn sort_and_dedup(peptides: &mut Vec<Peptide>) {
+    peptides.par_sort_unstable_by(|a, b| {
+        a.monoisotopic
+            .total_cmp(&b.monoisotopic)
+            .then_with(|| a.initial_sort(b))
+    });
+
+    peptides.dedup_by(|remove, keep| {
+        if remove.monoisotopic == keep.monoisotopic
+            && remove.sequence == keep.sequence
+            && remove.modifications == keep.modifications
+            && remove.nterm == keep.nterm
+            && remove.cterm == keep.cterm
+        {
+            keep.proteins.extend(remove.proteins.iter().cloned());
+            // if any source was target, the merged stays target
+            keep.decoy &= remove.decoy;
+            true
+        } else {
+            false
+        }
+    });
+
+    peptides
+        .par_iter_mut()
+        .for_each(|p| p.proteins.sort_unstable());
+}