Targeted Analysis and MRM

class TargetedExperiment:
    def __init__(self) -> None: ...
    
    def getTransitions(self) -> list[ReactionMonitoringTransition]:
        """
        Get all transitions.
        
        Returns:
            list[ReactionMonitoringTransition]: List of transitions
        """
    
    def setTransitions(self, transitions: list[ReactionMonitoringTransition]) -> None:
        """
        Set transitions.
        
        Args:
            transitions (list[ReactionMonitoringTransition]): Transitions to set
        """
    
    def addTransition(self, transition: ReactionMonitoringTransition) -> None:
        """
        Add transition.
        
        Args:
            transition (ReactionMonitoringTransition): Transition to add
        """
    
    def getCompounds(self) -> list[Compound]:
        """
        Get compound definitions.
        
        Returns:
            list[Compound]: List of compounds
        """
    
    def setCompounds(self, compounds: list[Compound]) -> None:
        """
        Set compounds.
        
        Args:
            compounds (list[Compound]): Compounds to set
        """
    
    def addCompound(self, compound: Compound) -> None:
        """
        Add compound.
        
        Args:
            compound (Compound): Compound to add
        """
    
    def getProteins(self) -> list[Protein]:
        """
        Get protein definitions.
        
        Returns:
            list[Protein]: List of proteins
        """
    
    def setProteins(self, proteins: list[Protein]) -> None:
        """
        Set proteins.
        
        Args:
            proteins (list[Protein]): Proteins to set
        """
    
    def addProtein(self, protein: Protein) -> None:
        """
        Add protein.
        
        Args:
            protein (Protein): Protein to add
        """
    
    def getPeptides(self) -> list[Peptide]:
        """
        Get peptide definitions.
        
        Returns:
            list[Peptide]: List of peptides
        """
    
    def setPeptides(self, peptides: list[Peptide]) -> None:
        """
        Set peptides.
        
        Args:
            peptides (list[Peptide]): Peptides to set
        """
    
    def addPeptide(self, peptide: Peptide) -> None:
        """
        Add peptide.
        
        Args:
            peptide (Peptide): Peptide to add
        """
    
    def sortTransitionsByProductMZ(self) -> None:
        """Sort transitions by product m/z."""
    
    def getTransitionByRef(self, ref: str) -> ReactionMonitoringTransition:
        """
        Get transition by reference.
        
        Args:
            ref (str): Transition reference ID
            
        Returns:
            ReactionMonitoringTransition: The transition
        """

class ReactionMonitoringTransition:
    def __init__(self) -> None: ...
    
    def getName(self) -> str:
        """
        Get transition name.
        
        Returns:
            str: Transition name
        """
    
    def setName(self, name: str) -> None:
        """
        Set transition name.
        
        Args:
            name (str): Transition name
        """
    
    def getNativeID(self) -> str:
        """
        Get native ID.
        
        Returns:
            str: Native identifier
        """
    
    def setNativeID(self, id: str) -> None:
        """
        Set native ID.
        
        Args:
            id (str): Native identifier
        """
    
    def getPrecursor(self) -> Precursor:
        """
        Get precursor ion.
        
        Returns:
            Precursor: Precursor ion definition
        """
    
    def setPrecursor(self, precursor: Precursor) -> None:
        """
        Set precursor ion.
        
        Args:
            precursor (Precursor): Precursor ion definition
        """
    
    def getProduct(self) -> Product:
        """
        Get product ion.
        
        Returns:
            Product: Product ion definition
        """
    
    def setProduct(self, product: Product) -> None:
        """
        Set product ion.
        
        Args:
            product (Product): Product ion definition
        """
    
    def getRetentionTime(self) -> RetentionTime:
        """
        Get retention time constraint.
        
        Returns:
            RetentionTime: RT constraint
        """
    
    def setRetentionTime(self, rt: RetentionTime) -> None:
        """
        Set retention time constraint.
        
        Args:
            rt (RetentionTime): RT constraint
        """
    
    def getPeptideRef(self) -> str:
        """
        Get peptide reference.
        
        Returns:
            str: Peptide reference ID
        """
    
    def setPeptideRef(self, ref: str) -> None:
        """
        Set peptide reference.
        
        Args:
            ref (str): Peptide reference ID
        """
    
    def getCompoundRef(self) -> str:
        """
        Get compound reference.
        
        Returns:
            str: Compound reference ID
        """
    
    def setCompoundRef(self, ref: str) -> None:
        """
        Set compound reference.
        
        Args:
            ref (str): Compound reference ID
        """
    
    def getDecoyTransitionType(self) -> DecoyTransitionType:
        """
        Get decoy type.
        
        Returns:
            DecoyTransitionType: Decoy classification
        """
    
    def setDecoyTransitionType(self, type: DecoyTransitionType) -> None:
        """
        Set decoy type.
        
        Args:
            type (DecoyTransitionType): Decoy classification
        """
    
    def isTargetTransition(self) -> bool:
        """
        Check if target transition.
        
        Returns:
            bool: True if target transition
        """
    
    def isDecoyTransition(self) -> bool:
        """
        Check if decoy transition.
        
        Returns:
            bool: True if decoy transition
        """

