def drop_positions(residue):
    if _resolve_special_base_type(residue) is None:
        modifications = OrderedMultiMap()
        for k, v in residue.modifications.items():
            modifications[-1] = v
        residue.modifications = modifications

        for p, link in list(residue.substituent_links.items()):
            link.break_link(refund=True)
            link.parent_position = -1
            link.apply()
Пример #2
0
def to_iupac_lite(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`
    """
    if isinstance(residue, (SubstituentResidue, MolecularComposition)):
        return residue.to_iupac_lite()

    template = "{modification}{base_type}{substituent}"
    modification = ""
    base_type = _resolve_special_base_type(residue)
    if base_type is None:
        if residue.stem[0] is not Stem.Unknown:
            base_type = residue.stem[0].name.title()
        else:
            base_type = residue.superclass.name.title()

    # Omit unknown coordinates on modifications and substituents
    modification = extract_modifications(residue.modifications, base_type).replace("-1-", "")
    substituent = resolve_substituent(residue).replace("-1", "")
    return template.format(
        modification=modification,
        base_type=base_type,
        substituent=substituent
        )
    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 drop_configuration(residue):
    if _resolve_special_base_type(residue) is None:
        residue.configuration = (None,)
def drop_stem(residue):
    if _resolve_special_base_type(residue) is None:
        residue.stem = (None,)