Fbapkgs

modelseedpy/fbapkg/changeoptpkg.py

@@ -2,10 +2,11 @@
 
 from __future__ import absolute_import
 
-from optlang.symbolics import Zero, add
-from cobra.core import Gene, Metabolite, Model, Reaction
+from optlang.symbolics import Zero, add  # !!! Add is never used
+from cobra.core import Gene, Metabolite, Model, Reaction  # !!! None of these packages are ever used
 from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
 
+
 #Base class for FBA packages
 class ChangeOptPkg(BaseFBAPkg):
     def __init__(self,model):
@@ -15,7 +16,7 @@ def build_package(self,target_values = {},build_objective = True):
         self.validate_parameters({}, [], {
             "target_values":target_values
         });
-        #Creating objective but won't set objective unless build_objective is true
+        # the created objective will only be set when build_objective is true
         goal_objective = self.model.problem.Objective(Zero,direction="max")
         obj_coef = dict()
         for rxnid in target_values:
@@ -25,35 +26,32 @@ def build_package(self,target_values = {},build_objective = True):
                 rxn = self.model.reactions.get_by_id(rxnid)
                 var = self.build_variable("bgoal",rxn)
                 obj_coef[var] = target_values[rxnid]["objcoef"]
-                const = self.build_constraint("bgoalc",rxn)    
-        #Now setting the goal objective if build_objective is true
+                self.build_constraint("bgoalc",rxn)    
+        # setting the goal objective if build_objective is true
         if build_objective:
             self.model.objective = goal_objective
             goal_objective.set_linear_coefficients(obj_coef)
 
-    def build_variable(self,type,object):
-        if type == "bgoal":
-            goal = self.parameters["target_values"][object.id]
-            return BaseFBAPkg.build_variable(self,type,0,1,"binary",object.id+goal["direction"])
+    def build_variable(self,obj_type,cobra_obj):
+        if obj_type == "bgoal":
+            goal = self.parameters["target_values"][cobra_obj.id]
+            return BaseFBAPkg.build_variable(self,obj_type,0,1,"binary",cobra_obj.id+goal["direction"])
 
-    def build_constraint(self,type,object):
-        if type == "bgoalc":
+    def build_constraint(self,obj_type,cobra_obj):
+        if obj_type == "bgoalc":
             #For lower: goal - vi + 1000 - 1000 gi >= 0
             #For higher: vi - goal  + 1000 - 1000 gi >= 0
             lb = -1000
-            goal = self.parameters["target_values"][object.id]
-            var = self.variables["bgoal"][object.id+goal["direction"]]
-            fluxvar = None
+            goal = self.parameters["target_values"][cobra_obj.id]
+            var = self.variables["bgoal"][cobra_obj.id+goal["direction"]]
+            fluxvar = cobra_obj.forward_variable
             if goal["flux"] < 0:
-                fluxvar = object.reverse_variable
-            else:
-                fluxvar = object.forward_variable
-            coef = {var:-1000}
+                fluxvar = cobra_obj.reverse_variable
+            coef = {var:-1000, fluxvar:1}
             if goal["direction"] == "low":
                 coef[fluxvar] = -1
                 lb += -1*abs(goal["flux"])
             else:
-                coef[fluxvar] = 1
                 lb += abs(goal["flux"])
-            return BaseFBAPkg.build_constraint(self,type,lb,None,coef,object)
+            return BaseFBAPkg.build_constraint(self,obj_type,lb,None,coef,cobra_obj)
 

modelseedpy/fbapkg/drainfluxpkg.py

@@ -3,16 +3,16 @@
 from __future__ import absolute_import
 
 import logging
-from optlang.symbolics import Zero, add
-from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
-
 logger = logging.getLogger("modelseedpy")
+from optlang.symbolics import Zero, add  # !!! Neither Zero nor Add are used
+from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
+from modelseedpy.core.fbahelper import FBAHelper
 
 #Base class for FBA packages
 class DrainFluxPkg(BaseFBAPkg):
     def __init__(self,model):
         BaseFBAPkg.__init__(self,model,"drain flux",{},{"drain"})
