cameo package

Subpackages

• cameo.api package
  • Submodules
  • cameo.api.designer module
  • cameo.api.hosts module
  • cameo.api.products module
  • Module contents
• cameo.core package
  • Submodules
  • cameo.core.gene module
  • cameo.core.manipulation module
  • cameo.core.metabolite module
  • cameo.core.pathway module
  • cameo.core.reaction module
  • cameo.core.result module
  • cameo.core.solution module
  • cameo.core.solver_based_model module
  • cameo.core.solver_based_model_dual module
  • cameo.core.strain_design module
  • cameo.core.target module
  • Module contents
• cameo.data package
  • Submodules
  • cameo.data.metanetx module
  • Module contents
• cameo.flux_analysis package
  • Submodules
  • cameo.flux_analysis.analysis module
  • cameo.flux_analysis.simulation module
  • cameo.flux_analysis.structural module
  • cameo.flux_analysis.util module
  • Module contents
• cameo.models package
  • Submodules
  • cameo.models.universal module
  • cameo.models.webmodels module
    • WebModels API
  • Module contents
• cameo.network_analysis package
  • Submodules
  • cameo.network_analysis.networkx_based module
  • cameo.network_analysis.util module
  • Module contents
• cameo.strain_design package
  • Subpackages
    • cameo.strain_design.deterministic package
      • Submodules
      • cameo.strain_design.deterministic.flux_variability_based module
      • cameo.strain_design.deterministic.linear_programming module
      • Module contents
    • cameo.strain_design.heuristic package
      • Submodules
      • cameo.strain_design.heuristic.evolutionary_based module
      • Module contents
    • cameo.strain_design.pathway_prediction package
      • Submodules
      • cameo.strain_design.pathway_prediction.pathway_predictor module
      • cameo.strain_design.pathway_prediction.util module
      • Module contents
  • Module contents
• cameo.ui package
  • Module contents
• cameo.visualization package
  • Submodules
  • cameo.visualization.escher_ext module
  • cameo.visualization.palette module
  • cameo.visualization.plotting_old module
  • cameo.visualization.sympy_ext module
  • cameo.visualization.visualization module
  • Module contents

Submodules

cameo.config module

cameo.exceptions module

exception cameo.exceptions.IncompatibleTargets(target1, target2)

Bases: Exception

exception cameo.exceptions.SolveError(message)

Bases: Exception

exception cameo.exceptions.Infeasible(message)

Bases: cameo.exceptions.SolveError

exception cameo.exceptions.Unbounded(message)

Bases: cameo.exceptions.SolveError

exception cameo.exceptions.FeasibleButNotOptimal(message)

Bases: cameo.exceptions.SolveError

exception cameo.exceptions.UndefinedSolution(message)

Bases: cameo.exceptions.SolveError

cameo.io module

cameo.io.load_model(path_or_handle, solver_interface=<module ‘optlang’ from ‘/home/travis/virtualenv/python3.6.1/lib/python3.6/site-packages/optlang/__init__.py’>, sanitize=True)

Read a metabolic model .

Parameters:

• path_or_handle (path, fhandle or name.) –

  One of:

  • file path of a model file;
  • file handle to a SBML or pickled model; or
  • the identifier of a model in a web database (optflux.org/models)

• solver_interface (solver_interface, optional) – E.g. optlang.glpk_interface or any other optlang interface.
• sanitize (boolean, optional) – If reaction and metabolite IDs should be sanitized (works only for SBML models).

cameo.io.sanitize_ids(model)

Makes IDs crippled by the XML specification less annoying.

For example, EX_glc_LPAREN_e_RPAREN_ will be converted to EX_glc_lp_e_rp_. Furthermore, reactions and metabolites will be equipped with a nice_id attribute that provides the original ID, i.e., EX_glc(d).

Parameters:model (model) –

Notes

Will add a nice_id attribute.

cameo.parallel module

class cameo.parallel.MultiprocessingView(processes=2, **kwargs)

Bases: cameo.util.Singleton

Provides a parallel view (similar to IPython)

Attributes

Methods

pool

map(*args, **kwargs)

apply(func, *args, **kwargs)

apply_async(func, *args, **kwargs)

imap(func, *args, **kwargs)

shutdown()

class cameo.parallel.SequentialView

Bases: object

Methods

map(*args, **kwargs)

apply(func, *args, **kwargs)

apply_async(func, *args, **kwargs)

imap(func, *args, **kwargs)

shutdown()

cameo.util module

class cameo.util.frozendict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

Bases: dict

Methods

popitem()

pop(k, d=None)

setdefault(k, d=None)

update(E=None, **F)

cameo.util.float_ceil(val, decimals=0)

Like ceil but the number of decimals can be set.

Equivalent of $$round(val + 1e^{-decimals}/2, decimals)$$

val: float, numpy.array

The initial value.

decimals: int

The number of decimal places.

Returns: Return type:float, numpy.array

cameo.util.float_floor(val, decimals=0)

Like floor but the number of decimals can be set.

Equivalent of $$round(val - 1e^{-decimals}/2, decimals)$$

val: float, numpy.array

The initial value.

decimals: int

The number of decimal places.

Returns: Return type:float, numpy.array

class cameo.util.ProblemCache(model)

