def from_glycan(cls, glycan): inst = cls() glycan = tree(glycan) inst.extend(glycan) inst.reducing_end = glycan.reducing_end deriv = has_derivatization(glycan.root) if deriv: inst._composition_offset += ( deriv.total_composition() - deriv.attachment_composition_loss()) * 2 return inst
def _handle_reduction_and_derivatization(self, reduced): if reduced: reduced = ReducedEnd(Composition(reduced)) self.reducing_end = reduced deriv = None for key in self: deriv = has_derivatization(key) if deriv: break if deriv: # strip_derivatization(self) # derivatize(self, deriv) self._derivatized(deriv.clone(), make_counter(uid()), include_reducing_end=False)
def _format_map(mapping): store = dict() for key, value in dict(mapping).items(): if isinstance(key, SymbolNode): key = key.symbol elif isinstance(key, (str, _MR)): text_key = str(key) key = _FMR.from_iupac_lite(text_key) is_derivatized = composition_transform.has_derivatization(key) if is_derivatized: key = str(glycan_composition.from_iupac_lite.strip_derivatization(text_key)) else: key = text_key store[key] = value return store
def _format_map(mapping): store = dict() for key, value in dict(mapping).items(): if isinstance(key, SymbolNode): key = key.symbol elif isinstance(key, (str, _MR)): text_key = str(key) key = _FMR.from_iupac_lite(text_key) is_derivatized = composition_transform.has_derivatization(key) if is_derivatized: key = str( glycan_composition.from_iupac_lite. strip_derivatization(text_key)) else: key = text_key store[key] = value return store
def monosaccharide_to_iupac(self, residue): """ Encode a subset of traits of a :class:`Monosaccharide`-like object using a limited subset of the IUPAC three letter code. The information present is sufficient to reconstruct a :class:`MonosaccharideResidue` instance reflecting the base type and its native substituents and modificats. .. note:: This function is not suitable for use on whole |Glycan| objects. Instead, see :meth:`GlycanComposition.from_glycan` and :meth:`GlycanComposition.serialize` Parameters ---------- residue: Monosaccharide The object to be encoded Returns ------- str See Also -------- :func:`from_iupac_lite` """ template = "{modification}{base_type}{substituent}" modification = "" base_type = self.resolve_special_base_type(residue) if base_type is None: if len(residue.stem) == 1 and residue.stem[0] is not Stem.Unknown: base_type = residue.stem[0].name.title() else: base_type = residue.superclass.name.title() modification = self.modification_extractor(residue.modifications, base_type) substituent = self.substituent_resolver(residue) string = template.format( modification=modification, base_type=base_type, substituent=substituent ) deriv = has_derivatization(residue) if deriv: string = "%s^%s" % (string, self.substituent_resolver.serialize_substituent(deriv)) return string
def from_glycan(cls, glycan): """ Convert a |Glycan| into a |GlycanComposition|. Parameters ---------- glycan : Glycan The instance to be converted Returns ------- GlycanComposition """ inst = cls() glycan = tree(glycan) inst.extend(glycan) inst.reducing_end = glycan.reducing_end deriv = has_derivatization(glycan.root) if deriv: inst._composition_offset += ( deriv.total_composition() - deriv.attachment_composition_loss()) * 2 return inst
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 monosaccharide_to_iupac(self, residue): string = super(DerivatizationAwareMonosaccharideSerializer, self).monosaccharide_to_iupac(residue) deriv = has_derivatization(residue) if deriv: string = "%s^%s" % (string, self.substituent_resolver.serialize_substituent(deriv)) return string