-        self.update_drain_fluxes(self)
+        self.update_drain_fluxes()
 
     def build_package(self,parameters):
         self.validate_parameters(parameters,[],{
@@ -24,14 +24,14 @@ def build_package(self,parameters):
             "update_drain_fluxes":False
         })
         if self.parameters["update_drain_fluxes"]:
-            self.update_drain_fluxes(self)
+            self.update_drain_fluxes()
         if self.parameters["add_all_intracellular_drains"]:
             for cpd in self.model.metabolites:
                 self.add_drain_reaction(cpd,self.parameters["default_uptake"],self.parameters["default_excretion"])
         else:
             for cpd in self.parameters["drain_compounds"]:
-                if cpd in self.metabolites:
-                    cpdobj = self.metabolites.get_by_id(cpd)
+                if cpd in self.model.metabolites:
+                    cpdobj = self.model.metabolites.get_by_id(cpd)
                     self.add_drain_reaction(cpdobj,self.parameters["drain_compounds"][cpd]["uptake"],self.parameters["drain_compounds"][cpd]["excretion"])
 
     def add_drain_reaction(self,cpd,uptake,excretion):

modelseedpy/fbapkg/elementuptakepkg.py

@@ -11,9 +11,9 @@ def __init__(self,model):
         BaseFBAPkg.__init__(self,model,"element uptake",{"elements":"string"},{"elements":"string"})
 
     def build_package(self,element_limits):
-        for element in element_limits:
+        for element, limit in element_limits.items():
             if element not in self.variables["elements"]:
-                self.build_variable(element,element_limits[element])
+                self.build_variable(element, limit)
                 self.build_constraint(element)
 
     def build_variable(self,element,limit):

modelseedpy/fbapkg/kbasemediapkg.py

@@ -1,18 +1,18 @@
 # -*- coding: utf-8 -*-
 
 from __future__ import absolute_import
-
 import logging
+logger = logging.getLogger(__name__)
 from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
 from modelseedpy.core.fbahelper import FBAHelper   # !!! imported but not used
+from numpy import log as ln
 
 logger = logging.getLogger(__name__)
 
 class KBaseMediaPkg(BaseFBAPkg):
     """
     Base class for FBA packages
     """
-
     def __init__(self, model):
         BaseFBAPkg.__init__(self, model, "kbase media", {}, {})
 
