core Package — cobra 0.2.0 documentation

### Navigation

- index
- modules |
- next |
- previous |
- cobra 0.2.0 documentation »
- cobra Package »

# core Package

## `core` Package

## `ArrayBasedModel` Module

class `cobra.core.ArrayBasedModel.` `ArrayBasedModel`(description=None, deepcopy_model=False)

  Bases: `cobra.core.Model.Model`

  ArrayBasedModel is a class that adds arrays and vectors to a cobra.Model to make it easier to perform linear algebra operations.

  S : `scipy.sparse.lil_matrix` (in CPython)
    Stoichiometric matrix of the model

  lower_bounds

  upper_bounds

  objective_coefficients

  b

  constraint_sense

  `add_metabolites`(metabolite_list, expand_stoichiometric_matrix=True)

    Will add a list of metabolites to the the object, if they do not exist and then expand the stochiometric matrix

    metabolite_list: A list of `Metabolite` objects

    expand_stoichimetric_matrix: Boolean. If True and self.S is not None then it will add rows to self.S. self.S must be created after adding reactions and metabolites to self before it can be expanded. Trying to expand self.S when self only contains metabolites is ludacris.

  `add_reactions`(reaction_list, update_matrices=False)

    Will add a cobra.Reaction object to the model, if reaction.id is not in self.reactions.

    reaction_list: A `Reaction` object or a list of them

    update_matrices: Boolean. If true populate / update matrices S, lower_bounds, upper_bounds, .... Note this is slow to run for very large models and using this option with repeated calls will degrade performance. Better to call self.update() after adding all reactions.

    > If the stoichiometric matrix is initially empty then initialize a 1x1 sparse matrix and add more rows as needed in the self.add_metabolites function

  `copy`(print_time=False)

    Provides a partial ‘deepcopy’ of the Model. All of the Metabolite, Gene, and Reaction objects are created anew but in a faster fashion than deepcopy

    print_time: Boolean used for debugging

  `update`()

    Regenerates the stoichiometric matrix and vectors

## `DictList` Module

class `cobra.core.DictList.` `DictList`(*args, **kwargs)

  Bases: `list`

  A combined dict and list that feels like a list, but has the speed benefits of a dict. This may be eventually replaced by collections.OrderedDict.

  This was written to address the performance issues associated with searching, accessing, or iterating over a list in python that resulted in notable performance decays with COBRA for python.

  `append`(object)
  `extend`(iterable)
  `get_by_id`(id)

    return the element with a matching id

  `index`(id)

    id: A string or a `Object`

  `insert`(index, object)
  `list_attr`(attribute)

    return a list of the given attribute for every object

  `pop`(*args, **kwargs)
  `query`(search_function, attribute='id')

    query the list

    search_function: this will be used to select which objects to return This can be:

    > - a string, in which case any object.attribute containing the string will be returned
    > - a compiled regular expression
    > - a boolean function which takes one argument and returns True for desired values

    attribute: the attribute to be searched for (default is ‘id’).
      If this is None, the object itself is used.

    returns: a list of objects which match the query

  `remove`(*args, **kwargs)
  `reverse`(*args, **kwargs)
  `sort`(*args, **kwargs)
  `union`(iterable)

    adds elements with id’s not already in the model

`cobra.core.DictList.` `get_id`(object)

  return an id for the object

  This allows the function to be generalize to non-cobra.core objects, however, this added function call slows things down.

## `Formula` Module

class `cobra.core.Formula.` `Formula`(formula=None)

  Bases: `cobra.core.Object.Object`

  Formula is a class for holding information regarding a Metabolite formula.

  This will replace the current way of dealing with molecular formulae in cobra.Metabolite objects

  Legal formula string characters include letters, numbers, and *. If a formula string starts with a number then it is assumed that all element counts are multiplied by this number.

  `calculate_formula_weight`(weight_dict=None)

    Calculate the formula weight.

    weight_dict: None or a dictionary of elements and weights.

  `parse_composition`()

    Breaks the chemical formula down by element. Useful for making sure Reactions are balanced.’

    TODO: Find a stable python package for parsing chemical formulas.

## `Gene` Module

class `cobra.core.Gene.` `Gene`(id, formula=None, name=None, compartment=None, strand='+', locus_start=0, locus_end=0, functional=True)

  Bases: `cobra.core.Metabolite.Metabolite`

  A Gene is a special class of metabolite.

  TODO: Make design decisions about TUs and such

  `guided_copy`(the_model)

    Trying to make a faster copy proceedure for cases where large numbers of metabolites might be copied. Such as when copying reactions.

  `remove_from_model`(the_model, make_dependent_reactions_nonfunctional=True)

    Removes the association

    the_model: `Model` object.
      Remove the reaction from this model.

    make_dependent_reactions_nonfunctional: Boolean. If True then replace the gene with ‘False’ in the gene association, else replace the gene with ‘True’

    TODO: Better handling of the gene association

