def testInitCopy(self):
self.list.append(Object("test2"))
copied = DictList(self.list)
self.assertIsNot(self.list, copied)
self.assertIsInstance(copied, self.list.__class__)
self.assertEqual(len(self.list), len(copied))
for i, v in enumerate(self.list):
self.assertEqual(self.list[i].id, copied[i].id)
self.assertEqual(i, copied.index(v.id))
self.assertIs(self.list[i], copied[i])
self.assertIs(v, copied.get_by_id(v.id))
def test_init_copy(self, dict_list):
obj, test_list = dict_list
test_list.append(Object("test2"))
copied = DictList(test_list)
assert test_list is not copied
assert isinstance(copied, test_list.__class__)
assert len(test_list) == len(copied)
for i, v in enumerate(test_list):
assert test_list[i].id == copied[i].id
assert i == copied.index(v.id)
assert test_list[i] is copied[i]
assert v is copied.get_by_id(v.id)
def testRemoval(self):
obj_list = DictList(Object("test%d" % (i)) for i in range(2, 10))
del obj_list[3]
self.assertNotIn("test5", obj_list)
self.assertEqual(obj_list.index(obj_list[-1]), len(obj_list) - 1)
del obj_list[3:5]
self.assertNotIn("test6", obj_list)
self.assertNotIn("test7", obj_list)
self.assertEqual(obj_list.index(obj_list[-1]), len(obj_list) - 1)
removed = obj_list.pop(1)
self.assertEqual(obj_list.index(obj_list[-1]), len(obj_list) - 1)
self.assertEqual(removed.id, "test3")
self.assertNotIn("test3", obj_list)
def testSet(self):
obj_list = DictList(Object("test%d" % (i)) for i in range(10))
obj_list[4] = Object("testa")
self.assertEqual(obj_list.index("testa"), 4)
self.assertEqual(obj_list[4].id, "testa")
obj_list[5:7] = [Object("testb"), Object("testc")]
self.assertEqual(obj_list.index("testb"), 5)
self.assertEqual(obj_list[5].id, "testb")
self.assertEqual(obj_list.index("testc"), 6)
self.assertEqual(obj_list[6].id, "testc")
# Even if the object is unique, if it is present twice in the new
# list, it should still raise an exception
self.assertRaises(ValueError, obj_list.__setitem__, slice(5, 7),
[Object("testd"), Object("testd")])
def _build_targets(self):
targets = DictList()
for reaction in self.reactions:
reaction = self._replace_adapted_metabolites(reaction)
targets.append(ReactionKnockinTarget(reaction.id, reaction))
for reaction in self.exchanges:
reaction = self._replace_adapted_metabolites(reaction)
targets.append(ReactionKnockinTarget(reaction.id, reaction))
product = self._replace_adapted_metabolites(self.product)
product.lower_bound = 0
targets.append(ReactionKnockinTarget(product.id, product))
return targets
def test_set(self):
obj_list = DictList(Object("test%d" % (i)) for i in range(10))
obj_list[4] = Object("testa")
assert obj_list.index("testa") == 4
assert obj_list[4].id == "testa"
obj_list[5:7] = [Object("testb"), Object("testc")]
assert obj_list.index("testb") == 5
assert obj_list[5].id == "testb"
assert obj_list.index("testc") == 6
assert obj_list[6].id == "testc"
# Even if the object is unique, if it is present twice in the new
# list, it should still raise an exception
with pytest.raises(ValueError):
obj_list.__setitem__(slice(
5, 7), [Object("testd"), Object("testd")])
def __init__(self, *args):
Model.__init__(self, *args)
self.global_info = {}
self.process_data = DictList()
# create the biomass/dilution constraint
self._biomass = Constraint("biomass")
self._biomass_dilution = SummaryVariable("biomass_dilution")
self._biomass_dilution.add_metabolites({self._biomass: -1})
self.add_reactions([self._biomass_dilution])
self._biomass_dilution.upper_bound = mu
self._biomass_dilution.lower_bound = mu
# maintenance energy
self._gam = 0.
self._ngam = 0.
# Unmodeled protein is handled by converting protein_biomass to
# biomass, and requiring production of the appropriate amount of dummy
# protein
self._unmodeled_protein_fraction = None
def __iadd__(self, other):
targets = {}
for target in self.targets:
if target.id not in targets:
targets[target.id] = []
targets[target.id].append(target)
for target in other.targets:
if target.id not in targets:
targets[target.id] = []
targets[target.id].append(target)
targets = [
t[0] if len(t) == 1 else EnsembleTarget(id, t)
for id, t in six.iteritems(targets)
]
self.targets = DictList(targets)
return self
def __iadd__(self, other):
if not isinstance(other, StrainDesign):
raise AssertionError("Only instances of StrainDesign can be added together")
targets = {}
for target in self.targets:
if target.id not in targets:
targets[target.id] = set()
targets[target.id].add(target)
for target in other.targets:
if target.id not in targets:
targets[target.id] = set()
targets[target.id].add(target)
targets = [next(iter(t)) if len(t) == 1 else EnsembleTarget(id, t) for id, t in six.iteritems(targets)]
self.targets = DictList(targets)
return self
def test_removal(self):
obj_list = DictList(Object("test%d" % (i)) for i in range(2, 10))
del obj_list[3]
assert "test5" not in obj_list
assert obj_list.index(obj_list[-1]) == len(obj_list) - 1
assert len(obj_list) == 7
del obj_list[3:5]
assert "test6" not in obj_list
assert "test7" not in obj_list
assert obj_list.index(obj_list[-1]) == len(obj_list) - 1
assert len(obj_list) == 5
removed = obj_list.pop(1)
assert obj_list.index(obj_list[-1]) == len(obj_list) - 1
assert removed.id == "test3"
assert "test3" not in obj_list
assert len(obj_list) == 4
removed = obj_list.pop()
assert removed.id == "test9"
assert removed.id not in obj_list
assert len(obj_list) == 3
def _build_targets(self):
targets = DictList()
for reaction in self.reactions:
reaction = self._replace_adapted_metabolites(reaction)
if reaction.id in metanetx.mnx2all:
target = ReactionKnockinTarget(reaction.id,
reaction,
accession_id=reaction.id,
accession_db='metanetx')
else:
target = ReactionKnockinTarget(reaction.id, reaction)
targets.append(target)
for reaction in self.exchanges:
reaction = self._replace_adapted_metabolites(reaction)
targets.append(ReactionKnockinTarget(reaction.id, reaction))
product = self._replace_adapted_metabolites(self.product)
product.lower_bound = 0
targets.append(ReactionKnockinTarget(product.id, product))
return targets
def __init__(self, enzymes = None, scaled = False, *args, **kwargs):
ExpressionReaction.__init__(self, scaled, *args, **kwargs)
self.enzymes = DictList()
if enzymes:
self.add_enzymes(enzymes)
def setUp(self):
self.obj = Object("test1")
self.list = DictList()
self.list.append(self.obj)
def create_metanetx_universal_model(validate=False, verbose=False):
""" Create an universal model from MetaNetX universal reactions and metabolites.
The MetaNetX metabolite list is very large and includes metabolites that are
not used in any reaction. The returned model only includes metabolites that
are actually used in a reaction.
Parameters
----------
validate : bool, optional
When True, perform validity checks on universal COBRA model
verbose : bool, optional
When True, show warning messages
Returns
-------
cobra.Model
COBRA model object with universal reactions and metabolites
"""
# Create an empty model.
universal = Model('metanetx_universal', name='MetaNetX universal model')
# Download the metabolites file.
metabolite_list = _download_metanetx_file('chem_prop.tsv')
# Map field names to column numbers (MetaNetX may add fields in future).
field_names = {
'MNX_ID': 0,
'Description': 1,
'Formula': 2,
'Charge': 3,
'Mass': 4,
'InChI': 5,
'SMILES': 6,
'Source': 7,
'InChIKey': 8
}
# Accumulate all available Metabolite objects separately. Later when creating
# reactions, metabolites are put in a compartment.
all_metabolites = DictList()
# Create Metabolite objects for all of the metabolites from the downloaded file.
# Add all of the universal metabolites from the list.
LOGGER.info('Started creating Metabolite objects from %d lines in file',
len(metabolite_list))
for index in range(len(metabolite_list)):
if len(metabolite_list[index]
) == 0 or metabolite_list[index][0] == '#':
continue # Skip empty lines and comment lines
fields = metabolite_list[index].split('\t')
if len(fields) < len(field_names):
if verbose:
warn('Skipped metabolite on line {0} with missing fields: {1}'.
format(index, metabolite_list[index]))
continue
# Create cobra.core.Metabolite from MetaNetX metabolite.
metabolite = Metabolite(id=fields[field_names['MNX_ID']],
name=fields[field_names['Description']],
formula=fields[field_names['Formula']])
charge = fields[field_names['Charge']]
metabolite.charge = int(
charge) if len(charge) > 0 and charge != 'NA' else None
mass = fields[field_names['Mass']]
if len(mass) > 0:
metabolite.notes['mass'] = float(mass)
metabolite.notes['InChI'] = fields[field_names['InChI']] \
if len(fields[field_names['InChI']]) > 0 else 'NA'
metabolite.notes['SMILES'] = fields[field_names['SMILES']] \
if len(fields[field_names['SMILES']]) > 0 else 'NA'
metabolite.notes['source'] = fields[field_names['Source']] \
if len(fields[field_names['Source']]) > 0 else 'NA'
metabolite.notes['InChIKey'] = fields[field_names['InChIKey']] \
if len(fields[field_names['InChIKey']]) > 0 else 'NA'
all_metabolites.append(metabolite)
LOGGER.info('Finished creating %d Metabolite objects',
len(all_metabolites))
# Download the compartments file.
compartment_list = _download_metanetx_file('comp_prop.tsv')
# Map field names to column numbers (MetaNetX may add fields in future).
field_names = {'MNX_ID': 0, 'Description': 1, 'Source': 2}
# Add the compartments to the universal model.
LOGGER.info('Started adding compartments from %d lines in file',
len(compartment_list))
for index in range(len(compartment_list)):
if len(compartment_list[index]
) == 0 or compartment_list[index][0] == '#':
continue # Skip empty lines and comment lines
fields = compartment_list[index].split('\t')
if len(fields) < len(field_names):
if verbose:
warn(
'Skipped compartment on line {0} with missing fields: {1}'.
format(index, compartment_list[index]))
continue
universal.compartments[fields[field_names['MNX_ID']]] = fields[
field_names['Description']]
LOGGER.info('Finished adding {0} compartments to universal model'.format(
len(universal.compartments)))
# Download the reactions file.
reaction_list = _download_metanetx_file('reac_prop.tsv')
# Map field names to column numbers (hopefully MetaNetX doesn't change this).
field_names = {
'MNX_ID': 0,
'Equation': 1,
'Description': 2,
'Balance': 3,
'EC': 4,
'Source': 5
}
# Accumulate Reaction and Metabolite objects separately because it is faster
# than adding them one at a time to a model.
reactions = DictList()
metabolites = DictList()
# Create Reaction objects for all of the reactions from the downloaded file.
LOGGER.info('Started creating Reaction objects from %d lines in file',
len(reaction_list))
for index in range(len(reaction_list)):
if len(reaction_list[index]) == 0 or reaction_list[index][0] == '#':
continue # Skip empty lines and comment lines
fields = reaction_list[index].split('\t')
if len(fields) != len(field_names):
if verbose:
warn('Skipped reaction on line {0} with missing fields: {1}'.
format(index, reaction_list[index]))
continue
# Create cobra.core.Reaction from MetaNetX reaction.
metabolite_info = _parse_metanetx_equation(
fields[field_names['Equation']])
if metabolite_info is None:
if verbose:
warn(
'Could not parse equation for reaction {0} on line {1}: {2}'
.format(fields[field_names['MNX_ID']], index,
fields[field_names['Equation']]))
continue
rxn_mets = dict()
for metabolite_id in metabolite_info:
try:
rxn_mets[metabolites.get_by_id(
metabolite_id
)] = metabolite_info[metabolite_id]['coefficient']
except KeyError:
metabolite = all_metabolites.get_by_id(
metabolite_info[metabolite_id]['mnx_id']).copy()
metabolite.id = metabolite_id
metabolite.compartment = metabolite_info[metabolite_id][
'compartment']
metabolites.append(metabolite)
rxn_mets[metabolite] = metabolite_info[metabolite_id][
'coefficient']
reaction = Reaction(id=fields[field_names['MNX_ID']],
name=fields[field_names['MNX_ID']],
lower_bound=-1000.0,
upper_bound=1000.0)
reaction.add_metabolites(rxn_mets)
if len(fields[field_names['EC']]) > 0:
reaction.notes['EC_number'] = fields[field_names['EC']]
if len(fields[field_names['Source']]) > 1:
parts = fields[field_names['Source']].split(':')
if len(parts) == 2:
reaction.notes['aliases'] = {parts[0]: parts[1]}
else:
if verbose:
warn('Could not parse source for {0}: {1}'.format(
fields[field_names['MNX_ID']],
fields[field_names['Source']]))
reactions.append(reaction)
LOGGER.info('Finished creating %d Reaction objects', len(reactions))
# Add the reactions to the universal model.
universal.add_reactions(reactions)
LOGGER.info('Finished adding Reaction objects to universal model')
# If requested, validate the COBRA model.
if validate:
warn('Coming soon')
return universal
def dict_list():
obj = Object("test1")
test_list = DictList()
test_list.append(obj)
return obj, test_list
def __init__(self, *args):
Model.__init__(self, *args)
self.global_info = {}
self.stoichiometric_data = DictList()
self.complex_data = DictList()
self.modification_data = DictList()
self.translation_data = DictList()
self.transcription_data = DictList()
self.generic_data = DictList()
self.tRNA_data = DictList()
self.translocation_data = DictList()
self.posttranslation_data = DictList()
self.subreaction_data = DictList()
self.process_data = DictList()
# create the biomass/dilution constraint
self._biomass = Constraint("biomass")
self._biomass_dilution = SummaryVariable("biomass_dilution")
self._biomass_dilution.add_metabolites({self._biomass: -1})
self.add_reaction(self._biomass_dilution)
self._biomass_dilution.upper_bound = mu
self._biomass_dilution.lower_bound = mu
# maintenance energy
self._gam = 0.
self._ngam = 0.
# Unmodeled protein is handled by converting protein_biomass to
# biomass, and requiring production of the appropriate amount of dummy
# protein
self._unmodeled_protein_fraction = None
self._protein_biomass = Constraint("protein_biomass")
self._protein_biomass_dilution = SummaryVariable(
"protein_biomass_dilution")
self._protein_biomass_dilution.add_metabolites({
self._protein_biomass:
-1,
self._biomass:
1,
})
self._mRNA_biomass = Constraint("mRNA_biomass")
self._mRNA_biomass_dilution = SummaryVariable("mRNA_biomass_dilution")
self._mRNA_biomass_dilution.add_metabolites({
self._mRNA_biomass: -1,
self._biomass: 1,
})
self._tRNA_biomass = Constraint("tRNA_biomass")
self._tRNA_biomass_dilution = SummaryVariable("tRNA_biomass_dilution")
self._tRNA_biomass_dilution.add_metabolites({
self._tRNA_biomass: -1,
self._biomass: 1,
})
self._rRNA_biomass = Constraint("rRNA_biomass")
self._rRNA_biomass_dilution = SummaryVariable("rRNA_biomass_dilution")
self._rRNA_biomass_dilution.add_metabolites({
self._rRNA_biomass: -1,
self._biomass: 1,
})
self._ncRNA_biomass = Constraint("ncRNA_biomass")
self._ncRNA_biomass_dilution = SummaryVariable(
"ncRNA_biomass_dilution")
self._ncRNA_biomass_dilution.add_metabolites({
self._ncRNA_biomass: -1,
self._biomass: 1,
})
self._DNA_biomass = Constraint("DNA_biomass")
self._DNA_biomass_dilution = SummaryVariable("DNA_biomass_dilution")
self._DNA_biomass_dilution.add_metabolites({
self._DNA_biomass: -1,
self._biomass: 1,
})
self.add_reactions(
(self._protein_biomass_dilution, self._mRNA_biomass_dilution,
self._tRNA_biomass_dilution, self._rRNA_biomass_dilution,
self._ncRNA_biomass_dilution, self._DNA_biomass_dilution))
def __init__(self, targets):
self.targets = DictList(targets)
