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)