Merge branch 'main' of github.com:ModelSEED/ModelSEEDpy into main

Author: Fxe

examples/MetaboFBAExample.ipynb

@@ -0,0 +1,102 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cobrakbase 0.2.7\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "import cobra\n",
+    "import cplex\n",
+    "import cobrakbase\n",
+    "#Put the path to ModelSEEDpy on your machine here\n",
+    "sys.path.append(\"/Users/chenry/code/ModelSEEDpy\")\n",
+    "#import modelseedpy.fbapkg\n",
+    "from modelseedpy import GapfillingPkg, KBaseMediaPkg, MetaboFBAPkg\n",
+    "from modelseedpy import FBAHelper\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (<ipython-input-1-9c96e9aed238>, line 18)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-9c96e9aed238>\"\u001b[0;36m, line \u001b[0;32m18\u001b[0m\n\u001b[0;31m    mfp.build_package({\"peaks\":[{\"id\":\"peak.1\",\"inchi\":,\"set_objective\":1})\u001b[0m\n\u001b[0m                                                       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "kbase_api = cobrakbase.KBaseAPI()\n",
+    "model = kbase_api.get_from_ws(\"test_model\",18528)\n",
+    "pickaxe_model = kbase_api.get_from_ws(\"MMSyn3Expansion\",29280)\n",
+    "model.solver = 'optlang-cplex'\n",
+    "template = kbase_api.get_from_ws(\"GramNegModelTemplateV3\",\"NewKBaseModelTemplates\")\n",
+    "media = kbase_api.get_from_ws(\"Carbon-D-Glucose\",\"KBaseMedia\")\n",
+    "metabolome = kbase_api.get_from_ws(\"JCVI_Syn3_metabolomics\",29280)\n",
+    "FBAHelper.set_objective_from_target_reaction(model,\"bio1\")\n",
+    "copy_model = cobra.io.json.from_json(cobra.io.json.to_json(model))\n",
+    "gfp = GapfillingPkg(copy_model)\n",
+    "gfp.build_package({\n",
+    "    \"default_gapfill_models\":[pickaxe_model]\n",
+    "    \"default_gapfill_templates\":[template],\n",
+    "    \"gapfill_all_indecies_with_default_templates\":1,\n",
+    "    \"minimum_obj\":0.01,\n",
+    "    \"set_objective\":0\n",
+    "})\n",
+    "kmp = KBaseMediaPkg(copy_model)\n",
+    "kmp.build_package(media)\n",
+    "mfp = MetaboFBAPkg(copy_model)\n",
+    "mfp.build_package({\"peaks\":metabolome.build_peaks_data(),\"set_objective\":1})\n",
+    "sol=model.optimize()\n",
+    "with open('MetaboFBA.lp', 'w') as out:\n",
+    "    out.write(str(model.solver))\n",
+    "#Next minimize active reactions\n",
+    "model.summary()\n",
+    "\n",
+    "cobra.io.save_json_model(model,filename)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

modelseedpy/__init__.py

@@ -34,11 +34,11 @@ def _warn_format(message, category, filename, lineno, file=None, line=None):
 
 import modelseedpy
 from modelseedpy.core import (
-    RastClient, MSGenome, MSBuilder, FBAHelper,MSEditorAPI
+    RastClient, MSGenome, MSBuilder, FBAHelper, MSEditorAPI
 )
 from modelseedpy.fbapkg import (
     BaseFBAPkg,RevBinPkg,ReactionUsePkg,SimpleThermoPkg,TotalFluxPkg,ElementUptakePkg,BilevelPkg,
-    CommKineticPkg,KBaseMediaPkg,FluxFittingPkg,ProteomeFittingPkg,GapfillingPkg
+    CommKineticPkg,KBaseMediaPkg,FluxFittingPkg,ProteomeFittingPkg,GapfillingPkg,MetaboFBAPkg
 )
 
 #If there are parallel modules these should be imported in parallel as shown here:

modelseedpy/core/mseditorapi.py

@@ -17,6 +17,8 @@ class MSEditorAPI:
 
     @staticmethod
     def remove_reactions(model,rxn_id_list = []):
+        for rxnid in rxn_id_list:
+            pass
         pass
 
     @staticmethod    
@@ -28,6 +30,7 @@ def edit_biomass_compound(model,biomass_id,cpd_id,new_coef,rescale = 1):
         pass
 
     @staticmethod
+
     def add_custom_reaction(model,rxn_id,MSEquation,gpr = None,genome = None):
         pass
 

modelseedpy/fbapkg/__init__.py

@@ -13,4 +13,5 @@
 from modelseedpy.fbapkg.kbasemediapkg import KBaseMediaPkg
 from modelseedpy.fbapkg.proteomefittingpkg import ProteomeFittingPkg
 from modelseedpy.fbapkg.fluxfittingpkg import FluxFittingPkg
-from modelseedpy.fbapkg.gapfillingpkg import GapfillingPkg
+from modelseedpy.fbapkg.gapfillingpkg import GapfillingPkg
+from modelseedpy.fbapkg.metabofbapkg import MetaboFBAPkg

