def __init__(self, composition, obj=None):
if isinstance(composition, basestring):
composition = FrozenGlycanComposition.parse(composition)
if obj is None:
obj = composition
self.composition = composition
self.obj = obj
def __init__(self, composition, obj=None):
if isinstance(composition, basestring):
composition = FrozenGlycanComposition.parse(composition)
if obj is None:
obj = composition
self.composition = composition
self.obj = obj
def monosaccharide_bounds(self):
from .glycan import GlycanComposition
bounds = Counter()
session = object_session(self)
for composition, in session.query(GlycanComposition.composition.distinct()).filter(
GlycanComposition.hypothesis_id == self.id):
composition = FrozenGlycanComposition.parse(composition)
for residue, count in composition.items():
bounds[residue] = max(bounds[residue], count)
return {str(k): int(v) for k, v in bounds.items()}
def monosaccharide_bounds(self):
from .glycan import GlycanComposition
bounds = Counter()
session = object_session(self)
for composition, in session.query(
GlycanComposition.composition.distinct()).filter(
GlycanComposition.hypothesis_id == self.id):
composition = FrozenGlycanComposition.parse(composition)
for residue, count in composition.items():
bounds[residue] = max(bounds[residue], count)
return {str(k): int(v) for k, v in bounds.items()}
def glycan_composition_permutations(glycan_composition, constant_modifications=None, variable_modifications=None):
if constant_modifications is None:
constant_modifications = []
if variable_modifications is None:
variable_modifications = []
glycan_composition = FrozenGlycanComposition(
get_glycan_composition(glycan_composition))
final_composition = FrozenGlycanComposition()
temporary_composition = FrozenGlycanComposition()
sequence = linearize_composition(glycan_composition)
if not constant_modifications:
temporary_composition = glycan_composition.clone()
has_constant_reduction = False
else:
constant_modifications, constant_reduction = split_reduction_and_modification_rules(
constant_modifications)
for rule in constant_modifications:
extracted = rule.find_valid_sites(sequence)
for i, mr in enumerate(sequence):
if i in extracted:
final_composition[mr] += 1
final_composition[rule.modifier] += 1
else:
temporary_composition[mr] += 1
sequence = linearize_composition(temporary_composition)
if constant_reduction:
has_constant_reduction = True
constant_reduction[0].apply(temporary_composition)
variable_modifications, variable_reduction = split_reduction_and_modification_rules(
variable_modifications)
mod_site_map = {
rule: rule.find_valid_sites(sequence) for rule in variable_modifications
}
assignments_generator = site_modification_assigner(
modification_series(mod_site_map))
for assignments in simplify_assignments(assignments_generator):
result = temporary_composition.clone()
for mod, count in assignments:
mod.apply(result, count)
result += final_composition
if glycan_composition.reducing_end is not None:
result.reducing_end = glycan_composition.reducing_end.clone()
yield result
if not has_constant_reduction:
for rule in variable_reduction:
yield rule.apply(result.clone())
def merge_compositions_frozen(composition_list):
"""Given a list of monosaccharide packed strings,
sum the monosaccharide counts across lists and return
the merged string
Parameters
----------
composition_list : list of GlycanCompositionRecord
Returns
-------
FrozenGlycanComposition
"""
first = FrozenGlycanComposition()
for comp_rec in composition_list:
first += comp_rec.composition
return first
def parse_glycan_formula(glycan_formula):
gc = FrozenGlycanComposition()
if glycan_formula.startswith("\""):
glycan_formula = glycan_formula[1:-1]
for mono, count in re.findall(r"([^0-9]+)\((\d+)\)", glycan_formula):
count = int(count)
if mono in substituent_map:
parsed = SubstituentResidue(substituent_map[mono])
elif mono in ("Sia", ):
continue
elif mono in ("Pent", ):
mono = "Pen"
parsed = FrozenMonosaccharideResidue.from_iupac_lite(mono)
elif mono == 'Xxx':
continue
elif mono == 'X':
continue
else:
parsed = FrozenMonosaccharideResidue.from_iupac_lite(mono)
gc[parsed] += count
return gc
def convert(self):
gc = FrozenGlycanComposition.parse(self.glycan_composition_string)
gc.id = self.id
gc.count = self.count
return gc
def _copy_glycan_composition(self):
return FrozenGlycanComposition(self.target.glycan_composition)
def convert(self):
gc = FrozenGlycanComposition.parse(self.glycan_composition_string)
gc.id = self.id
gc.count = self.count
return gc