class DecoyTransitionType:
    TARGET = 0
    DECOY = 1
    UNKNOWN = 2

class MRMFeature:
    def __init__(self) -> None: ...
    
    def getRT(self) -> float:
        """
        Get retention time.
        
        Returns:
            float: Retention time in seconds
        """
    
    def setRT(self, rt: float) -> None:
        """
        Set retention time.
        
        Args:
            rt (float): Retention time in seconds
        """
    
    def getIntensity(self) -> float:
        """
        Get feature intensity.
        
        Returns:
            float: Feature intensity
        """
    
    def setIntensity(self, intensity: float) -> None:
        """
        Set intensity.
        
        Args:
            intensity (float): Feature intensity
        """
    
    def getOverallQuality(self) -> float:
        """
        Get overall quality score.
        
        Returns:
            float: Quality score
        """
    
    def setOverallQuality(self, quality: float) -> None:
        """
        Set quality score.
        
        Args:
            quality (float): Quality score
        """
    
    def getScore(self, score_name: str) -> float:
        """
        Get named score.
        
        Args:
            score_name (str): Score name
            
        Returns:
            float: Score value
        """
    
    def setScore(self, score_name: str, score: float) -> None:
        """
        Set named score.
        
        Args:
            score_name (str): Score name
            score (float): Score value
        """
    
    def getFeature(self, key: str) -> Feature:
        """
        Get sub-feature by key.
        
        Args:
            key (str): Feature key
            
        Returns:
            Feature: Sub-feature
        """
    
    def addFeature(self, feature: Feature, key: str) -> None:
        """
        Add sub-feature.
        
        Args:
            feature (Feature): Sub-feature to add
            key (str): Feature key
        """
    
    def getFeatureIDs(self) -> list[str]:
        """
        Get all feature keys.
        
        Returns:
            list[str]: List of feature keys
        """

class MRMTransitionGroup:
    def __init__(self) -> None: ...
    
    def getTransitionGroupID(self) -> str:
        """
        Get transition group ID.
        
        Returns:
            str: Group identifier
        """
    
    def setTransitionGroupID(self, id: str) -> None:
        """
        Set transition group ID.
        
        Args:
            id (str): Group identifier
        """
    
    def getTransitions(self) -> list[ReactionMonitoringTransition]:
        """
        Get transitions in group.
        
        Returns:
            list[ReactionMonitoringTransition]: Transitions
        """
    
    def addTransition(self, transition: ReactionMonitoringTransition, key: str) -> None:
        """
        Add transition to group.
        
        Args:
            transition (ReactionMonitoringTransition): Transition to add
            key (str): Transition key
        """
    
    def getChromatograms(self) -> list[MSChromatogram]:
        """
        Get chromatograms.
        
        Returns:
            list[MSChromatogram]: Transition chromatograms
        """
    
    def addChromatogram(self, chromatogram: MSChromatogram, key: str) -> None:
        """
        Add chromatogram.
        
        Args:
            chromatogram (MSChromatogram): Chromatogram to add
            key (str): Chromatogram key
        """

class Compound:
    def __init__(self) -> None: ...
    
    def getId(self) -> str:
        """Get compound ID."""
    
    def setId(self, id: str) -> None:
        """Set compound ID."""
    
    def getMolecularFormula(self) -> str:
        """Get molecular formula."""
    
    def setMolecularFormula(self, formula: str) -> None:
        """Set molecular formula."""
    
    def getSmiles(self) -> str:
        """Get SMILES string."""
    
    def setSmiles(self, smiles: str) -> None:
        """Set SMILES string."""
    
    def getInChI(self) -> str:
        """Get InChI string."""
    
    def setInChI(self, inchi: str) -> None:
        """Set InChI string."""
    
    def getTheoreticalMass(self) -> float:
        """Get theoretical mass."""
    
    def setTheoreticalMass(self, mass: float) -> None:
        """Set theoretical mass."""
    
    def getRetentionTimes(self) -> list[RetentionTime]:
        """Get retention time constraints."""
    
    def addRetentionTime(self, rt: RetentionTime) -> None:
        """Add retention time constraint."""

