feat: knock-out genes

As we can knock-out reactions, it is natural to also be able to
knock-out genes. Knocking a gene marks it as non-functional along
with all reactions which are not functional without that gene.

cobra/core/gene.py

@@ -10,6 +10,7 @@
 from warnings import warn
 
 from cobra.core.species import Species
+from cobra.util import resettable
 
 keywords = list(kwlist)
 keywords.remove("and")
@@ -182,7 +183,35 @@ class Gene(Species):
 
     def __init__(self, id=None, name="", functional=True):
         Species.__init__(self, id=id, name=name)
-        self.functional = functional
+        self._functional = functional
+
+    @property
+    def functional(self):
+        """A flag indicating if the gene is functional.
+
+        Changing the flag is reverted upon exit if executed within the model
+        as context.
+        """
+        return self._functional
+
+    @functional.setter
+    @resettable
+    def functional(self, value):
+        if not isinstance(value, bool):
+            raise ValueError('expected boolean')
+        self._functional = value
+
+    def knock_out(self):
+        """Knockout gene by marking it as non-functional and setting all
+        associated reactions bounds to zero.
+
+        The change is reverted upon exit if executed within the model as
+        context.
+        """
+        self.functional = False
+        for reaction in self.reactions:
+            if not reaction.functional:
+                reaction.bounds = (0, 0)
 
     def remove_from_model(self, model=None,
                           make_dependent_reactions_nonfunctional=True):

cobra/core/reaction.py

@@ -13,7 +13,7 @@
 from future.utils import raise_from, raise_with_traceback
 
 from cobra.exceptions import OptimizationError
-from cobra.core.gene import Gene, ast2str, parse_gpr
+from cobra.core.gene import Gene, ast2str, parse_gpr, eval_gpr
 from cobra.core.metabolite import Metabolite
 from cobra.core.object import Object
 from cobra.util.context import resettable, get_context
@@ -450,6 +450,23 @@ def gene_name_reaction_rule(self):
         ast = parse_gpr(self._gene_reaction_rule)[0]
         return ast2str(ast, names=names)
 
+    @property
+    def functional(self):
+        """All required enzymes for reaction are functional.
+
+        Returns
+        -------
+        bool
+            True if the gene-protein-reaction (GPR) rule is fulfilled for
+            this reaction, or if reaction is not associated to a model,
+            otherwise False.
+        """
+        if self._model:
+            tree, _ = parse_gpr(self.gene_reaction_rule)
+            return eval_gpr(tree, {gene.id for gene in self.genes if
+                                   not gene.functional})
+        return True
+
     @property
     def x(self):
         """The flux through the reaction in the most recent solution.
@@ -489,8 +506,8 @@ def boundary(self):
 
         Returns `True` if the reaction has either no products or reactants.
         """
-        return len(self.metabolites) == 1 and\
-            not (self.reactants and self.products)
+        return (len(self.metabolites) == 1 and
+                not (self.reactants and self.products))
 
     @property
     def model(self):

cobra/test/test_model.py

@@ -73,6 +73,25 @@ def test_gpr_modification(self, model):
         fake_gene.name = "foo_gene"
         assert reaction.gene_name_reaction_rule == fake_gene.name
 
+    def test_gene_knock_out(self, model):
+        rxn = Reaction('rxn')
+        rxn.add_metabolites({Metabolite('A'): -1, Metabolite('B'): 1})
+        rxn.gene_reaction_rule = 'A2B1 or A2B2 and A2B3'
+        assert hasattr(list(rxn.genes)[0], 'knock_out')
+        model.add_reaction(rxn)
+        with model:
+            model.genes.A2B1.knock_out()
+            assert not model.genes.A2B1.functional
+            model.genes.A2B3.knock_out()
+            assert not rxn.functional
+        assert model.genes.A2B3.functional
+        assert rxn.functional
+        model.genes.A2B1.knock_out()
+        assert not model.genes.A2B1.functional
+        assert model.reactions.rxn.functional
+        model.genes.A2B3.knock_out()
+        assert not model.reactions.rxn.functional
+
     @pytest.mark.parametrize("solver", list(solver_dict))
     def test_add_metabolite_benchmark(self, model, benchmark, solver):
         reaction = model.reactions.get_by_id("PGI")