Bases: object

Variable and constraint cache for models.

To be used in complex methods that require many extra variables and constraints when one must run simulations with the same method many times.

It allows rollback to the previous state in case one iteration fails to build the problem or generates an invalid state.

Attributes

Methods

begin_transaction()

Creates a time point. If rollback is called, the variables and constrains will be reverted to this point.

model

add_constraint(constraint_id, create, update, *args, **kwargs)

Adds a new cached constraint.

The create and update functions must have the following signatures: >>> create(model, constraint_id, *args) >>> update(model, constraint, *args)

“args” in the first example must match args on the second example.

Parameters:

• constraint_id (str) – The identifier of the constraint
• create (function) – A function that creates an optlang.interface.Constraint
• update (function) – a function that updates an optlang.interface.Constraint

add_variable(variable_id, create, update, *args, **kwargs)

Adds a new cached variable.

The create and update functions must have the following signatures: >>> create(model, variable_id, *args) >>> update(model, variable, *args)

“args” in the first example must match args on the second example.

Parameters:

• constraint_id (str) – The identifier of the constraint
• create (function) – A function that creates an optlang.interface.Variable
• update (function) – a function that updates an optlang.interface.Variable

add_objective(create, update, *args)

reset()

Removes all constraints and variables from the cache.

rollback()

Returns to the previous transaction start point.

class cameo.util.RandomGenerator(seed=None)

Bases: object

Methods

seed(seed)

random()

randint(a, b=None)

sample(population, k)

uniform(low=0.0, high=1.0, size=None)

class cameo.util.Singleton

Bases: object

Singleton class to be extended

class cameo.util.AutoVivification

Bases: dict

Implementation of perl’s autovivification feature. Checkout http://stackoverflow.com/a/652284/280182

Methods

class cameo.util.TimeMachine

Bases: object

Travel back and forth in time.

Methods

undo(bookmark=None)

redo()

reset()

class cameo.util.Timer(name=None)

Bases: object

Taken from http://stackoverflow.com/a/5849861/280182

class cameo.util.IntelliContainer(**kwargs)

Bases: object

cameo.util.inheritdocstring(name, bases, attrs)

Use as metaclass to inherit class and method docstrings from parent. Adapted from http://stackoverflow.com/questions/13937500/inherit-a-parent-class-docstring-as-doc-attribute

cameo.util.partition_(lst, n)

Partition a list into n bite size chunks.

cameo.util.partition(ite, n)

Partition an iterable into n bite size chunks.

cameo.util.flatten(l)

cameo.util.generate_colors(n)

cameo.util.memoize(function, memo={})

cameo.util.get_system_info()

cameo.util.in_ipnb()

Check if it is running inside an IPython Notebook (updated for new notebooks)

cameo.util.str_to_valid_variable_name(s)

Adapted from http://stackoverflow.com/a/3303361/280182

cameo.util.zip_repeat(long_iter, short_iter)

Zips two iterable objects but repeats the second one if it is shorter than the first one.

Parameters:

• long_iter (iterable) –
• short_iter (iterable) –

Returns:

Return type:

generator

cameo.util.pick_one(iterable)

Helper function that returns an element of an iterable (it the iterable is ordered this will be the first element).

cameo.util.reduce_reaction_set(reaction_set, groups)

Reduces a set of reactions according to a number of groups of reactions. The reduction will be performed so that the resulting set will contain no more than 1 reaction from each group. Reactions that are not in any of the groups will remain in the set.

Parameters:

• reaction_set (Set) –
• groups (Iterable of sets) –

Returns:

Return type:

Set

cameo.util.decompose_reaction_groups(reaction_groups, reactions)

reaction_groups : list

A list with dictionaries (element: relative_coefficient)

reactions : list, set, tuple

A collection of reactions.

Returns:A list of all possible group substitutions. Return type:list

cameo.util.current_solver_name(model)

Give a string representation for an optlang interface.

Parameters:model (cameo.core.SolverBasedModel) – A model Returns:The name of the interface as a string Return type:string

Module contents

CAMEO: Computer Aided Metabolic Engineering & Optimization

Cameo is a high-level python library developed to aid the in silico strain design process in metabolic engineering projects. The library provides a modular architecture that enables the efficient construction of custom analysis workflows.

Example

from cameo import load_model

# load a model from SBML format (can be found under cameo/tests/data) model = load_model(‘EcoliCore.xml’)

# solve the model and print the objective value solution = model.solve() print ‘Objective value:’, solution.f

# Determine a set of gene deletions that will optimize the production # of a desired compound from cameo.strain_design.heuristic import GeneKnockoutOptimization from cameo.strain_design.heuristic.objective_functions import biomass_product_coupled_yield from cameo.flux_analysis.simulation import fba

objective = biomass_product_coupled_yield(“Ec_biomass_iJO1366_core_53p95M”,

“EX_succ_lp_e_rp_”, “EX_glc_lp_e_rp_”)

optimization = GeneKnockoutOptimization(model=model, objective_function=of,

simulation_method=fba, heuristic_method=inspyred.ec.GA)

optimization.run(max_evaluations=2000, n=1,

mutation_rate=0.3, view=cameo.parallel.SequentialView(), product=”EX_succ_lp_e_rp_”, num_elites=1)