class Peptide:
    def __init__(self) -> None: ...
    
    def getId(self) -> str:
        """Get peptide ID."""
    
    def setId(self, id: str) -> None:
        """Set peptide ID."""
    
    def getSequence(self) -> str:
        """Get peptide sequence."""
    
    def setSequence(self, sequence: str) -> None:
        """Set peptide sequence."""
    
    def getModifications(self) -> list[Modification]:
        """Get peptide modifications."""
    
    def addModification(self, mod: Modification) -> None:
        """Add modification."""
    
    def getChargeStates(self) -> list[int]:
        """Get charge states."""
    
    def addChargeState(self, charge: int) -> None:
        """Add charge state."""
    
    def getProteinRefs(self) -> list[str]:
        """Get protein references."""
    
    def addProteinRef(self, ref: str) -> None:
        """Add protein reference."""
    
    def getRetentionTimes(self) -> list[RetentionTime]:
        """Get retention time constraints."""
    
    def addRetentionTime(self, rt: RetentionTime) -> None:
        """Add retention time constraint."""

class OpenSwathWorkflow:
    def __init__(self) -> None: ...
    
    def performExtraction(self, input: MSExperiment, targeted_exp: TargetedExperiment,
                         output: FeatureMap, trafo: TransformationDescription) -> None:
        """
        Perform OpenSWATH feature extraction.
        
        Args:
            input (MSExperiment): Input DIA data
            targeted_exp (TargetedExperiment): Transition library
            output (FeatureMap): Output features
            trafo (TransformationDescription): RT transformation
        """
    
    def getParameters(self) -> Param:
        """Get workflow parameters."""
    
    def setParameters(self, param: Param) -> None:
        """Set workflow parameters."""

class DIAScoring:
    def __init__(self) -> None: ...
    
    def dia_score(self, transition_group: MRMTransitionGroup, 
                  spectrum: list[MSSpectrum]) -> None:
        """
        Score DIA transition group.
        
        Args:
            transition_group (MRMTransitionGroup): Transition group to score
            spectrum (list[MSSpectrum]): DIA spectra
        """
    
    def getParameters(self) -> Param:
        """Get scoring parameters."""

class MRMTransitionGroupPicker:
    def __init__(self) -> None: ...
    
    def pickTransitionGroup(self, chromatograms: list[MSChromatogram]) -> MRMFeature:
        """
        Pick peaks in transition group chromatograms.
        
        Args:
            chromatograms (list[MSChromatogram]): Input chromatograms
            
        Returns:
            MRMFeature: Detected MRM feature
        """
    
    def getParameters(self) -> Param:
        """Get picking parameters."""
    
    def setParameters(self, param: Param) -> None:
        """Set picking parameters."""

class PeakIntegrator:
    def __init__(self) -> None: ...
    
    def integratePeak(self, chromatogram: MSChromatogram, left: float, 
                     right: float) -> tuple[float, float]:
        """
        Integrate chromatographic peak.
        
        Args:
            chromatogram (MSChromatogram): Input chromatogram
            left (float): Left boundary RT
            right (float): Right boundary RT
            
        Returns:
            tuple[float, float]: (area, height)
        """
    
    def getParameters(self) -> Param:
        """Get integration parameters."""

class RetentionTime:
    def __init__(self) -> None: ...
    
    def getRT(self) -> float:
        """
        Get retention time.
        
        Returns:
            float: Retention time in seconds
        """
    
    def setRT(self, rt: float) -> None:
        """
        Set retention time.
        
        Args:
            rt (float): Retention time in seconds
        """
    
    def getRTUnit(self) -> RTUnit:
        """
        Get retention time unit.
        
        Returns:
            RTUnit: Time unit
        """
    
    def setRTUnit(self, unit: RTUnit) -> None:
        """
        Set retention time unit.
        
        Args:
            unit (RTUnit): Time unit
        """
    
    def getRTType(self) -> RTType:
        """
        Get retention time type.
        
        Returns:
            RTType: RT type (predicted, observed, etc.)
        """
    
    def setRTType(self, type: RTType) -> None:
        """
        Set retention time type.
        
        Args:
            type (RTType): RT type
        """
    
    def getRTWindow(self) -> tuple[float, float]:
        """
        Get retention time window.
        
        Returns:
            tuple[float, float]: (lower_bound, upper_bound)
        """
    
    def setRTWindow(self, lower: float, upper: float) -> None:
        """
        Set retention time window.
        
        Args:
            lower (float): Lower bound
            upper (float): Upper bound
        """

