algorecell_types Python module

This module implements generic types for representing predictions for the control of attractors in Boolean and multivalued networks, with various visualizations.

It accounts for instantaneous, temporary, and permanent perturbations, as well as sequential reprogramming strategies.

Typically, a method computing reprogramming strategies returns an object of class ReprogrammingStrategies, from which can be extracted and visualized the set of identified strategies.

Exemples of projects using the algorecell_types module:

• ActoNet
• CABEAN-python
• Caspo-control
• StableMotifs-python

class _SymbolicType(*args)

Bases: object

Abstract class of a symbolic type with list of arguments.

Implements a generic repr method.

__init__(*args)

Initialize self. See help(type(self)) for accurate signature.

__repr__()

Return repr(self).

class _Perturbation(partial_state)

Bases: algorecell_types._SymbolicType

Abstract class for representing a perturbation.

__init__(partial_state)

Parameters:partial_state (dict[str,int]) – effect of the perturbation, which assigns states to components

get_edge_label(compact=True)

label to use for the perturbation edge in the graph representation

Parameters:compact (bool) – True requests a short label

__hash__()

Return hash(self).

__eq__(p2)

Return self==value.

class PermanentPerturbation(partial_state)

Bases: algorecell_types._Perturbation

A permanent perturbation locks the specified components forever (mutation).

Example:

>>> p = PermanentPerturbation({"a": 1, "b": 0})

class TemporaryPerturbation(partial_state)

Bases: algorecell_types._Perturbation

A temporary perturbation locks the specified components until having reached an attractor, or until a ReleasePerturbation.

Example:

>>> p = TemporaryPerturbation({"a": 1, "b": 0})

class ReleasePerturbation(partial_state)

Bases: algorecell_types._Perturbation

A release perturbation unlocks given components subject to a prior TemporaryPerturbation.

Example:

>>> p = ReleasePerturbation({"a","b"})

class InstantaneousPerturbation(partial_state)

Bases: algorecell_types._Perturbation

An instantaneous perturbation modifies the states of the components and is immediatly released.

Example:

>>> p = InstantaneousPerturbation({"a": 1, "b": 0})

class _Strategy(*args)

Bases: algorecell_types._SymbolicType

perturbation_sequence()

Returns the sequence of perturbations encoded by the strategy

Return type:tuple of _Perturbation objects

class FromAny(perturbation, *seq)

Bases: algorecell_types._Strategy

Reprogramming strategy that can be applied in any state of the network

__init__(perturbation, *seq)

Parameters:

• perturbation (_Perturbation) – perturbation object
• seq (_Strategy) – optional the next strategy to apply (sequential reprogramming)

class FromState(state, perturbation, *seq)

Bases: algorecell_types._Strategy

Reprograming strategy that should be applied in the specified state

__init__(state, perturbation, *seq)

Parameters:

• state (str) – alias of the state
• perturbation (_Perturbation) – perturbation object
• seq (_Strategy) – optional the next strategy to apply (sequential reprogramming)

class FromCondition(state, perturbation, *seq)

Bases: algorecell_types.FromState

Reprogramming strategy that should be applied only with the given condition

class FromSteadyState(state, perturbation, *seq)

Bases: algorecell_types.FromState

Reprogramming strategy that should be applied in the given steady state (fixed point).

class FromOneInLimitCycle(state, perturbation, *seq)

Bases: algorecell_types.FromState

Reprogramming strategy that should be applied in one state of the given cyclic attractor.

class ReprogrammingStrategies

Bases: object

Stores a list of reprogramming strategies and offers various visualization methods, including IPython representation.

__init__()

as_graph(compact=False)

Returns a directed graph representation of the strategies Edge labels indicate the type and specification of perturbations.

Parameters:compact (bool) – draw compact edge labels Return type:pydot.Dot graph

as_table()

Returns a pandas.DataFrame where each row corresponds to a reprogramming stategy, and columns indicate which nodes are perturbated, in which direction.

Note that this representation hides the type of perturbation. Moreover sequential reproogramming strategies are flatten.

Red cells indicate a forced activation, green cells a forced inhibtion. Yellow cells indicate a sequential reprogramming strategy in which the node is first activated and then later inhibited, or conversely.

perturbations()

Returns the set of _Strategy.perturbation_sequence() of registered reprogramming strategies.

Return type:set(tuple(_Perturbation))

aliases

Returns a pandas.DataFrame listing the state aliases used by the reprogramming strategies.

register_alias(name, state)

Register name as being an alias of state.

Parameters:

• name (str) –
• state (dict[str,int]) –

add(s, **props)

Add a reprogramming strategy s, with optional properties props.

__iter__()

Iterator over registered strategies

• Index