## `Metabolite` Module

class `cobra.core.Metabolite.` `Metabolite`(id=None, formula=None, name=None, compartment=None)

  Bases: `cobra.core.Object.Object`

  Metabolite is a class for holding information regarding a metabolite in a cobra.Reaction object.

  `copy`()

    When copying a reaction, it is necessary to deepcopy the components so the list references aren’t carried over.

    Additionally, a copy of a reaction is no longer in a cobra.Model.

    This should be fixed with self.__deecopy__ if possible

  `get_model`()

    Returns the Model object that contain this Object

  `get_reaction`()

    Returns a list of Reactions that contain this Object

  `guided_copy`(the_model)

    Trying to make a faster copy procedure for cases where large numbers of metabolites might be copied. Such as when copying reactions.

  `parse_composition`()

    Breaks the chemical formula down by element. Useful for making sure Reactions are balanced.’

  `remove_from_model`(model=None, method='subtractive')

    Removes the association

    model: None or `Model` object.
      Remove the reaction from this model.

    method: ‘subtractive’ or ‘destructive’. If ‘subtractive’ then the metabolite is removed from all associated reactions. If ‘destructive’ then all associated reactions are removed from the Model.

## `Model` Module

class `cobra.core.Model.` `Model`(description=None)

  Bases: `cobra.core.Object.Object`

  Model is a class for analyzing metabolic models with the COBRA toolbox developed in the Palsson Lab at UCSD. Make all of the objects (Reaction, Metabolite, ...) to make OOP easier.

  `add_metabolites`(metabolite_list)

    Will add a list of metabolites to the the object, if they do not exist and then expand the stochiometric matrix

    metabolite_list: A list of `Metabolite` objects

  `add_reaction`(reaction)

    Will add a cobra.Reaction object to the model, if reaction.id is not in self.reactions.

    reaction: A `Reaction` object

  `add_reactions`(reaction_list)

    Will add a cobra.Reaction object to the model, if reaction.id is not in self.reactions.

    reaction_list: A `Reaction` object or a list of them

  `copy`(print_time=False)

    Provides a partial ‘deepcopy’ of the Model. All of the Metabolite, Gene, and Reaction objects are created anew but in a faster fashion than deepcopy

    print_time: Boolean used for debugging

  `optimize`(new_objective=None, objective_sense='maximize', the_problem=None, solver='glpk', error_reporting=None, quadratic_component=None, tolerance_optimality=1e-06, tolerance_feasibility=1e-06, tolerance_barrier=1e-10, **kwargs)

    Optimize self for self._objective_coefficients or new_objective.

    NOTE: Only the most commonly used parameters are presented here. Additional parameters for cobra.solvers may be available and specified with the appropriate keyword=value.

    new_objective: Reaction, String, or Integer referring to a reaction in cobra_model.reactions to set as the objective. Currently, only supports single objective coeffients. Will expand to include mixed objectives.

    objective_sense: ‘maximize’ or ‘minimize’

    the_problem: None or a problem object for the specific solver that can be used to hot start the next solution.

    solver: ‘glpk’, ‘gurobi’, or ‘cplex’

    error_reporting: None or True to disable or enable printing errors encountered when trying to find the optimal solution.

    quadratic_component: None or scipy.sparse.dok of dim(len(cobra_model.reactions),len(cobra_model.reactions)) If not None:

    > Solves quadratic programming problems for cobra_models of the form: cobra_model = ArrayBasedModel(cobra_model) minimize: 0.5 * x’ * quadratic_component * x + cobra_model._objective_coefficients’ * x such that,

    > > cobra_model._lower_bounds <= x <= cobra_model._upper_bounds cobra_model._S * x (cobra_model._constraint_sense) cobra_model._b

    #See cobra.flux_analysis.solvers for more info on the following parameters. Also, refer to your solver’s manual

    tolerance_optimality: Solver tolerance for optimality.

    tolerance_feasibility: Solver tolerance for feasibility.

    tolerance_barrier: Solver tolerance for barrier method

    lp_method: Solver method to solve the problem

    #End solver parameters

    **kwargs: See additional parameters for your specific solver module in cobra.solvers

  `remove_reactions`(the_reactions)

    the_reactions: instance or list of cobra.Reactions or strings of self.reactions[:].id.

  `to_array_based_model`(deepcopy_model=False)

    Makes a `ArrayBasedModel` from a cobra.Model which may be used to perform linear algebra operations with the stoichiomatric matrix.

    deepcopy_model: Boolean. If False then the ArrayBasedModel points to the Model

  `update`()

    Non functional. Model.update is moved to ArrayBasedModel. Please use the to_array_based_model property to create an ArrayBasedModel.

## `Object` Module

