peppy-sage 0.1.3__pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl

peppy_sage/__init__.py

@@ -0,0 +1,55 @@
+# 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,
+)
+
+# Define the _rust alias here for internal use by other modules.
+# This makes it accessible via 'from . import _rust' in other package files.
+_rust = type('RustBindings', (object,), {
+    'PyPeptide': PyPeptide,
+    'PyIndexedDatabase': PyIndexedDatabase,
+    'PyProcessedSpectrum': PyProcessedSpectrum,
+    'PyScorer': PyScorer,
+    'PyTolerance': PyTolerance,
+    'PyPrecursor': PyPrecursor,
+    'PyKind': 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/core.py

@@ -0,0 +1,234 @@
+from typing import List, Optional, Tuple, Union
+import numpy as np
+from pyteomics import mass
+from . import _rust
+
+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[1:-1], 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/indexing.py

@@ -0,0 +1,124 @@
+# indexed_database.py
+
+from typing import List, Optional, Tuple, Union
+from .core import Peptide
+from . import _rust
+
+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/scoring.py

@@ -0,0 +1,60 @@
+from . import _rust
+from . import 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 = _rust.PyTolerance.Da(*precursor_tol_da)
+        fragment_tol = _rust.PyTolerance.Ppm(*fragment_tol_ppm)
+
+        self._scorer = _rust.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.3.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: peppy_sage
+Version: 0.1.3
+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.11

peppy_sage-0.1.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+peppy_sage-0.1.3.dist-info/METADATA,sha256=p4xp97UvxhRJwPh9SXbeVbcA5P3Ci4J5QNvXDvs82wc,303
+peppy_sage-0.1.3.dist-info/WHEEL,sha256=58FYlvu5vg1OXOKVWfxLInpqINB3aeZOnVlG23zDrM0,155
+peppy_sage/__init__.py,sha256=u5XtfUF6wqNAGMMfohjNAT7yQSFU5sgbQYVr_W1MTYI,1367
+peppy_sage/_peppy_sage.pypy39-pp73-s390x-linux-gnu.so,sha256=tjxxQJ_rQSYK_Lmc4ycbCtRXdgNkTO-YjbPp8vRniwA,1407848
+peppy_sage/core.py,sha256=ko0Mop95BY5hjXt6qll3G7AUhPMYAnGOSZ_p6tzqjD8,7549
+peppy_sage/indexing.py,sha256=4jV_kcx9bp8R-Ql18i9mPv4XIX1vFGrr84S9r2y8wXQ,4517
+peppy_sage/scoring.py,sha256=NmSiNSV12L4quuAAXS-TLIuiLUXRmA7qE5Z8ArNZZbU,1904
+peppy_sage-0.1.3.dist-info/RECORD,,

peppy_sage-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.10.1)
+Root-Is-Purelib: false
+Tag: pp39-pypy39_pp73-manylinux_2_17_s390x
+Tag: pp39-pypy39_pp73-manylinux2014_s390x