enabling parameters associated with enzymes

datanator/data_source/sabio_rk.py

@@ -161,6 +161,7 @@ class Parameter(Entry):
         kinetic_law (:obj:`KineticLaw`): kinetic law
         type (:obj:`int`): SBO term
         compound (:obj:`Compound`): compound
+        enzyme (:obj:`Enzyme`): enzyme
         compartment (:obj:`Compartment`): compartment
         value (:obj:`float`): normalized value
         error (:obj:`float`): normalized error
@@ -205,10 +206,19 @@ class Parameter(Entry):
     type = sqlalchemy.Column(sqlalchemy.Integer(), index=True)
     compound_id = sqlalchemy.Column(sqlalchemy.Integer(), sqlalchemy.ForeignKey('compound._id'), index=True)
     compound = sqlalchemy.orm.relationship(
-        'Compound', uselist=False, backref=sqlalchemy.orm.backref('parameters'), foreign_keys=[compound_id])
+        'Compound', uselist=False, 
+        backref=sqlalchemy.orm.backref('parameters'), 
+        foreign_keys=[compound_id])
+    enzyme_id = sqlalchemy.Column(sqlalchemy.Integer(), sqlalchemy.ForeignKey('enzyme._id'), index=True)
+    enzyme = sqlalchemy.orm.relationship(
+        'Enzyme', uselist=False,
+        backref=sqlalchemy.orm.backref('parameters'),
+        foreign_keys=[enzyme_id])
     compartment_id = sqlalchemy.Column(sqlalchemy.Integer(), sqlalchemy.ForeignKey('compartment._id'), index=True)
-    compartment = sqlalchemy.orm.relationship('Compartment', uselist=False,
-                                              backref=sqlalchemy.orm.backref('parameters'), foreign_keys=[compartment_id])
+    compartment = sqlalchemy.orm.relationship(
+        'Compartment', uselist=False,
+        backref=sqlalchemy.orm.backref('parameters'),
+        foreign_keys=[compartment_id])
     value = sqlalchemy.Column(sqlalchemy.Float())
     error = sqlalchemy.Column(sqlalchemy.Float())
     units = sqlalchemy.Column(sqlalchemy.String(), index=True)
@@ -369,6 +379,7 @@ class Enzyme(Entry):
         subunits (:obj:`list` of :obj:`EnzymeSubunit`): list of subunits
         kinetic_laws (:obj:`list` of :obj:`KineticLaw`): list of kinetic laws
         molecular_weight (:obj:`float`): molecular weight in Daltons
+        parameters (:obj:`list` of :obj:`Parameter`): list of parameters
     """
     _id = sqlalchemy.Column(sqlalchemy.Integer(), sqlalchemy.ForeignKey('entry._id'), primary_key=True)
     molecular_weight = sqlalchemy.Column(sqlalchemy.Float())
@@ -996,10 +1007,17 @@ def create_kinetic_law_from_sbml(self, id, sbml, specie_properties, functions, u
             match = re.match(r'^(.*?)_((SPC|ENZ)_([0-9]+)_(.*?))$', param.getId(), re.IGNORECASE)
             if match:
                 observed_name = match.group(1)
-                compound, compartment = self.get_specie_reference_from_sbml(match.group(2))
+                species, compartment = self.get_specie_reference_from_sbml(match.group(2))
+                if isinstance(species, Compound):
+                    compound = species
+                    enzyme = None
+                else:
+                    compound = None
+                    enzyme = species
             else:
                 observed_name = param.getId()
                 compound = None
+                enzyme = None
                 compartment = None
             observed_name = observed_name.replace('div', '/')
 
@@ -1018,6 +1036,7 @@ def create_kinetic_law_from_sbml(self, id, sbml, specie_properties, functions, u
 
             parameter = Parameter(
                 compound=compound,
+                enzyme=enzyme,
                 compartment=compartment,
                 observed_name=observed_name,
                 observed_type=observed_type,
@@ -1606,7 +1625,7 @@ def load_compounds(self, compounds=None):
                     namespace = 'chebi'
                     id = 'CHEBI:' + id
                 else:
-                    namespace='None'
+                    namespace = 'None'
                     ValueError('Compound {} has unkonwn cross reference type to namespace {}'.format(c.id, url))
 
                 q = self.session.query(Resource).filter_by(namespace=namespace, id=id)

tests/data_source/test_sabio_rk.py

@@ -741,6 +741,23 @@ def test_normalize_parameter_value(self):
 
         self.assertRaises(ValueError, src.normalize_parameter_value, 'k_cat', 25, 0.25, 0.15, 'm', None)
 
+    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_infer_compound_structures_from_names(self):
         src = sabio_rk.SabioRk(cache_dirname=self.cache_dirname, download_backups=False, load_content=False)