class `cobra.core.Object.` `Object`(id=None)

  Bases: `object`

  `endswith`(x)
  `guided_copy`()

    Trying to make a faster copy procedure for cases where large numbers of metabolites might be copied. Such as when copying reactions.

    This function allows us to manipulate how specific attributes are copied.

  `startswith`(x)

## `Reaction` Module

class `cobra.core.Reaction.` `Reaction`(name=None)

  Bases: `cobra.core.Object.Object`

  Reaction is a class for holding information regarding a biochemical reaction in a cobra.Model object

  `add_gene_reaction_rule`(the_rule)

    This adds a gene reaction rule.

    the_rule: A boolean representation of the gene requirements for this reaction to be active as described in Schellenberger et al 2011 Nature Protocols 6(9):1290-307.

    Note that this method currently replaces any pre-existing rules

  `add_metabolites`(the_metabolites, combine=True, add_to_container_model=True)

    Add metabolites and stoichiometric coefficients to the reaction. If the final coefficient for a metabolite is 0 then it is removed from the reaction.

    the_metabolites: A dict of cobra.Metabolites and their coefficient

    combine: Boolean. If True and a metabolite already exists in the reaction then the coefficients will be added. If False the old metabolite will be discarded and the new one added.

    add_to_container_model: Boolean. If True and this reaction is contained within a cobra.Model (i.e., self._model is a cobra.Model) then add the metabolite to the model.

  `build_reaction_string`(use_metabolite_names=False)

    Generate a human readable reaction string.

  `check_mass_balance`()

    Makes sure that the reaction is elementally-balanced.

  `copy`()

    When copying a reaction, it is necessary to deepcopy the components so the list references aren’t carried over.

    Additionally, a copy of a reaction is no longer in a cobra.Model.

    This should be fixed with self.__deecopy__ if possible

  `delete`()

    Removes all associations between a reaction and its container _model and metabolites and genes.

    TODO: Decide whether orphan metabolites should automatically be removed from the model.

  `get_coefficient`(the_metabolite)

    Return the stoichiometric coefficient for a metabolite in the reaction.

    the_metabolite: A metabolite Id.

  `get_coefficients`(the_metabolites)

    Return the stoichiometric coefficients for a list of metabolites in the reaction.

    the_metabolites: A list of metabolite Ids.

  `get_compartments`()
  `get_gene`()

    Return a list of reactants for the reaction.

  `get_model`()

    Returns the Model object that this Reaction is associated with.

  `get_products`()

    Return a list of products for the reaction

  `get_reactants`()

    Return a list of reactants for the reaction.

  `guided_copy`(the_model, metabolite_dict, gene_dict=None)

    Trying to make a faster copy procedure for cases where large numbers of metabolites might be copied. Such as when copying reactions.

  `parse_gene_association`(the_type='gene')

    Extract all genes from the Boolean Gene_Association string.

    #Formerly, update_names

  `pop`(the_metabolite)

    Remove a metabolite from the reaction and return the stoichiometric coefficient.

    the_metabolite: A cobra.Metabolite that is in the reaction

  `print_values`()

    Prints most of the contents of a reaction as a series of strings.

  `process_prefixed_reaction`()

    Deal with reaction names that have a prefix.

    DEPRECATED This is necessary when parsing text files. It is better to get the reactions from SBML files.

    This can be moved to a tools section

  `reconstruct_reaction`()

    Generate a human readable reaction string.

  `remove_from_model`(model=None)

    Removes the association

    model: cobra.Model object. remove the reaction from this model.

  `subtract_metabolites`(metabolites)

    This function will ‘subtract’ cobra.metabolites from a reaction, which means add the metabolites with -1*coefficient. If the final coefficient for a metabolite is 0 then the metabolite is removed from the reaction.

    Note

    That a final coefficient < 0 implies a reactant.

    metabolites: dict of {`Metabolite`: coefficient}
      These metabolites will be added to the reaction

    Note

    This function uses deepcopy in case the reaction is being

    subtracted from itself.

## `Solution` Module

class `cobra.core.Solution.` `Solution`(the_f, x=None, x_dict=None, y=None, y_dict=None, the_solver=None, the_time=0, status='NA')

  Bases: `cobra.core.Object.Object`

  Stores the solution from optimizing a cobra.Model. This is used to provide a single interface to results from different solvers that store their values in different ways.

  NOTE: This class might be deprecated in favor of associating the values with the Reactions and Metabolites in the cobra.Model.

  f: The objective value

  the_time: Float. Sometimes indicates how long it took to solve a problem. As this is typically negligible and not used in cobra pie, it might be deprecated.

  the_solver: A string indicating which solver package was used.

  x: List or Array of the values from the primal.

  x_dict: A dictionary of reaction ids that maps to the primal values.

  y: List or Array of the values from the dual.

  y_dict: A dictionary of reaction ids that maps to the dual values.

### Navigation

- index
- modules |
- next |
- previous |
- cobra 0.2.0 documentation »
- cobra Package »