Refactor PafAnnotation class: Update mass and composition calculations to use new parsing methods, add dict_composition method, and improve error handling for charge in annotations.

Author: pgarrett-scripps

src/paftacular/parser.py

@@ -81,7 +81,12 @@ def mass(self, monoisotopic: bool = True, calculate_sequence: bool = False) -> f
             # Additional mass calculations based on sequence can be added here
             import peptacular as pt
 
-            sequence_mass = pt.mass(self.sequence, monoisotopic=monoisotopic, ion_type="n")
+            annot = pt.parse(self.sequence)
+
+            if annot.has_charge:
+                raise ValueError("Sequence in annotation should not have charge for mass calculation")
+
+            sequence_mass = annot.mass(monoisotopic=monoisotopic, ion_type="n")
             base_mass += sequence_mass
 
         return base_mass
@@ -113,13 +118,23 @@ def composition(self, calculate_sequence: bool = False) -> Counter[ElementInfo]:
 
         if calculate_sequence is True and self.sequence is not None:
             # Additional composition calculations based on sequence can be added here
-            import petacualr as pt
+            import peptacular as pt
 
-            seq_comp = pt.comp(self.sequence)
+            annot = pt.parse(self.sequence)
+
+            if annot.has_charge:
+                raise ValueError("Sequence in annotation should not have charge for mass calculation")
+
+            seq_comp = annot.comp()
             comp.update(seq_comp)
 
         return comp
 
+    def dict_composition(self, calculate_sequence: bool = False) -> dict[str, int]:
+        """Get the elemental composition as a dictionary of element symbols to counts"""
+        comp_counter = self.composition(calculate_sequence=calculate_sequence)
+        return {str(elem): count for elem, count in comp_counter.items()}
+
     @property
     def sequence(self) -> str | None:
         """Get the peptide sequence if applicable, else None"""

tests/test_annot.py

@@ -3,7 +3,7 @@
 import pytest
 from tacular import ELEMENT_LOOKUP
 
-from paftacular import PafAnnotation, mzPAFParser
+from paftacular import PafAnnotation, parse, parse_single
 from paftacular.comps import (
     Adduct,
     ChemicalFormula,
@@ -271,8 +271,7 @@ def test_basic_mass(self):
         """Test basic mass calculation"""
         annotation = PafAnnotation(ion_type=PeptideIon(series=IonSeries.B, position=2))
         # Should have some positive mass
-        assert annotation.monoisotopic_mass > 0
-        assert annotation.average_mass > 0
+        assert annotation.mass() > 0
 
     def test_mass_with_neutral_loss(self):
         """Test mass with neutral loss"""
@@ -282,7 +281,7 @@ def test_mass_with_neutral_loss(self):
             neutral_losses=(NeutralLoss(count=-1, base_formula="H2O"),),
         )
         # Mass should be reduced by water
-        assert with_loss.monoisotopic_mass < base.monoisotopic_mass
+        assert with_loss.mass() < base.mass()
 
     def test_mass_with_charge(self):
         """Test mass calculation includes protonation"""
@@ -291,7 +290,7 @@ def test_mass_with_charge(self):
             charge=2,
         )
         # Should add 2 protons
-        assert annotation.monoisotopic_mass > 0
+        assert annotation.mass() > 0
 
 
 class TestComposition:
@@ -300,7 +299,7 @@ class TestComposition:
     def test_basic_composition(self):
         """Test basic composition calculation"""
         annotation = PafAnnotation(ion_type=ChemicalFormula(formula="C6H12O6"))
-        comp = annotation.composition
+        comp = annotation.composition()
         assert isinstance(comp, Counter)
         # Should contain C, H, O elements
         assert any(elem.symbol == "C" for elem in comp)
@@ -313,7 +312,7 @@ def test_composition_with_charge(self):
             ion_type=ChemicalFormula(formula="C6H12O6"),
             charge=2,
         )
-        comp = annotation.composition
+        comp = annotation.composition()
         # Should have protons added
         h_element = ELEMENT_LOOKUP["H"]
         assert h_element in comp
@@ -324,7 +323,7 @@ def test_composition_with_neutral_loss(self):
             ion_type=ChemicalFormula(formula="C6H12O6"),
             neutral_losses=(NeutralLoss(count=-1, base_formula="H2O"),),
         )
-        comp = annotation.composition
+        comp = annotation.composition()
         # Composition should be affected by loss
         assert isinstance(comp, Counter)
 
@@ -334,43 +333,37 @@ class TestParsing:
 
     def test_parse_simple(self):
         """Test parsing simple annotation"""
-        parser = mzPAFParser()
-        annotation = parser.parse_single("b2")
+        annotation = parse_single("b2")
         assert annotation.ion_type.series == IonSeries.B
         assert annotation.ion_type.position == 2
 
     def test_parse_with_sequence(self):
         """Test parsing with sequence"""
-        parser = mzPAFParser()
-        annotation = parser.parse_single("y3{PEP}")
+        annotation = parse_single("y3{PEP}")
         assert annotation.ion_type.series == IonSeries.Y
         assert annotation.ion_type.position == 3
         assert annotation.ion_type.sequence == "PEP"
 
     def test_parse_with_neutral_loss(self):
         """Test parsing with neutral loss"""
-        parser = mzPAFParser()
-        annotation = parser.parse_single("b2-H2O")
+        annotation = parse_single("b2-H2O")
         assert len(annotation.neutral_losses) == 1
         assert annotation.neutral_losses[0].count == -1
 
     def test_parse_with_adduct(self):
         """Test parsing with adduct"""