class RTUnit:
    SECOND = 0
    MINUTE = 1

class RTType:
    PREDICTED = 0
    OBSERVED = 1
    NORMALIZED = 2

import pyopenms

# Create targeted experiment
targeted_exp = pyopenms.TargetedExperiment()

# Define protein
protein = pyopenms.Protein()
protein.setId("P12345")
protein.setSequence("MPROTEINSEQUENCK")
targeted_exp.addProtein(protein)

# Define peptide
peptide = pyopenms.Peptide()
peptide.setId("PEPTIDE_1")
peptide.setSequence("PEPTIDE")
peptide.addChargeState(2)
peptide.addProteinRef("P12345")

# Add retention time constraint
rt = pyopenms.RetentionTime()
rt.setRT(123.45)
rt.setRTWindow(113.45, 133.45)  # ±10 seconds
peptide.addRetentionTime(rt)

targeted_exp.addPeptide(peptide)

# Create transitions
for product_mz in [200.1, 300.2, 400.3]:
    transition = pyopenms.ReactionMonitoringTransition()
    transition.setName(f"PEPTIDE_2_{product_mz:.1f}")
    transition.setPeptideRef("PEPTIDE_1")
    
    # Set precursor
    precursor = pyopenms.Precursor()
    precursor.setMZ(400.7)  # [M+2H]2+
    precursor.setCharge(2)
    transition.setPrecursor(precursor)
    
    # Set product
    product = pyopenms.Product()
    product.setMZ(product_mz)
    product.setCharge(1)
    transition.setProduct(product)
    
    # Set retention time
    transition.setRetentionTime(rt)
    
    targeted_exp.addTransition(transition)

print(f"Created targeted experiment with {len(targeted_exp.getTransitions())} transitions")

# Save to TraML file
pyopenms.TraMLFile().store("targeted_experiment.traml", targeted_exp)

import pyopenms

# Load MRM data and targeted experiment
exp = pyopenms.MSExperiment()
pyopenms.MzMLFile().load("mrm_data.mzML", exp)

targeted_exp = pyopenms.TargetedExperiment()
pyopenms.TraMLFile().load("transitions.traml", targeted_exp)

print(f"Loaded {exp.getNrChromatograms()} chromatograms")
print(f"Loaded {len(targeted_exp.getTransitions())} transitions")

# Extract chromatograms for each transition group
transition_groups = {}
transitions = targeted_exp.getTransitions()

for transition in transitions:
    peptide_ref = transition.getPeptideRef()
    if peptide_ref not in transition_groups:
        transition_groups[peptide_ref] = []
    transition_groups[peptide_ref].append(transition)

print(f"Found {len(transition_groups)} transition groups")

# Process each transition group
picker = pyopenms.MRMTransitionGroupPicker()
params = picker.getParameters()
params.setValue("min_peak_width", 5.0)
params.setValue("peak_integration", "original")
picker.setParameters(params)

results = []
for peptide_ref, group_transitions in transition_groups.items():
    print(f"Processing {peptide_ref} with {len(group_transitions)} transitions")
    
    # Get chromatograms for this group
    group_chromatograms = []
    for chrom in exp.getChromatograms():
        native_id = chrom.getNativeID()
        for transition in group_transitions:
            if transition.getName() in native_id:
                group_chromatograms.append(chrom)
                break
    
    if group_chromatograms:
        # Pick peaks
        feature = picker.pickTransitionGroup(group_chromatograms)
        
        result = {
            'peptide': peptide_ref,
            'rt': feature.getRT(),
            'intensity': feature.getIntensity(),
            'quality': feature.getOverallQuality()
        }
        results.append(result)

# Display results
print("\nMRM Analysis Results:")
for result in results:
    print(f"{result['peptide']}: RT={result['rt']:.2f}, "
          f"Intensity={result['intensity']:.0f}, "
          f"Quality={result['quality']:.3f}")

import pyopenms

