cameo.core package

Submodules

cameo.core.manipulation module

Manage manipulations such as swapping reaction cofactors, over-express or down-regulate genes and reactions.

cameo.core.manipulation.increase_flux(reaction, ref_value, value)[source]

lb 0 ub |--------------------------- ' ---------------------------|

<- - -|———-‘
‘———-|- - - ->
Parameters:
  • reaction (cobra.Reaction) – The reaction to over-express.
  • ref_value (float) – The flux value to come from.
  • value (float) – The flux value to achieve.
cameo.core.manipulation.decrease_flux(reaction, ref_value, value)[source]

lb 0 ub |--------------------------- ' ---------------------------|

|- - >———-‘
‘———-<- - - -|
Parameters:
  • reaction (cobra.Reaction) – The reaction to down_regulate.
  • ref_value (float) – The flux value to come from.
  • value (float) – The flux value to achieve.
cameo.core.manipulation.reverse_flux(reaction, ref_value, value)[source]

Forces a reaction to have a minimum flux level in the opposite direction of a reference state.

lb 0 ub |--------------------------- ' ---------------------------|

<———-‘- - - - - - - ->
Parameters:
  • reaction (cobra.Reaction) – The reaction that will be inverted.
  • ref_value (float) – The flux value to come from.
  • value (float) – The flux value to achieve.
cameo.core.manipulation.swap_cofactors(reaction, model, swap_pairs, inplace=True)[source]

Swaps the cofactors of a reaction. For speed, it can be done inplace which just changes the coefficients. If not done inplace, it will create a new Reaction, add it to the model, and knockout the original reaction.

Parameters:
  • reaction (cobra.Reaction) – The reaction to swap.
  • model (cameo.cobra.Model) – A constraint-based model.
  • swap_pairs (tuple) – A tuple of (cofactors, equivalent_cofactors)
  • inplace (bool) – If replace is done inplace, it changes the coefficients in the matrix. Otherwise, it creates a new reaction with the other cofactors and adds it to the model.
Returns:

A reaction with swapped cofactors (the same if inplace).

Return type:

Reaction

cameo.core.model_dual module

cameo.core.model_dual.convert_to_dual(model)[source]
cameo.core.model_dual.to_dual_model(model, solver_interface=None)[source]
class cameo.core.model_dual.ModelDual(*args, **kwargs)[source]

Bases: cobra.core.model.Model

A cobra.Model that also contains the dual variables and constraints, allowing primal and dual problems to be combined.

Dual variables corresponding to stoichiometric constraints are prefixed by lambda Dual variables corresponding to flux bounds are prefixed by mu Other constraints are not supported at the moment!

Dual constraints will be set according to the original primal objective. The objective can be changed subsequently to optimize an outer problem.

Attributes

Methods

objective
dual_objective
primal_objective()[source]

cameo.core.pathway module

This module implements a pathway data structure that can be added to a model for example.

class cameo.core.pathway.Pathway(reactions, *args, **kwargs)[source]

Bases: object

Representation of a pathway (a set of reactions)

reactions

list o Reaction – The list of reactions in the pathway.

Attributes

Methods

data_frame
classmethod from_file(file_path, sep='\t')[source]

Read a pathway from a file. The file format is: reaction_id<sep>equation<sep>lower_limit<sep>upper_limit<sep>name<sep>comments

The equation is defined by: coefficient * substrate_name#substrate_id + … <=> coefficient * product_name#product_id

Parameters:
  • file_path (str) – The path to the file containing the pathway
  • sep (str) – The separator between elements in the file (default: ” “)
Returns:

Return type:

Pathway

to_file(file_path, sep='\t')[source]

Writes the pathway to a file.

Parameters:
  • file_path (str) – The path to the file where the pathway will be written
  • sep (str) – The separator between elements in the file (default: ” “)
plug_model(model)[source]

Plugs the pathway to a model.

Metabolites are matched in the model by id. For metabolites with no ID in the model, an exchange reaction is added to the model

Parameters:model (cobra.Model) – The model to plug in the pathway

cameo.core.result module

