def test_link_site_no_overlap(self):
ambig = '''
RES
1b:x-dglc-HEX-x:x
2s:n-acetyl
3b:b-dglc-HEX-1:5
4s:n-acetyl
5b:b-dman-HEX-1:5
6b:a-dman-HEX-1:5
7b:b-dglc-HEX-1:5
8s:n-acetyl
9b:b-dgal-HEX-1:5
10b:a-dman-HEX-1:5
11b:a-dman-HEX-1:5
LIN
1:1d(2+1)2n
2:1o(4+1)3d
3:3d(2+1)4n
4:3o(4+1)5d
5:5o(3|6+1)6d
6:6o(2+1)7d
7:7d(2+1)8n
8:7o(4+1)9d
9:5o(3|6+1)10d
10:10o(3|6+1)11d
'''
exact = '''
RES
1b:x-dglc-HEX-1:5
2s:n-acetyl
3b:b-dglc-HEX-1:5
4s:n-acetyl
5b:b-dman-HEX-1:5
6b:a-dman-HEX-1:5
7b:b-dglc-HEX-1:5
8s:n-acetyl
9b:a-dman-HEX-1:5
10b:a-dman-HEX-1:5
11b:a-dman-HEX-1:5
LIN
1:1d(2+1)2n
2:1o(4+1)3d
3:3d(2+1)4n
4:3o(4+1)5d
5:5o(3+1)6d
6:6o(2+1)7d
7:7d(2+1)8n
8:5o(6+1)9d
9:9o(3+1)10d
10:9o(6+1)11d
'''
ambig = glycoct.loads(ambig)
exact = glycoct.loads(exact)
ambig.set_reducing_end(True)
exact.set_reducing_end(True)
self.assertEqual(ambig.total_composition(), exact.total_composition())
self.assertEqual(ambig, ambig.clone())
self.assertEqual(derivatize(ambig.clone(), 'methyl').total_composition(),
derivatize(exact.clone(), 'methyl').total_composition())
def apply_derivatization(self, residue, deriv):
if deriv.startswith("^"):
deriv = deriv[1:]
deriv = self.substituent_parser.symbol_to_name(deriv)
derivatize(residue, deriv)
else:
raise IUPACError("Derivatization Extension Must Start with '^'")
def test_strip_derivatize(self):
glycan = load("common_glycan")
glycan.reducing_end = ReducedEnd()
mass = glycan.mass()
composition_transform.derivatize(glycan, 'methyl')
self.assertNotEqual(mass, glycan.mass())
composition_transform.strip_derivatization(glycan)
self.assertAlmostEqual(glycan.mass(), mass, 3)
def test_parse_derivatized(self):
glyc = glycans["N-Linked Core"]
composition_transform.derivatize(glyc, "methyl")
comp = GlycanComposition.from_glycan(glycans["N-Linked Core"])
composition_transform.derivatize(comp, "methyl")
self.assertAlmostEqual(glyc.mass(), comp.mass(), 3)
frozen_comp = self.GlycanCompositionType.parse(comp)
self.assertAlmostEqual(glyc.mass(), frozen_comp.mass(), 3)
def test_derivatize(self):
glyc = glycans["N-Linked Core"]
composition_transform.derivatize(glyc, "methyl")
comp = GlycanComposition.from_glycan(glyc)
self.assertAlmostEqual(glyc.mass(), comp.mass(), 3)
comp = GlycanComposition.from_glycan(glycans["N-Linked Core"])
composition_transform.derivatize(comp, "methyl")
self.assertAlmostEqual(glyc.mass(), comp.mass(), 3)
def test_derivatize(self):
glyc = glycans["N-Linked Core"]
with self.assertRaises(glycan_composition.FrozenError):
composition_transform.derivatize(glyc, "methyl")
comp = self.GlycanCompositionType.from_glycan(glyc)
self.assertAlmostEqual(glyc.mass(), comp.mass(), 3)
comp = self.GlycanCompositionType.from_glycan(glycans["N-Linked Core"])
composition_transform.derivatize(comp, "methyl")
self.assertAlmostEqual(glyc.mass(), comp.mass(), 3)
self.assertAlmostEqual(self.GlycanCompositionType.parse(comp).mass(), comp.mass(), 3)
def test_validate_reducing_end(self):
structure = named_structures.monosaccharides['Hex']
composition = structure.total_composition()
structure.reducing_end = ReducedEnd()
self.assertEqual(structure.total_composition(), composition + Composition("H2"))
structure.reducing_end = True
self.assertEqual(structure.total_composition(), composition + Composition("H2"))
self.assertEqual(structure.total_composition(), structure.clone().total_composition())
self.assertEqual(structure.total_composition(), pickle.loads(pickle.dumps(structure)).total_composition())
structure.reducing_end = None
self.assertEqual(structure.total_composition(), composition)
structure.reducing_end = True
composition_transform.derivatize(structure, "methyl")
self.assertEqual(structure.mass(), structure.clone().mass())
def _process_composition(self):
gc, structure_classes = next(self.glycan_source)
if self.reduction is not None and gc.reducing_end is None:
gc.reducing_end = self.reduction.clone()
if self.derivatization is not None:
gc = composition_transform.derivatize(gc, self.derivatization)
return gc, structure_classes
def _process_composition(self):
gc, structure_classes = next(self.glycan_source)
if self.reduction is not None and gc.reducing_end is None:
gc.reducing_end = self.reduction.clone()
if self.derivatization is not None:
gc = composition_transform.derivatize(gc, self.derivatization)
return gc, structure_classes
def test_derivatized_glycan_parse(self):
ref = composition_transform.derivatize(
glypy.motifs["N-Glycan complex 1"], "methyl")
serializer = iupac.GlycanSerializer(iupac.DerivatizationAwareMonosaccharideSerializer())
text = serializer(ref)
deserializer = iupac.GlycanDeserializer(iupac.DerivatizationAwareMonosaccharideDeserializer())
obj = deserializer(text)
self.assertEqual(obj, ref)
def test_normalize_glycan_composition(self):
base = glycan_composition.GlycanComposition.parse("{Hex:6; HexNAc:5; Neu5Ac:3}")
deriv = composition_transform.derivatize(
glycan_composition.GlycanComposition.parse(
"{Hex:6; HexNAc:5; Neu5Ac:3}"), "methyl")
normd_symbol = symbolic_expression.GlycanSymbolContext(deriv)
normd_composition = glycan_composition.GlycanComposition.parse(normd_symbol.serialize())
self.assertEqual(base, normd_composition)
def test_normalize_glycan_composition(self):
base = glycan_composition.GlycanComposition.parse(
"{Hex:6; HexNAc:5; Neu5Ac:3}")
deriv = composition_transform.derivatize(
glycan_composition.GlycanComposition.parse(
"{Hex:6; HexNAc:5; Neu5Ac:3}"), "methyl")
normd_symbol = symbolic_expression.GlycanSymbolContext(deriv)
normd_composition = glycan_composition.GlycanComposition.parse(
normd_symbol.serialize())
self.assertEqual(base, normd_composition)
def test_derivatize(self):
reference = {"GlcNAc": 245.1263, "Fuc": 174.0892, "NeuAc": 361.1737}
for name in ["GlcNAc", "NeuAc", "Fuc"]:
base = monosaccharides[name]
residue = glycan_composition.MonosaccharideResidue.from_monosaccharide(base)
composition_transform.derivatize(base, "methyl")
composition_transform.derivatize(residue, "methyl")
self.assertAlmostEqual(
base.mass() - (water_mass + 2 * (Substituent("methyl").mass() - glypy.Composition("H").mass * 2)),
residue.mass(),
3,
)
self.assertAlmostEqual(reference[name], residue.mass(), 3)
base = monosaccharides[name]
composition_transform.derivatize(base, "methyl")
residue = glycan_composition.MonosaccharideResidue.from_monosaccharide(base)
self.assertAlmostEqual(
base.mass() - (water_mass + 2 * (Substituent("methyl").mass() - glypy.Composition("H").mass * 2)),
residue.mass(),
3,
)
self.assertAlmostEqual(reference[name], residue.mass(), 3)
def from_monosaccharide(cls, monosaccharide, configuration=False, stem=True, ring=False):
"""Construct an instance of :class:`MonosaccharideResidue` from an instance
of |Monosaccharide|. This function attempts to preserve derivatization if possible.
This function will create a *deep copy* of `monosaccharide`.
Parameters
----------
monosaccharide : Monosaccharide
The monosaccharide to be converted
configuration : bool, optional
Whether or not to preserve |Configuration|. Defaults to |False|
stem : bool, optional
Whether or not to preserve |Stem|. Defaults to |True|
ring : bool, optional
Whether or not to preserve |RingType|. Defaults to |False|
Returns
-------
MonosaccharideResidue
"""
residue = monosaccharide.clone(monosaccharide_type=cls)
premass = residue.mass()
deriv = has_derivatization(monosaccharide)
strip_derivatization(residue)
if _resolve_special_base_type(monosaccharide) is None:
if not configuration:
residue.configuration = (Configuration.x,)
if not stem:
residue.stem = (Stem.x,)
if not ring:
residue.ring_start = residue.ring_end = None
if deriv:
derivatize(residue, deriv)
if residue.mass() != premass and not deriv:
residue.composition += water_composition
return residue
def test_monosacchide_crossring(self):
test_cases = [
'Glc',
"GlcNAc",
"Xyl",
'GalA',
'Fuc',
'IdoA',
"KDN"
]
store = self.load_all()
for case in test_cases:
test = store[case]
target = monosaccharides[case]
for k, v in test.items():
target_d = {t.kind: t for t in crossring_fragments.crossring_fragments(target, k[0], k[1])}
target_d_permethylated = {t.kind: t for t in crossring_fragments.crossring_fragments(
composition_transform.derivatize(target.clone(), "methyl"), k[0], k[1])}
for kind in {"A", "X"}:
self.assertAlmostEqual(v[kind].mass, target_d[kind].mass(), 3)
self.assertAlmostEqual(v[kind].permethylated_mass, target_d_permethylated[kind].mass(), 3)
def test_is_derivatized(self):
broad = load("broad_n_glycan")
self.assertFalse(similarity.is_derivatized(broad.root))
composition_transform.derivatize(broad, 'methyl')
self.assertTrue(similarity.is_derivatized(broad.root))
def test_monosaccharide_serialize(self):
obj = composition_transform.derivatize(glypy.monosaccharides.HexNAc, 'methyl')
ref = '?-?-Hexp2NAc^Me'
serializer = iupac.DerivatizationAwareMonosaccharideSerializer()
text = serializer(obj)
self.assertEqual(text, ref)
def derivatized_mass(row, derivative):
return composition_transform.derivatize(row.structure, derivative).mass()
def test_derivatize_bare(self):
permethylated_reduced_mass = 1716.9033
glycan = load("common_glycan")
glycan.reducing_end = ReducedEnd()
composition_transform.derivatize(glycan, 'methyl')
self.assertAlmostEqual(glycan.mass(), permethylated_reduced_mass, 3)
def test_monosaccharide_parse(self):
text = '?-?-Hexp2NAc^Me'
parser = iupac.DerivatizationAwareMonosaccharideDeserializer()
obj, _ = parser(text)
ref = composition_transform.derivatize(glypy.monosaccharides.HexNAc, 'methyl')
self.assertEqual(obj, ref)
def derivatize(glycan_obj, derivatization_kind):
if derivatization_kind is not None:
composition_transform.derivatize(glycan_obj, derivatization_type[derivatization_kind])