@@ -37,27 +37,26 @@ def build_package(self, media_or_parameters, default_uptake=None, default_excret
             self.parameters["default_uptake"] = 100
 
         #First initializing all exchanges to default uptake and excretion
-        exchange_list = self.modelutl.exchange_list()
-        for reaction in exchange_list:
-            reaction.lower_bound = -1*self.parameters["default_uptake"]
+        for reaction in self.modelutl.exchange_list():
+            reaction.lower_bound = -self.parameters["default_uptake"]
             reaction.upper_bound = self.parameters["default_excretion"]
 
         #Now constraining exchanges for specific compounds specified in the media
         if self.parameters["media"]:
             exchange_hash = self.modelutl.exchange_hash()
-            self.modelutl.build_metabolite_hash()
+            self.modelutl.build_metabolite_hash()  # !!! what does this accomplish?
             for mediacpd in self.parameters["media"].mediacompounds:
                 mets = self.modelutl.find_met(mediacpd.id)
                 if len(mets) > 0:
                     for met in mets:
                         if met in exchange_hash:
-                            exchange_hash[met].lower_bound = -1 * mediacpd.maxFlux
-                            exchange_hash[met].upper_bound = -1 * mediacpd.minFlux
+                            exchange_hash[met].lower_bound = -mediacpd.maxFlux
+                            exchange_hash[met].upper_bound = -mediacpd.minFlux
                             if self.pkgmgr != None and "FullThermoPkg" in self.pkgmgr.packages:
                                 logger.info('FullThermo constrained compound: ', met.id)
                                 if met.id in self.variables["logconc"] and met.compartment[0:1] == "e":
                                     if mediacpd.concentration != 0.001:
                                         self.variables["logconc"][met.id].lb = ln(mediacpd.concentration)
                                         self.variables["logconc"][met.id].ub = ln(mediacpd.concentration)
                 else:
-                    logger.warn('Media compound: ', mediacpd.id,' not found in model.')
+                    logger.warn('Media compound: ', mediacpd.id,' not found in model.')

modelseedpy/fbapkg/metabofbapkg.py

@@ -3,8 +3,10 @@
 from __future__ import absolute_import
 
 import logging
+logger = logging.getLogger(__name__)
 from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
-from modelseedpy.fbapkg.simplethermopkg import SimpleThermoPkg
+from modelseedpy.fbapkg.simplethermopkg import SimpleThermoPkg # !!! the import is not used
+from optlang.symbolics import Zero
 
 #Base class for FBA packages
 class MetaboFBAPkg(BaseFBAPkg):
@@ -14,22 +16,20 @@ def __init__(self,model):
 
     def build_package(self,parameters):
         self.validate_parameters(parameters,["peaks"],{
-            "set_objective":1,
+            "set_objective":True,
         })
         self.pkgmgr.getpkg("SimpleThermoPkg").build_package()
         peak_hash = {}
-        for peak_data in peaks:
+        for peak_data in self.parameters['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")
+        if parameters["set_objective"]:
+            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]:
@@ -39,21 +39,20 @@ def build_package(self,parameters):
             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_variable(self,cobra_obj,obj_type):
+        if obj_type == "met":
+            return BaseFBAPkg.build_variable(self,obj_type,0,1,"continuous",cobra_obj)
+        elif obj_type == "pk":
+            return BaseFBAPkg.build_variable(self,obj_type,0,1,"continuous",cobra_obj["id"])
 
-    def build_constraint(self,object,type):
+    def build_constraint(self,cobra_obj,obj_type):
         #TODO: need to determine coefficients
-        coef = {self.variables["met"][object.id]:1}
-        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"])
+        if obj_type == "metc":
+            return BaseFBAPkg.build_constraint(self,"metc",0,0,{self.variables["met"][cobra_obj.id]:1},cobra_obj)
+        elif obj_type == "pkc":
+            return BaseFBAPkg.build_constraint(self,"pkc",0,0,{self.variables["met"][cobra_obj.id]:1},cobra_obj["id"])
 
     def find_metabolites_matching_peak(self,data):
         #TODO: need to write this function
         pass
-
+

modelseedpy/fbapkg/objconstpkg.py

@@ -3,6 +3,7 @@
 from __future__ import absolute_import
 
 import logging
+logger = logging.getLogger(__name__)
 from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
 
 #Base class for FBA packages
@@ -11,8 +12,5 @@ def __init__(self,model):
         BaseFBAPkg.__init__(self,model,"objective constraint",{},{"objc":"none"})
 
     def build_package(self,lower_bound,upper_bound):
-        self.build_constraint(lower_bound,upper_bound)
-
-    def build_constraint(self,lower_bound,upper_bound):
         coef = self.model.solver.objective.get_linear_coefficients(self.model.solver.objective.variables)
-        return BaseFBAPkg.build_constraint(self,"objc",lower_bound,upper_bound,coef,None)
+        return BaseFBAPkg.build_constraint(self,"objc",lower_bound,upper_bound,coef,None)

modelseedpy/fbapkg/problemreplicationpkg.py

@@ -3,11 +3,12 @@
 from __future__ import absolute_import
 
 import logging
+logger = logging.getLogger(__name__)
 from optlang import Variable
-from optlang.symbolics import Zero, add
+from optlang.symbolics import Zero, add  # !!! neither Zero nor Add are used
 from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
-from modelseedpy.fbapkg.revbinpkg import RevBinPkg
-from modelseedpy.fbapkg.totalfluxpkg import TotalFluxPkg
+from modelseedpy.fbapkg.revbinpkg import RevBinPkg  # !!! import is unused
+from modelseedpy.fbapkg.totalfluxpkg import TotalFluxPkg  # !!! import is unused
 
 #Base class for FBA packages
 class ProblemReplicationPkg(BaseFBAPkg):
@@ -21,10 +22,10 @@ def build_package(self,parameters):
         #First loading shared variables into a hash
         shared_var_hash = {}
         for pkg in self.parameters["shared_variable_packages"]:
-            for type in self.parameters["shared_variable_packages"][pkg]:
-                if type in pkg.variables:
-                    for objid in pkg.variables[type]:
-                        shared_var_hash[pkg.variables[type][objid].name] = pkg.variables[type][objid]
+            for obj_type in self.parameters["shared_variable_packages"][pkg]:
+                if obj_type in pkg.variables:
+                    for objid in pkg.variables[obj_type]:
+                        shared_var_hash[pkg.variables[obj_type][objid].name] = pkg.variables[obj_type][objid]
         #Now copying over variables and constraints from other models and replacing shared variables
         count = 0
         for othermdl in self.parameters["models"]:
@@ -55,4 +56,4 @@ def build_package(self,parameters):
                 self.constraints[str(count)][const.name] = newconst
                 newobj.append(newconst)       
             self.model.add_cons_vars(newobj)
-            count += 1
+            count += 1

modelseedpy/fbapkg/proteomefittingpkg.py

@@ -3,11 +3,12 @@
 from __future__ import absolute_import
 
 import logging
-import math
-from optlang.symbolics import Zero, add
+logger = logging.getLogger(__name__)
+import math  # !!! import never used
+from optlang.symbolics import Zero, add  # !!! Zero is never used
 from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
 from modelseedpy.core.fbahelper import FBAHelper
-from modelseedpy.multiomics.msexpression import MSExpression, GENOME, MODEL, COLUMN_NORM
+from modelseedpy.multiomics.msexpression import MSExpression, GENOME, MODEL, COLUMN_NORM  # !!! MSExpression and Model are never used
 
 #Options for default behavior
 LOWEST = 10
@@ -60,15 +61,15 @@ def build_package(self,parameters):
                 self.build_variable(rxnobj,"kapp")
                 var = self.build_variable(rxnobj,"kvfit")
                 objvars.append(self.parameters["obj_kvfit"] * var ** 2)
-                const = self.build_constraint(rxnobj,"vkapp")            
+                self.build_constraint(rxnobj,"vkapp")            
         #Adding kcat fitting variables and constraints
-        for rxnid in self.parameters["kcat_values"]:
+        for rxnid in self.parameters["kcat_values"]:  #!!! what does this loop contribute?
             for rxnobj in self.model.reactions:
                 if rxnid == FBAHelper.modelseed_id_from_cobra_reaction(rxnobj):
                     if rxnobj.id not in self.variables["kapp"]:
                         self.build_variable(rxnobj,"kapp")
                     var = self.build_variable(rxnobj,"kfit")
-                    const = self.build_constraint(rxnobj,"kfitc")
+                    self.build_constraint(rxnobj,"kfitc")
                     objvars.append(self.parameters["obj_kfit"] * var ** 2)
         #Creating objective function
         if self.parameters["set_objective"] == 1:

modelseedpy/fbapkg/revbinpkg.py

@@ -24,4 +24,4 @@ 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)
+        return BaseFBAPkg.build_constraint(self,"revbinR",None,1000,{self.variables["revbin"][object.id]:1000,object.reverse_variable:1},object)

modelseedpy/fbapkg/simplethermopkg.py

@@ -2,9 +2,10 @@
 
 from __future__ import absolute_import
 import logging
+logger = logging.getLogger(__name__)
 from modelseedpy.fbapkg.basefbapkg import BaseFBAPkg
 from optlang.symbolics import Zero
-import re
+import re  # !!! import is never used
 
 #Base class for FBA packages
 class SimpleThermoPkg(BaseFBAPkg):
@@ -101,4 +102,4 @@ def optimize_dgbin(self):
 
         # set the dgbin sum as the model objective
         self.model.objective = self.model.problem.Objective(Zero,direction='max')
-        self.model.objective.set_linear_coefficients(dgbin_sum_coef)
+        self.model.objective.set_linear_coefficients(dgbin_sum_coef)