class cameo.core.result.MetaInformation(*args, **kwargs)[source]

Bases: object

Attributes

system_info
responsible
timestamp

doc string

human_readable_timestamp
class cameo.core.result.Result(*args, **kwargs)[source]

Bases: object

Attributes

Methods

meta_information
data_frame
plot(grid=None, width=None, height=None, title=None, *args, **kwargs)[source]

cameo.core.strain_design module

Core implementation of strain design. It contains core structures. Targets (and subclasses) are identified by strain design methods.

class cameo.core.strain_design.StrainDesignMethod(*args, **kwargs)[source]

Bases: object

Methods

run(*args, **kwargs)[source]
class cameo.core.strain_design.StrainDesign(targets)[source]

Bases: object

A StrainDesign is a collection of targets in a COBRA model. The targets, identified by a StrainDesignMethod, map elements in the model that need to be modified to achieve the objective of the design method.

Methods

apply(model)[source]
to_gnomic()[source]
class cameo.core.strain_design.StrainDesignMethodResult(designs, *args, **kwargs)[source]

Bases: cameo.core.result.Result

Attributes

Methods

data_frame
display_on_map(index, map_name)[source]
plot(grid=None, width=None, height=None, title=None, *args, **kwargs)[source]

cameo.core.target module

class cameo.core.target.ReactionCofactorSwapTarget(id, swap_pairs, *args, **kwargs)[source]

Bases: cameo.core.target.Target

Swap cofactors of a given reaction.

Attributes

Methods

apply(model)[source]
swap_str
to_gnomic()[source]
class cameo.core.target.ReactionKnockinTarget(id, value, *args, **kwargs)[source]

Bases: cameo.core.target.KnockinTarget

Methods

apply(model)[source]
to_gnomic()[source]
class cameo.core.target.GeneModulationTarget(id, value, reference_value, *args, **kwargs)[source]

Bases: cameo.core.target.FluxModulationTarget

Attributes

Methods

get_model_target(model)[source]
class cameo.core.target.GeneKnockoutTarget(id, *args, **kwargs)[source]

Bases: cameo.core.target.GeneModulationTarget

Gene Knockout Target. Knockout a gene present in a COBRA model.

Attributes

Methods

apply(model)[source]
to_gnomic()[source]
class cameo.core.target.ReactionModulationTarget(id, value, reference_value)[source]

Bases: cameo.core.target.FluxModulationTarget

Attributes

Methods

get_model_target(model)[source]
class cameo.core.target.ReactionKnockoutTarget(id)[source]

Bases: cameo.core.target.ReactionModulationTarget

Reaction Knockout Target. Knockout a reaction present in a COBRA model.

Attributes

Methods

apply(model)[source]

cameo.core.utils module

cameo.core.utils.get_reaction_for(model, value, add=True)[source]

Get or create a reaction for a metabolite or a reaction.

If value is a Metabolite or a Metabolite id, return any already existing demand or exchange reaction. If add is true, add a demand reaction if it does not already exist.

Parameters:
  • model (cobra.Model) – The model to for which to get / create a reaction
  • value (str, Reaction or Metabolite) – A reaction identifier, a Reaction or a Metabolite for which an exchange reaction is to be created.
  • add (bool) – Adds a demand reaction for a metabolite if a metabolite is found for value
Returns:

Return type:

Reaction

Raises:

KeyError – If value does not match any Reaction or Metabolite

cameo.core.utils.medium(model)[source]

Current medium for this model.

cameo.core.utils.load_medium(model, medium_def, copy=False, delimiter='\t')[source]

Loads a medium into the model. If copy is true it will return a copy of the model. Otherwise it applies the medium to itself. Supported formats TODO

Parameters:
  • model (cobra.Model) – The model to load medium for
  • medium_def (str, pandas.DataFrame, dict.) – The medium to load
  • copy (boolean, optional) – If True copies the model, otherwise the changes will happen inplace.
  • delimiter (str) – Only if loading the medium from a file.
Returns:

If copy=True, returns a copy of the model.

Return type:

cobra.Model

Module contents

This package implements the basic data structures (models, reactions etc.) used in cameo.