modelseedpy/fbapkg/fullthermopkg.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+
+import logging
+from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
+from modelseedpy.fbapkg.revbinpkg import RevBinPkg
+
+#Base class for FBA packages
+class FullThermoPkg(BaseFBAPkg):
+    def __init__(self,model):
+        BaseFBAPkg.__init__(self,model,"full thermo",{"logconc":"metabolite"},{"potentialc":"metabolite"})
+        self.childpkgs["simple thermo"] = SimpleThermoPkg(model)
+
+    def build_package(self,parameters):
+        self.validate_parameters(parameters,[],{
+            "default_max_conc":20,#mM
+            "default_min_conc":0.001,#mM
+            "custom_concentration_constraints":{"cpd000027_e0":["10","10"]},
+            "compartment_potential":{"c0":,}
+        })
+        #Extend the custom concentration for H+, CO2, O2
+        self.childpkgs["simple thermo"].build_package(filter)
+        for metabolite in self.model.metabolites:
+            #Build concentration variable
+            self.build_variable(metabolite)
+            #Build the potential constraint
+            self.build_constraint(reaction)
+    
+    def build_variable(self,object):
+        lb = self.parameters["default_max_conc"]
+        if object.id in self.parameters["custom_concentration_constraints"]:
+            lb = self.parameters["custom_concentration_constraints"][object.id]
+        ub = ?
+        return BaseFBAPkg.build_variable(self,"logconc",lb,ub,"continuous",object)
+    
+    def build_constraint(self,object):
+        #potential(i) (KJ/mol) = deltaG(i) (KJ/mol) + R * T(K) * lnconc(i) + charge(i) * compartment_potentil
+        constant = ?
+        coef = {?}
+        return BaseFBAPkg.build_constraint(self,"thermo",constant,constant,coef,object)

modelseedpy/fbapkg/metabofbapkg.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+
+import logging
+from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
+from modelseedpy.fbapkg.simplethermopkg import SimpleThermoPkg
+
+#Base class for FBA packages
+class MetaboFBAPkg(BaseFBAPkg):
+    def __init__(self,model):
+        BaseFBAPkg.__init__(self,model,"metabo fba",{"met":"metabolite","pk":"string"},{"metc":"metabolite","pkc":"string"})
+        self.childpkgs["simple thermo"] = SimpleThermoPkg(model)
+
+    def build_package(self,parameters):
+        self.validate_parameters(parameters,["peaks"],{
+            "set_objective":1,
+        })
+        self.childpkgs["simple thermo"].build_package()
+        peak_hash = {}
+        for peak_data in peaks:
+            peak_hash[peak_data["id"]] = peak_data
+            self.find_metabolites_matching_peak(peak_data)
+            self.build_variable(peak_data,"pk")
+            for met in peak_data["metabolites"]:
+                self.build_variable(met,"met")
+                self.build_constraint(met,"metc")
+            self.build_constraint(peak_data,"pkc")
+        if parameters["set_objective"] == 1:
+            metabolite_objective = self.model.problem.Objective(
+                Zero,
+                direction="max")
+            obj_coef = dict()
+            for peak_id in self.variables["pk"]:
+                if "wieght" in peak_hash[peak_id]:
+                    obj_coef[self.variables["pk"][peak_id]] = peak_hash[peak_id]["wieght"]
+                else:
+                    obj_coef[self.variables["pk"][peak_id]] = 1
+            self.model.objective = metabolite_objective
+            metabolite_objective.set_linear_coefficients(obj_coef)
+    
+    def build_variable(self,object,type):
+        if type == "met":
+            return BaseFBAPkg.build_variable(self,type,0,1,"continuous",object)
+        elif type == "pk":
+            return BaseFBAPkg.build_variable(self,type,0,1,"continuous",object["id"])
+    
+    def build_constraint(self,object,type):
+        #TODO: need to determine coefficients
+        if type == "metc":
+            return BaseFBAPkg.build_constraint(self,"metc",0,0,coef,object)
+        elif type == "pkc":
+            return BaseFBAPkg.build_constraint(self,"pkc",0,0,coef,object["id"])
+        
+    def find_metabolites_matching_peak(self,data):
+        #TODO: need to write this function

modelseedpy/fbapkg/revbinpkg.py

@@ -21,5 +21,7 @@ def build_variable(self,object):
         return BaseFBAPkg.build_variable(self,"revbin",0,1,"binary",object)
 
     def build_constraint(self,object):
+        #-1000 * revbin(i) + forv(i) <= 0
         BaseFBAPkg.build_constraint(self,"revbinF",None,0,{self.variables["revbin"][object.id]:-1000,object.forward_variable:1},object)
+        #1000 * revbin(i) + revv(i) <= 1000
         return BaseFBAPkg.build_constraint(self,"revbinR",None,1000,{self.variables["revbin"][object.id]:1000,object.reverse_variable:1},object)

modelseedpy/fbapkg/simplethermopkg.py

@@ -23,8 +23,9 @@ def build_package(self,filter = None):
 
     def build_variable(self,object):
         return BaseFBAPkg.build_variable(self,"potential",0,1000,"continuous",object)
-    
-    def build_constraint(self,object):
+
+    def build_constraint(self,object):#Gibbs: dg = Sum(st(i,j)*p(j))
+        #0 <= 1000*revbin(i) + Sum(st(i,j)*p(j)) <= 1000
         coef = {self.childpkgs["reversible binary"].variables["revbin"][object.id] : 1000}
         for metabolite in object.metabolites:
             coef[self.variables["potential"][metabolite.id]] = object.metabolites[metabolite]