# Load DIA data
exp = pyopenms.MSExperiment()
pyopenms.MzMLFile().load("dia_data.mzML", exp)

# Load spectral library
targeted_exp = pyopenms.TargetedExperiment()
pyopenms.TraMLFile().load("spectral_library.traml", targeted_exp)

# Set up OpenSWATH workflow
osw = pyopenms.OpenSwathWorkflow()
params = osw.getParameters()

# Configure scoring parameters
params.setValue("Scoring:stop_report_after_feature", 5)
params.setValue("Scoring:rt_normalization_factor", 100.0)
params.setValue("Scoring:quantification_cutoff", 0.01)
params.setValue("Scoring:write_convex_hull", "false")

# Configure extraction parameters
params.setValue("Library:retentionTimeInterpretation", "seconds")
params.setValue("Library:override_group_label_check", "false")

osw.setParameters(params)

# Run extraction
output_features = pyopenms.FeatureMap()
trafo = pyopenms.TransformationDescription()

print("Running OpenSWATH extraction...")
osw.performExtraction(exp, targeted_exp, output_features, trafo)

print(f"Extracted {output_features.size()} features")

# Export results
pyopenms.FeatureXMLFile().store("openswath_results.featureXML", output_features)

# Analyze results
high_confidence = 0
for feature in output_features:
    main_score = feature.getMetaValue("main_var_xx_swath_prelim_score")
    if main_score < 0.01:  # High confidence threshold
        high_confidence += 1

print(f"High confidence identifications: {high_confidence}")

import pyopenms

# Load protein sequences
fasta_entries = []
pyopenms.FASTAFile().load("proteins.fasta", fasta_entries)

# Set up digestion
digester = pyopenms.EnzymaticDigestion()
digester.setEnzyme("Trypsin")
digester.setMissedCleavages(1)

# Create targeted experiment
targeted_exp = pyopenms.TargetedExperiment()

peptide_id = 0
transition_id = 0

for entry in fasta_entries[:10]:  # Process first 10 proteins
    protein = pyopenms.Protein()
    protein.setId(entry.getIdentifier())
    protein.setSequence(entry.getSequence())
    targeted_exp.addProtein(protein)
    
    # Digest protein
    peptides = []
    digester.digest(pyopenms.AASequence.fromString(entry.getSequence()), peptides)
    
    for pep_seq in peptides:
        if 7 <= len(pep_seq) <= 25:  # Reasonable peptide length
            peptide = pyopenms.Peptide()
            peptide.setId(f"peptide_{peptide_id}")
            peptide.setSequence(pep_seq.toString())
            peptide.addProteinRef(entry.getIdentifier())
            
            # Add charge states
            for charge in [2, 3]:
                peptide.addChargeState(charge)
                
                # Generate theoretical spectrum
                generator = pyopenms.TheoreticalSpectrumGenerator()
                spec = pyopenms.MSSpectrum()
                generator.getSpectrum(spec, pep_seq, charge, 1)
                
                precursor_mz = (pep_seq.getMonoWeight() + charge * 1.007276) / charge
                
                # Create transitions for top 5 fragments
                peaks = spec.get_peaks()
                if len(peaks[0]) > 0:
                    # Sort by intensity and take top 5
                    peak_list = list(zip(peaks[0], peaks[1]))
                    peak_list.sort(key=lambda x: x[1], reverse=True)
                    
                    for i, (product_mz, intensity) in enumerate(peak_list[:5]):
                        transition = pyopenms.ReactionMonitoringTransition()
                        transition.setName(f"transition_{transition_id}")
                        transition.setPeptideRef(f"peptide_{peptide_id}")
                        
                        # Set precursor
                        precursor = pyopenms.Precursor()
                        precursor.setMZ(precursor_mz)
                        precursor.setCharge(charge)
                        transition.setPrecursor(precursor)
                        
                        # Set product
                        product = pyopenms.Product()
                        product.setMZ(product_mz)
                        product.setCharge(1)
                        transition.setProduct(product)
                        
                        targeted_exp.addTransition(transition)
                        transition_id += 1
            
            targeted_exp.addPeptide(peptide)
            peptide_id += 1

print(f"Generated {len(targeted_exp.getTransitions())} transitions")
print(f"for {len(targeted_exp.getPeptides())} peptides")
print(f"from {len(targeted_exp.getProteins())} proteins")

# Save transition list
pyopenms.TraMLFile().store("generated_transitions.traml", targeted_exp)