-        parser = mzPAFParser()
-        annotation = parser.parse_single("b2[M+Na]")
+        annotation = parse_single("b2[M+Na]")
         assert len(annotation.adducts) == 1
         assert annotation.adducts[0].count == 1
 
     def test_parse_with_charge(self):
         """Test parsing with charge"""
-        parser = mzPAFParser()
-        annotation = parser.parse_single("b2^2")
+        annotation = parse_single("b2^2")
         assert annotation.charge == 2
 
     def test_parse_multiple_annotations(self):
         """Test parsing comma-separated annotations"""
-        parser = mzPAFParser()
-        annotations = parser.parse("b2, y3, a1")
+        annotations = parse("b2, y3, a1")
         assert len(annotations) == 3
         assert annotations[0].ion_type.series == IonSeries.B
         assert annotations[1].ion_type.series == IonSeries.Y
@@ -389,18 +382,16 @@ def test_parse_roundtrip(self):
             "r[TMT126]",
             "f{C6H12O6}",
         ]
-        parser = mzPAFParser()
         for test_str in test_strings:
-            annotation = parser.parse_single(test_str)
+            annotation = parse_single(test_str)
             serialized = annotation.serialize()
-            re_parsed = parser.parse_single(serialized)
+            re_parsed = parse_single(serialized)
             assert annotation.ion_type == re_parsed.ion_type
 
     def test_invalid_annotation(self):
         """Test that invalid annotations raise errors"""
-        parser = mzPAFParser()
         with pytest.raises(ValueError, match="Invalid mzPAF annotation"):
-            parser.parse_single("invalid_annotation!")
+            parse_single("invalid_annotation!")
 
 
 class TestFormulaProperties:
@@ -409,14 +400,14 @@ class TestFormulaProperties:
     def test_formula_property(self):
         """Test formula property returns string"""
         annotation = PafAnnotation(ion_type=ChemicalFormula(formula="C6H12O6"))
-        formula = annotation.formula
+        formula = annotation.formula()
         assert isinstance(formula, str)
         assert len(formula) > 0
 
     def test_proforma_formula_property(self):
         """Test ProForma formula property"""
         annotation = PafAnnotation(ion_type=ChemicalFormula(formula="C6H12O6"))
-        formula = annotation.proforma_formula
+        formula = annotation.proforma_formula()
         assert isinstance(formula, str)
         assert len(formula) > 0
 

tests/test_parser_types.py

@@ -1,7 +1,7 @@
 import pytest
 from tacular import ELEMENT_LOOKUP
 
-from paftacular import PafAnnotation, mzPAFParser
+from paftacular import PafAnnotation, parse, parse_single
 from paftacular.comps import (
     ChemicalFormula,
     ImmoniumIon,
@@ -17,7 +17,7 @@
 
 
 def parse_one(s: str) -> PafAnnotation:
-    return mzPAFParser().parse_single(s)
+    return parse_single(s)
 
 
 # ============================================================================
@@ -755,7 +755,7 @@ def test_complex_annotation_neutral_loss_isotope():
 
 
 def test_multiple_annotations_parse():
-    anns = mzPAFParser().parse("y3, b2, p, IY")
+    anns = parse("y3, b2, p, IY")
     assert len(anns) == 4
 
     assert isinstance(anns[0].ion_type, PeptideIon)
@@ -771,7 +771,7 @@ def test_multiple_annotations_parse():
 
 
 def test_multiple_annotations_complex():
-    anns = mzPAFParser().parse("y5-H2O, b3+NH3, p^2")
+    anns = parse("y5-H2O, b3+NH3, p^2")
     assert len(anns) == 3
 
     # First annotation with neutral loss

tmp.py

@@ -1,13 +1,8 @@
 import paftacular as pft
 
-print(pft.parse("y12{PEPTIDE}/3.4ppm*0.85")[0].mass(calculate_sequence=True))
+print(pft.parse("y12{PEPTIDE-[Oxidation]}/3.4ppm*0.85")[0].mass(calculate_sequence=True))
+print(pft.parse("y12{PEPTIDE-[Oxidation]}/3.4ppm*0.85")[0].dict_composition(calculate_sequence=True))
+print(pft.parse("y12{P[+10]EPTIDE-[Oxidation]}/3.4ppm*0.85")[0].mass(calculate_sequence=True))
 print(pft.parse("p-2[iTRAQ115]"))
 print(pft.parse_single("p-2[iTRAQ115]+2[iTRAQ115][M-2H2O+Na]^2").as_dict())
 print(pft.parse_single("p-2[iTRAQ115]+2[iTRAQ115][M-2H2O+Na]^2").ion_type)
-"""
-{'ion_type': {}, 'analyte_reference': None, 'is_auxiliary': False, 'neutral_losses': 
-[{'sign': -1, 'count': 2, '_formula': None, '_mass': None, '_reference': 'iTRAQ115'}, 
-{'sign': 1, 'count': 2, '_formula': None, '_mass': None, '_reference': 'iTRAQ115'}], 
-'isotopes': [], 'adducts': [{'sign': -1, 'count': 2, '_formula': 'H2O'}, {'sign': 1, 'count': 1, '_formula': 'Na'}], 
-'charge': 2, 'mass_error': None, 'confidence': None}
-"""