def test_load_kinetic_laws_with_same_reaction(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
src.load_kinetic_laws([16011, 16013, 16016])
session = src.session
l = session.query(KineticLaw).filter_by(id=16011).first()
self.assertEqual(
next(xr.id for xr in l.cross_references
if xr.namespace == 'sabiork.reaction'), '9886')
l = session.query(KineticLaw).filter_by(id=16013).first()
self.assertEqual(
next(xr.id for xr in l.cross_references
if xr.namespace == 'sabiork.reaction'), '9886')
l = session.query(KineticLaw).filter_by(id=16016).first()
self.assertEqual(
next(xr.id for xr in l.cross_references
if xr.namespace == 'sabiork.reaction'), '9930')
r = session.query(Resource).filter_by(namespace='sabiork.reaction',
id='9886').first()
self.assertEqual(set([l.id for l in r.entries]), set([16011, 16013]))
r = session.query(Resource).filter_by(namespace='sabiork.reaction',
id='9930').first()
self.assertEqual([l.id for l in r.entries], [16016])
def test_update_all_and_backup(self):
src = sabio_rk.SabioRk(download_backups=False,
load_content=True,
clear_content=True,
verbose=True,
clear_requests_cache=False,
max_entries=float('inf'))
self.assertGreaterEqual(src.session.query(KineticLaw).count(), 55000)
src.upload_backups()
def test_load_kinetic_laws_modifier_type(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
src.load_kinetic_laws([10054])
session = src.session
l = session.query(KineticLaw).filter_by(id=10054).first()
self.assertEqual(l.enzyme_type, 'Modifier-Catalyst')
def test_load_content_commit_intermediate_results(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=True,
max_entries=9,
commit_intermediate_results=True,
webservice_batch_size=1,
excel_batch_size=3,
verbose=True)
self.assertEqual(
src.session.query(KineticLaw).count(), src.max_entries)
def test_load_kinetic_law_ids(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
max_entries=10,
webservice_batch_size=1,
excel_batch_size=5,
verbose=True)
ids = src.load_kinetic_law_ids()
self.assertEqual(ids[0:10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
self.assertGreater(len(ids), 55000)
def test_full_kinetic_laws(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
session = src.session
src.load_kinetic_laws([23637])
src.load_compounds()
src.load_missing_kinetic_law_information_from_tsv([23637])
law = session.query(KineticLaw).filter_by(id=23637).first()
self.assertEqual(law.equation, 'V * S / (Km + S + S^2 / Ki)')
def test_load_content(self):
# get some kinetic laws
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=True,
max_entries=9,
webservice_batch_size=1,
excel_batch_size=3,
verbose=True)
self.assertTrue(os.path.isfile(src.filename))
self.assertEqual(
src.session.query(KineticLaw).count(), src.max_entries)
# get some more
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=True,
max_entries=18,
webservice_batch_size=1,
excel_batch_size=3,
verbose=True)
self.assertTrue(os.path.isfile(src.filename))
self.assertEqual(
src.session.query(KineticLaw).count(), src.max_entries)
def test_load_kinetic_laws_multiple(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
session = src.session
ids = [2, 10026]
src.load_kinetic_laws(ids)
src.load_compounds()
src.load_missing_kinetic_law_information_from_tsv(ids)
src.normalize_kinetic_laws(ids)
""" compartments """
self.assertEqual(
session.query(Compartment).filter_by(name='Cell').count(), 0)
cytosol = session.query(Compartment).filter_by(name='cytosol').first()
""" reactions """
l = session.query(KineticLaw).filter_by(id=10026).first()
for part in l.reactants:
self.assertEqual(part.compartment, cytosol)
for part in l.products:
self.assertEqual(part.compartment, cytosol)
""" kinetic laws """
l = session.query(KineticLaw).filter_by(id=2).first()
self.assertEqual(l.enzyme_compartment, None)
self.assertEqual(l.tissue, None)
self.assertEqual(l.mechanism, None)
self.assertFalse(l.taxon_wildtype)
self.assertEqual(l.taxon_variant,
'S156E of subtilisin DSAI (N76D/N87S/S103A/V104I)')
self.assertEqual(l.equation, None)
self.assertEqual(l.media, '50 mM potassium phosphate, 4 % DMSO')
l = session.query(KineticLaw).filter_by(id=10026).first()
self.assertEqual(l.enzyme_compartment, cytosol)
self.assertEqual(l.tissue, 'epidermal cell')
self.assertEqual(l.mechanism, 'Michaelis-Menten')
self.assertTrue(l.taxon_wildtype)
self.assertEqual(l.taxon_variant, '')
self.assertEqual(l.equation, 'Vmax * A / (Km + A)')
self.assertTrue(l.media.startswith('1.25 mM CaCl2'))
self.assertTrue(l.media.endswith('10 units/ml calmodulin'))
for param in l.parameters:
if param.compound:
self.assertEqual(param.compartment, cytosol)
def test_enzyme_parameter(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
session = src.session
src.load_kinetic_laws([213])
src.load_compounds()
src.load_missing_kinetic_law_information_from_tsv([213])
law = session.query(KineticLaw).filter_by(id=213).first()
params = list(
filter(lambda param: isinstance(param.enzyme, sabio_rk.Enzyme),
law.parameters))
self.assertEqual(len(params), 1)
self.assertEqual(params[0].enzyme.id, 1000)
self.assertEqual(params[0].enzyme.name, 'inorganic diphosphatase')
def test_load_missing_kinetic_law_information_from_tsv_error_2(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
session = src.session
src.load_kinetic_laws([443])
src.load_compounds()
src.load_missing_kinetic_law_information_from_tsv([443])
p = session.query(Parameter).filter_by(observed_name='kcat1').first()
self.assertEqual(p.observed_value, 28.3333333)
self.assertEqual(p.observed_error, 1.66667)
self.assertEqual(p.observed_units, 's^(-1)')
p = session.query(Parameter).filter_by(observed_name='kcat2').first()
self.assertEqual(p.observed_value, 27.6666667)
self.assertEqual(p.observed_error, 0.5)
self.assertEqual(p.observed_units, 's^(-1)')
def test_load_missing_kinetic_law_information_from_tsv_error_1(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
session = src.session
src.load_kinetic_laws([3962])
src.load_compounds()
src.load_missing_kinetic_law_information_from_tsv([3962])
p = session.query(Parameter).filter_by(observed_name='kcat').first()
self.assertEqual(p.observed_value, 0.9)
self.assertEqual(p.observed_error, 0.6)
self.assertEqual(p.observed_units, 's^(-1)')
p = session.query(Parameter).filter_by(
observed_name='app_kcat_MEP').first()
self.assertEqual(p.observed_value, 0.54)
self.assertEqual(p.observed_error, 0.36)
self.assertEqual(p.observed_units, 's^(-1)')
def test_load_kinetic_laws_with_opposite_directions_of_same_reaction(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False)
src.load_kinetic_laws([46425, 46427])
session = src.session
Lactaldehyde = session.query(Compound).filter_by(id=2845).first()
l = session.query(KineticLaw).filter_by(id=46425).first()
self.assertEqual(
next(xr.id for xr in l.cross_references
if xr.namespace == 'sabiork.reaction'), '554')
self.assertIn(Lactaldehyde, [p.compound for p in l.reactants])
self.assertNotIn(Lactaldehyde, [p.compound for p in l.products])
l = session.query(KineticLaw).filter_by(id=46427).first()
self.assertEqual(
next(xr.id for xr in l.cross_references
if xr.namespace == 'sabiork.reaction'), '554')
self.assertNotIn(Lactaldehyde, [p.compound for p in l.reactants])
self.assertIn(Lactaldehyde, [p.compound for p in l.products])
def test_normalize_parameter_value(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
self.assertEqual(
src.normalize_parameter_value('k_d', 282, 0.25, 0.15, None, None),
(None, None, None, None, None))
self.assertEqual(
src.normalize_parameter_value('k_cat', 25, None, None, 's^(-1)',
None),
(None, None, None, None, None))
self.assertEqual(
src.normalize_parameter_value('k_cat', 25, 0.25, 0.15, None, None),
(None, None, None, None, None))
self.assertEqual(
src.normalize_parameter_value('k_cat', 25, 0.25, 0.15, 's^(-1)',
None),
('k_cat', 25, 0.25, 0.15, 's^(-1)'))
self.assertEqual(
src.normalize_parameter_value('k_cat', 25, 0.25, 0.15,
'katal_base', None),
(None, None, None, None, None))
self.assertEqual(
src.normalize_parameter_value('k_cat', 25, 0.25, None,
'katal_base', None),
(None, None, None, None, None))
self.assertEqual(
src.normalize_parameter_value('k_cat', 25, 0.25, None,
'mol*s^(-1)*g^(-1)', None),
(None, None, None, None, None))
self.assertEqual(
src.normalize_parameter_value('v_max', 186, 0.25, None, None, 500),
(None, None, None, None, None))
self.assertEqual(
src.normalize_parameter_value('v_max', 186, 0.25, None,
'mol*s^(-1)*g^(-1)', 500),
('k_cat', 25, 0.25 * 500, None, 's^(-1)'))
self.assertEqual(
src.normalize_parameter_value('v_max', 186, 0.25, None,
'mol*s^(-1)*g^(-1)', None),
('v_max', 186, 0.25, None, 'mol*s^(-1)*g^(-1)'))
self.assertEqual(
src.normalize_parameter_value('v_max', 186, 0.25, 0.15,
'mol*s^(-1)*g^(-1)', 500),
('k_cat', 25, 0.25 * 500, 0.15 * 500, 's^(-1)'))
self.assertEqual(
src.normalize_parameter_value('v_max', 186, 0.25, 0.15,
'mol*s^(-1)*g^(-1)', None),
('v_max', 186, 0.25, 0.15, 'mol*s^(-1)*g^(-1)'))
self.assertEqual(
src.normalize_parameter_value('v_max', 186, 0.25, None, 's^(-1)',
500),
('k_cat', 25, 0.25, None, 's^(-1)'))
self.assertEqual(
src.normalize_parameter_value('v_max', 186, 0.25, None, 's^(-1)',
None),
('k_cat', 25, 0.25, None, 's^(-1)'))
self.assertRaises(ValueError, src.normalize_parameter_value, 'k_cat',
25, 0.25, 0.15, 'm', None)
def test_load_kinetic_laws_check_units(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
session = src.session
src.load_kinetic_laws([2023])
src.load_compounds()
src.load_missing_kinetic_law_information_from_tsv([2023])
src.normalize_kinetic_laws([2023])
law = session.query(KineticLaw).filter_by(id=2023).first()
self.assertEqual(len(law.parameters), 4)
param = next(param for param in law.parameters
if param.observed_type == 25)
self.assertEqual(param.observed_name, 'kcat')
self.assertEqual(param.observed_value, 0.329)
self.assertEqual(param.observed_error, None)
self.assertEqual(param.observed_units, 's^(-1)')
self.assertEqual(param.name, 'k_cat')
self.assertEqual(param.type, 25)
self.assertEqual(param.value, 0.329)
self.assertEqual(param.error, None)
self.assertEqual(param.units, 's^(-1)')
param = next(param for param in law.parameters
if param.observed_type == 27)
self.assertEqual(param.observed_name, 'Km')
self.assertEqual(param.observed_value, 0.232)
self.assertEqual(param.observed_error, None)
self.assertEqual(param.observed_units, 'mg/ml')
self.assertEqual(param.name, None)
self.assertEqual(param.type, None)
self.assertEqual(param.value, None)
self.assertEqual(param.error, None)
self.assertEqual(param.units, None)
param = next(param for param in law.parameters
if param.observed_type == 261)
self.assertEqual(param.observed_name, 'Ki')
self.assertEqual(param.observed_value, 2.4E-9)
self.assertEqual(param.observed_error, None)
self.assertEqual(param.observed_units, 'M')
self.assertEqual(param.name, 'k_i')
self.assertEqual(param.type, 261)
self.assertEqual(param.value, 2.4E-9)
self.assertEqual(param.error, None)
self.assertEqual(param.units, 'M')
param = next(param for param in law.parameters
if param.observed_type == 302)
self.assertEqual(param.observed_name, 'kcat/Km')
self.assertEqual(param.observed_value, 1.42)
self.assertEqual(param.observed_error, None)
self.assertEqual(param.observed_units, 'l*g^(-1)*s^(-1)')
self.assertEqual(param.name, None)
self.assertEqual(param.type, None)
self.assertEqual(param.value, None)
self.assertEqual(param.error, None)
self.assertEqual(param.units, None)
def test_loading_enzymes(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=True,
verbose=True)
ids = [11021, 2139, 1645]
src.load_kinetic_laws(ids)
src.load_compounds()
src.load_missing_kinetic_law_information_from_tsv(ids)
src.load_missing_enzyme_information_from_html(ids)
src.calc_enzyme_molecular_weights(src.session.query(Enzyme).all())
src.normalize_kinetic_laws(ids)
# 11021, one subunit
law = src.session.query(KineticLaw).filter_by(id=11021).first()
self.assertEqual(len(law.enzyme.subunits), 1)
self.assertEqual(len(law.enzyme.subunits[0].cross_references), 1)
self.assertEqual(law.enzyme.subunits[0].cross_references[0].namespace,
'uniprot')
self.assertEqual(law.enzyme.subunits[0].cross_references[0].id,
'P19631')
self.assertEqual(law.enzyme.subunits[0].coefficient, 2)
self.assertEqual(
law.enzyme.subunits[0].sequence,
('STAGKVIKCKAAVLWEANKPFSLEEVEVAPPKAHEVRIKIVATGICRSDDHVVTGALAMP'
'FPVILGHEAAGVVESVGEKVTLLKPGDAVIPLFVPQCGECRSCLSTKGNLCIKNDLSSSP'
'TGLMADGTTRFTCKGKAIHHFIGTSTFTEYTVVHETAAAKIDSAAPLEKVCLIGCGFSTG'
'YGAVLQTAKVEPGSTCAVFGLGGVGLSVVMGCKAAGASRIIAIDINKDKFAKAKELGATE'
'CVNPKDFKKPIHEVLTEMTGKGVDYSFEVIGRIETMTEALASCHYNYGVSVIVGVPPAAQ'
'KISFDPMLIFSGRTWKGSVFGGWKSKDAVPKLVADYMKKKFVLDPLITHTLPFTKINEGF'
'DLLRTGKSIRTVLVL'))
numpy.testing.assert_approx_equal(
law.enzyme.subunits[0].molecular_weight, 39810, significant=3)
self.assertEqual(law.enzyme.cross_references, [])
# 2139, two subunits
law = src.session.query(KineticLaw).filter_by(id=2139).first()
self.assertEqual(len(law.enzyme.subunits), 2)
subunit = next(subunit for subunit in law.enzyme.subunits
if subunit.cross_references[0].id == 'P07677')
self.assertEqual(len(subunit.cross_references), 1)
self.assertEqual(subunit.cross_references[0].namespace, 'uniprot')
self.assertEqual(subunit.cross_references[0].id, 'P07677')
self.assertEqual(subunit.coefficient, 1)
self.assertEqual(
subunit.sequence,
('MTRGRVIQVMGPVVDVKFENGHLPAIYNALKIQHKARNENEVDIDLTLEVALHLGDDTVR'
'TIAMASTDGLIRGMEVIDTGAPISVPVGQVTLGRVFNVLGEPIDLEGDIPADARRDPIHR'
'PAPKFEELATEVEILETGIKVVDLLAPYIKGGKIGLFGGAGVGKTVLIQELIHNIAQEHG'
'GISVFAGVGERTREGNDLYHEMKDSGVISKTAMVFGQMNEPPGARMRVALTGLTMAEYFR'
'DEQGQDGLLFIDNIFRFTQAGSEVSALLGRMPSAIGYQPTLATEMGQLQERITSTAKGSI'
'TSIQAIYVPADDYTDPAPATTFSHLDATTNLERKLAEMGIYPAVDPLVSTSRALAPEIVG'
'EEHYQVARKVQQTLERYKELQDIIAILGMDELSDEDKLVVHRARRIQFFLSQNFHVAEQF'
'TGQPGSYVPVKETVRGFKEILEGKYDHLPEDRFRLVGRIEEVVEKAKAMGVEV'))
numpy.testing.assert_approx_equal(subunit.molecular_weight,
51950,
significant=3)
subunit = next(subunit for subunit in law.enzyme.subunits
if subunit.cross_references[0].id == 'P09219')
self.assertEqual(len(subunit.cross_references), 1)
self.assertEqual(subunit.cross_references[0].namespace, 'uniprot')
self.assertEqual(subunit.cross_references[0].id, 'P09219')
self.assertEqual(subunit.coefficient, 1)
self.assertEqual(
subunit.sequence,
('MSIRAEEISALIKQQIENYESQIQVSDVGTVIQVGDGIARAHGLDNVMSGEAVEFANAVM'
'GMALNLEENNVGIVILGPYTGIKEGDEVRRTGRIMEVPVGETLIGRVVNPLGQPVDGLGP'
'VETTETRPIESRAPGVMDRRSVHEPLQTGIKAIDALVPIGRGQRELIIGDRQTGKTSVAI'
'DTIINQKDQNMICIYVAIGQKESTVATVVETLAKHGAPDYTIVVTASASQPAPLLFLAPY'
'AGVAMGEYFMIMGKHVLVVIDDLSKQAAAYRQLSLLLRRPPGREAYPGDIFYLHSRLLER'
'AAKLSDAKGGGSLTALPFVETQAGDISAYIPTNVISITDGQIFLQSDLFFSGVRPAINAG'
'LSVSRVGGAAQIKAMKKVAGTLRLDLAAYRELEAFAQFGSDLDKATQANVARGARTVEVL'
'KQDLHQPIPVEKQVLIIYALTRGFLDDIPVEDVRRFEKEFYLWLDQNGQHLLEHIRTTKD'
'LPNEDDLNQAIEAFKKTFVVSQ'))
numpy.testing.assert_approx_equal(subunit.molecular_weight,
54600,
significant=3)
self.assertEqual(law.enzyme.cross_references, [])
# 1645, one subunit not in SBML
law = src.session.query(KineticLaw).filter_by(id=1645).first()
self.assertEqual(len(law.enzyme.subunits), 1)
self.assertEqual(len(law.enzyme.subunits[0].cross_references), 1)
self.assertEqual(law.enzyme.subunits[0].cross_references[0].namespace,
'uniprot')
self.assertEqual(law.enzyme.subunits[0].cross_references[0].id,
'Q70GK9')
self.assertEqual(law.enzyme.subunits[0].coefficient, 1)
self.assertEqual(law.enzyme.cross_references, [])
def test_parse_complex_subunit_structure(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
self.assertEqual(
src.parse_complex_subunit_structure((
'(<a href="http://www.uniprot.org/uniprot/Q59669" target="_blank">Q59669</a>)'
)), {'Q59669': 1})
self.assertEqual(
src.parse_complex_subunit_structure((
'(<a href="http://www.uniprot.org/uniprot/Q59669" target="_blank">Q59669</a>)*2'
)), {'Q59669': 2})
self.assertEqual(
src.parse_complex_subunit_structure((
'('
'(<a href="http://www.uniprot.org/uniprot/Q59669" target="_blank">Q59669</a>)'
'(<a href="http://www.uniprot.org/uniprot/Q59670" target="_blank">Q59670</a>)'
')')), {
'Q59669': 1,
'Q59670': 1
})
self.assertEqual(
src.parse_complex_subunit_structure((
'('
'(<a href="http://www.uniprot.org/uniprot/Q59669" target="_blank">Q59669</a>)*2'
'(<a href="http://www.uniprot.org/uniprot/Q59670" target="_blank">Q59670</a>)*3'
')*4')), {
'Q59669': 8,
'Q59670': 12
})
self.assertEqual(
src.parse_complex_subunit_structure((
'('
'(<a href="http://www.uniprot.org/uniprot/Q59669" target="_blank">Q59669</a>)'
'(<a href="http://www.uniprot.org/uniprot/Q59670" target="_blank">Q59670</a>)*2'
')*3')), {
'Q59669': 3,
'Q59670': 6
})
self.assertEqual(
src.parse_complex_subunit_structure((
'<a href="http://www.uniprot.org/uniprot/P09219" target=_blank>P09219</a>; '
'<a href="http://www.uniprot.org/uniprot/P07677" target=_blank>P07677</a>; '
)), {
'P09219': 1,
'P07677': 1
})
self.assertEqual(
src.parse_complex_subunit_structure((
'<a href="http://www.uniprot.org/uniprot/P09219" target=_blank>P09219</a>; '
'<a href="http://www.uniprot.org/uniprot/P07677" target=_blank>P07677</a>; '
)), {
'P09219': 1,
'P07677': 1
})
self.assertEqual(
src.parse_complex_subunit_structure((
'(<a href="http://www.uniprot.org/uniprot/P19112" target=_blank>P19112</a>)*4; '
'<a href="http://www.uniprot.org/uniprot/Q9Z1N1" target=_blank>Q9Z1N1</a>; '
)), {
'P19112': 4,
'Q9Z1N1': 1
})
self.assertEqual(
src.parse_complex_subunit_structure((
'((<a href="http://www.uniprot.org/uniprot/P16924" target="_blank">P16924</a>)*2'
'(<a href="http://www.uniprot.org/uniprot/P09102" target="_blank">P09102</a>)*2); '
'((<a href="http://www.uniprot.org/uniprot/Q5ZLK5" target="_blank">Q5ZLK5</a>)*2'
'(<a href="http://www.uniprot.org/uniprot/P09102" target="_blank">P09102</a>)*2);'
)), {
'P16924': 2,
'P09102': 4,
'Q5ZLK5': 2
})
self.assertEqual(
src.parse_complex_subunit_structure((
'((<a href="http://www.uniprot.org/uniprot/Q03393" target=_blank>Q03393</a>)*3)*2); '
)), {'Q03393': 6})
def test_infer_compound_structures_from_names(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False)
session = src.session
compound_unknown = sabio_rk.Compound(name='Unknown')
compound_no_pubchem = sabio_rk.Compound(
name='a random string: adfkja;uvhayocbvadf')
compound_one_pubchem = sabio_rk.Compound(name='water')
compound_multiple_pubchem = sabio_rk.Compound(name='Aspartate')
session.add(compound_unknown)
session.add(compound_no_pubchem)
session.add(compound_one_pubchem)
session.add(compound_multiple_pubchem)
compounds = [
compound_unknown, compound_no_pubchem, compound_one_pubchem,
compound_multiple_pubchem
]
src.infer_compound_structures_from_names(compounds)
self.assertEqual(compound_unknown.cross_references, [])
self.assertEqual(compound_unknown.structures, [])
self.assertEqual(compound_no_pubchem.cross_references, [])
self.assertEqual(compound_no_pubchem.structures, [])
self.assertEqual(
set([(xr.namespace, xr.id)
for xr in compound_one_pubchem.cross_references]),
set([
('pubchem.compound', '962'),
]))
self.assertEqual(
set([(s.format, s.value)
for s in compound_one_pubchem.structures]),
set([
('inchi', 'InChI=1S/H2O/h1H2'),
]))
self.assertEqual(
set([(xr.namespace, xr.id)
for xr in compound_multiple_pubchem.cross_references]),
set([
('pubchem.compound', '5960'),
('pubchem.compound', '5460541'),
('pubchem.compound', '5460294'),
]))
self.assertEqual(
set([(s.format, s.value)
for s in compound_multiple_pubchem.structures]),
set([
('inchi',
'InChI=1S/C4H7NO4/c5-2(4(8)9)1-3(6)7/h2H,1,5H2,(H,6,7)(H,8,9)/t2-/m0/s1'
),
('inchi',
'InChI=1S/C4H7NO4/c5-2(4(8)9)1-3(6)7/h2H,1,5H2,(H,6,7)(H,8,9)/p-2/t2-/m0/s1'
),
('inchi',
'InChI=1S/C4H7NO4/c5-2(4(8)9)1-3(6)7/h2H,1,5H2,(H,6,7)(H,8,9)/p-1/t2-/m0/s1'
),
]))
def test_export_stats(self):
src = sabio_rk.SabioRk()
stats = src.calc_stats()
filename = os.path.join(self.dirname, 'stats.xlsx')
src.export_stats(stats, filename=filename)
self.assertTrue(os.path.isfile(filename))
def test_download_full_database(self):
src = sabio_rk.SabioRk(cache_dirname=self.dirname,
download_backups=True,
load_content=False,
verbose=True)
self.assertGreaterEqual(src.session.query(KineticLaw).count(), 55000)
def build_sabio(self):
"""
Collects SabioRK.sqlite file and integrates its data into the common ORM
"""
t0 = time.time()
sabiodb = sabio_rk.SabioRk(
cache_dirname=self.cache_dirname, verbose=self.verbose)
sabio_ses = sabiodb.session
batch = SABIO_TEST_BATCH if self.test else SABIO_BUILD_BATCH
sabio_progress = self.session.query(
models.Progress).filter_by(database_name=SABIO_NAME).first()
load_count = sabio_progress.amount_loaded
if self.max_entries == float('inf'):
sabio_entry = sabio_ses.query(sabio_rk.Entry)
else:
sabio_entry = sabio_ses.query(sabio_rk.Entry).filter(sabio_rk.Entry._id.in_
(range(load_count, load_count + batch)))
for item in sabio_entry:
metadata = self.get_or_create_object(models.Metadata, name='Kinetic Law ' + str(
item.id)) if item._type == 'kinetic_law' else self.get_or_create_object(models.Metadata, name=item.name)
metadata.synonym = [self.get_or_create_object(
models.Synonym, name=synonyms.name) for synonyms in item.synonyms]
metadata.taxon = [self.get_or_create_object(
models.Taxon, ncbi_id=docs.id) for docs in item.cross_references if docs.namespace == 'taxonomy']
uniprot = [
docs.id for docs in item.cross_references if docs.namespace == 'uniprot']
metadata.resource = [self.get_or_create_object(
models.Resource, namespace=docs.namespace, _id=docs.id) for docs in item.cross_references]
compartment = self.get_or_create_object(
models.CellCompartment, name=item.name) if item._type == 'compartment' else None
if compartment:
continue
if item._type == 'compound':
structure = None
for struct in item.structures:
structure = self.get_or_create_object(models.Structure, type='Structure', name=item.name,
_value_smiles=struct.value, _value_inchi=struct._value_inchi,
_structure_formula_connectivity=struct._value_inchi_formula_connectivity, _metadata=metadata)\
if struct.format == 'smiles' else None
self.entity.metabolite = self.get_or_create_object(models.Metabolite, type='Metabolite',
name=item.name, metabolite_name=item.name,
_is_name_ambiguous=sabio_ses.query(
sabio_rk.Compound).get(item._id)._is_name_ambiguous,
structure=structure, _metadata=metadata)
continue
elif item._type == 'enzyme':
complx = sabio_ses.query(sabio_rk.Enzyme).get(item._id)
self.entity.protein_complex = self.get_or_create_object(models.ProteinComplex, type='Enzyme',
name=item.name, complex_name=item.name,
molecular_weight=item.molecular_weight, funcat_dsc='Enzyme', _metadata=metadata)
continue
elif item._type == 'enzyme_subunit':
result = self.session.query(models.ProteinComplex).filter_by(
complex_name=item.enzyme.name).first()
self.entity.protein_subunit = self.get_or_create_object(models.ProteinSubunit, type='Enzyme Subunit',
name=item.name, subunit_name=item.name,
uniprot_id=uniprot, coefficient=item.coefficient,
molecular_weight=item.molecular_weight,
proteincomplex=result, _metadata=metadata)
continue
elif item._type == 'kinetic_law':
catalyst = self.session.query(models.ProteinComplex).filter_by(
complex_name=item.enzyme.name).first() if item.enzyme_id else None
metadata.resource.extend([self.get_or_create_object(
models.Resource, namespace=resource.namespace, _id=resource.id) for resource in item.references])
metadata.taxon.append(self.get_or_create_object(
models.Taxon, ncbi_id=item.taxon))
metadata.cell_line.append(self.get_or_create_object(
models.CellLine, name=item.taxon_variant))
metadata.conditions.append(self.get_or_create_object(
models.Conditions, temperature=item.temperature, ph=item.ph, media=item.media))
self.property.kinetic_law = self.get_or_create_object(models.KineticLaw, type='Kinetic Law', enzyme=catalyst,
enzyme_type=item.enzyme_type, tissue=item.tissue, mechanism=item.mechanism, equation=item.equation, _metadata=metadata)
def common_schema_metabolite(sabio_object):
metabolite_name = sabio_object.name
return self.session.query(models.Metabolite).filter_by(metabolite_name=metabolite_name).first()
def common_schema_compartment(sabio_object):
if sabio_object:
compartment_name = sabio_object.name
return self.session.query(models.CellCompartment).filter_by(name=compartment_name).first()
else:
return None
reactants = [models.Reaction(metabolite=common_schema_metabolite(r.compound),
compartment=common_schema_compartment(r.compartment), _is_reactant=1, rxn_type=r.type,
kinetic_law=self.property.kinetic_law) for r in item.reactants if item.reactants]
products = [models.Reaction(metabolite=common_schema_metabolite(p.compound),
compartment=common_schema_compartment(p.compartment), _is_product=1, rxn_type=p.type,
kinetic_law=self.property.kinetic_law) for p in item.products if item.products]
modifier = [models.Reaction(metabolite=common_schema_metabolite(m.compound),
compartment=common_schema_compartment(m.compartment), _is_modifier=1, rxn_type=m.type,
kinetic_law=self.property.kinetic_law) for m in item.modifiers if item.products]
for param in item.parameters:
parameter = models.Parameter(sabio_type=param.type, value=param.value, error=param.error,
units=param.units, observed_name=param.observed_name, kinetic_law=self.property.kinetic_law,
observed_sabio_type=param.observed_type, observed_value=param.observed_value,
observed_error=param.observed_error, observed_units=param.observed_units)
parameter.metabolite = common_schema_metabolite(
param.compound) if param.compound else None
continue
sabio_progress.amount_loaded = load_count + batch
self.vprint('Comitting')
self.session.commit()
def test_load_kinetic_laws_and_compounds(self):
src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname,
download_backups=False,
load_content=False,
verbose=True)
src.load_kinetic_laws([1])
session = src.session
""" compartments """
q = session.query(Compartment).filter_by(name='Cell')
self.assertEqual(q.count(), 0)
""" compounds """
c = session.query(Compound).filter_by(id=40).first()
self.assertEqual(c.name, 'H2O')
xrs = [
dict(namespace=xr.namespace, id=xr.id) for xr in c.cross_references
]
self.assertEqual(sorted(xrs, key=lambda xr: xr['namespace']), [
dict(namespace='chebi', id='CHEBI:15377'),
dict(namespace='kegg.compound', id='C00001'),
])
self.assertIsInstance(c.created, datetime.datetime)
self.assertIsInstance(c.modified, datetime.datetime)
self.assertLess(
(datetime.datetime.utcnow() - c.created).total_seconds(), 3600)
self.assertLess(
(datetime.datetime.utcnow() - c.modified).total_seconds(), 3600)
h20_created = c.created
c = session.query(Compound).filter_by(id=2562).first()
self.assertEqual(c.name, 'm n n+m Peptide')
xrs = [
dict(namespace=xr.namespace, id=xr.id) for xr in c.cross_references
]
self.assertEqual(sorted(xrs, key=lambda xr: xr['namespace']), [
dict(namespace='chebi', id='CHEBI:16670'),
dict(namespace='kegg.compound', id='C00012'),
])
c = session.query(Compound).filter_by(id=20035).first()
self.assertEqual(c.name,
'N-(Carbobenzoxy)-Leu-Leu-Phe-trifluoromethylketone')
self.assertEqual(c.cross_references, [])
""" enzymes """
e = session.query(Enzyme).filter_by(id=147631).first()
self.assertEqual(e.name, 'subtilisin')
self.assertEqual(e.subunits, [])
self.assertEqual(e.cross_references, [])
""" reactions """
law = session.query(KineticLaw).filter_by(id=1).first()
cpd_40 = session.query(Compound).filter_by(id=40).first()
cpd_2562 = session.query(Compound).filter_by(id=2562).first()
cpd_20035 = session.query(Compound).filter_by(id=20035).first()
enz_147631 = session.query(Enzyme).filter_by(id=147631).first()
self.assertEqual(
next(xr.id for xr in law.cross_references
if xr.namespace == 'sabiork.reaction'), '6570')
self.assertEqual(len(law.reactants), 2)
self.assertEqual(law.reactants[0].compound, cpd_2562)
self.assertEqual(law.reactants[0].compartment, None)
self.assertTrue(law.reactants[0].coefficient is None
or math.isnan(law.reactants[0].coefficient))
self.assertEqual(law.reactants[1].compound, cpd_40)
self.assertEqual(law.reactants[1].coefficient, 1.)
self.assertEqual(law.reactants[1].compartment, None)
self.assertEqual(len(law.products), 2)
self.assertEqual(law.products[0].compound, cpd_2562)
self.assertEqual(law.products[1].compound, cpd_2562)
self.assertEqual(law.products[0].compartment, None)
self.assertEqual(law.products[1].compartment, None)
self.assertTrue(law.products[0].coefficient is None
or math.isnan(law.products[0].coefficient))
self.assertTrue(law.products[1].coefficient is None
or math.isnan(law.products[1].coefficient))
self.assertEqual([(r.compound, r.coefficient) for r in law.modifiers],
[
(cpd_20035, None),
])
for mod in law.modifiers:
self.assertEqual(mod.modifier_kinetic_law, law)
""" kinetic laws """
l = session.query(KineticLaw).filter_by(id=1).first()
self.assertEqual(l.enzyme, enz_147631)
self.assertEqual(l.enzyme_compartment, None)
self.assertEqual(l.equation, None)
self.assertEqual([
dict(namespace=xr.namespace, id=xr.id) for xr in l.cross_references
], [
dict(namespace='ec-code', id='3.4.21.62'),
dict(namespace='sabiork.reaction', id='6570'),
])
self.assertEqual(len(l.parameters), 4)
p = session.query(Parameter).filter_by(
kinetic_law=l, observed_name='kcat/Km').first()
self.assertEqual(p.compound, cpd_2562)
self.assertEqual(p.compartment, None)
self.assertEqual(p.observed_type, 302)
self.assertEqual(p.observed_value, 120000.)
self.assertEqual(p.observed_error, None)
self.assertEqual(p.observed_units, 'M^(-1)*s^(-1)')
self.assertEqual(p.name, None)
self.assertEqual(p.type, None)
self.assertEqual(p.value, None)
self.assertEqual(p.error, None)
self.assertEqual(p.units, None)
p = session.query(Parameter).filter_by(kinetic_law=l,
observed_name='kcat').first()
self.assertEqual(p.compound, None)
self.assertEqual(p.compartment, None)
self.assertEqual(p.observed_type, 25)
self.assertEqual(p.observed_value, 220.)
self.assertEqual(p.observed_error, None)
self.assertEqual(p.observed_units, 's^(-1)')
p = session.query(Parameter).filter_by(kinetic_law=l,
observed_name='Ki').first()
self.assertEqual(p.compound, cpd_20035)
self.assertEqual(p.compartment, None)
self.assertEqual(p.observed_type, 261)
self.assertEqual(p.observed_value, 1.8E-8)
self.assertEqual(p.observed_error, None)
self.assertEqual(p.observed_units, 'M')
p = session.query(Parameter).filter_by(kinetic_law=l,
observed_name='Km').first()
self.assertEqual(p.compound, cpd_2562)
self.assertEqual(p.compartment, None)
self.assertEqual(p.observed_type, 27)
self.assertEqual(p.observed_value, 0.0019)
self.assertEqual(p.observed_error, None)
self.assertEqual(p.observed_units, 'M')
self.assertEqual(l.taxon, 1467)
self.assertEqual(l.taxon_wildtype, True)
self.assertEqual(l.taxon_variant,
'variant DSAI (N76D/N87S/S103A/V104I)')
self.assertEqual(l.temperature, 25.0)
self.assertEqual(l.ph, 7.5)
self.assertEqual(l.media, '50 mM potassium phosphate, 4 % DMSO')
self.assertEqual(
[dict(n=ref.namespace, i=ref.id) for ref in l.references],
[dict(n='pubmed', i='12962477')])
for ref in l.references:
self.assertIn(l, ref.kinetic_laws)
# download compounds
src.load_compounds()
c = session.query(Compound).filter_by(id=40).first()
self.assertEqual(c.name, 'H2O')
self.assertEqual(c._is_name_ambiguous, False)
self.assertEqual([s.name for s in c.synonyms], ['Water'])
self.assertEqual(c.get_inchi_structures(), ['InChI=1S/H2O/h1H2'])
self.assertEqual(c.get_smiles_structures(), ['[H]O[H]'])
xrs = [
dict(namespace=xr.namespace, id=xr.id) for xr in c.cross_references
]
self.assertNotIn(
dict(namespace='None', id='View all entries for compound H2O'),
xrs)
self.assertIn(dict(namespace='chebi', id='CHEBI:15377'), xrs)
self.assertIn(dict(namespace='kegg.compound', id='C00001'), xrs)
self.assertIn(dict(namespace='pubchem.substance', id='3303'), xrs)
self.assertEqual(c.created, h20_created)
self.assertIsInstance(c.modified, datetime.datetime)
self.assertLess(
(datetime.datetime.utcnow() - c.modified).total_seconds(), 3600)
