algorecell-types 0.90__py3-none-any.whl → 1.1__py3-none-any.whl

algorecell_types/__init__.py

@@ -1,7 +1,7 @@
 """
 This module implements generic types for representing predictions for
 the control of attractors in Boolean and multivalued networks, with
-various visualization methods.
+various visualizations.
 
 It accounts for instantaneous, temporary, and permanent perturbations, as well
 as sequential reprogramming strategies.
@@ -9,6 +9,14 @@ as sequential reprogramming strategies.
 Typically, a method computing reprogramming strategies returns an object of
 class :py:class:`.ReprogrammingStrategies`, from which can be extracted and
 visualized the set of identified strategies.
+
+Exemples of projects using the ``algorecell_types`` module:
+
+* `ActoNet <https://github.com/algorecell/pyActoNet>`_
+* `CABEAN-python <https://github.com/algorecell/cabean-python>`_
+* `Caspo-control <https://github.com/algorecell/caspo-control>`_
+* `StableMotifs-python <https://github.com/algorecell/StableMotifs-python>`_
+
 """
 
 import pandas as pd
@@ -73,6 +81,10 @@ class _Perturbation(_SymbolicType):
 class PermanentPerturbation(_Perturbation):
     """
     A permanent perturbation locks the specified components forever (mutation).
+
+    Example:
+
+    >>> p = PermanentPerturbation({"a": 1, "b": 0})
     """
     pass
 
@@ -80,6 +92,10 @@ class TemporaryPerturbation(_Perturbation):
     """
     A temporary perturbation locks the specified components until having reached
     an attractor, or until a :py:class:`.ReleasePerturbation`.
+
+    Example:
+
+    >>> p = TemporaryPerturbation({"a": 1, "b": 0})
     """
     pass
 
@@ -87,6 +103,10 @@ class ReleasePerturbation(_Perturbation):
     """
     A release perturbation unlocks given components subject to a prior
     :py:class:`.TemporaryPerturbation`.
+
+    Example:
+
+    >>> p = ReleasePerturbation({"a","b"})
     """
     pass
 
@@ -94,6 +114,10 @@ class InstantaneousPerturbation(_Perturbation):
     """
     An instantaneous perturbation modifies the states of the components and is
     immediatly released.
+
+    Example:
+
+    >>> p = InstantaneousPerturbation({"a": 1, "b": 0})
     """
     pass
 
@@ -118,6 +142,11 @@ class _Strategy(_SymbolicType):
         return start
 
     def perturbation_sequence(self):
+        """
+        Returns the sequence of perturbations encoded by the strategy
+
+        :rtype: tuple of :py:class:`._Perturbation` objects
+        """
         ps = (self.perturbation(),)
         s = self.next()
         if s:
@@ -125,6 +154,16 @@ class _Strategy(_SymbolicType):
         return ps
 
 class FromAny(_Strategy):
+    """
+    Reprogramming strategy that can be applied in any state of the network
+    """
+    def __init__(self, perturbation, *seq):
+        """
+        :param ._Perturbation perturbation: perturbation object
+        :keyword ._Strategy seq: optional the next strategy to apply (sequential reprogramming)
+        """
+        assert len(seq) <= 1
+        super().__init__(perturbation, *seq)
     def make_start_node(self):
         n = pydot.Node("any", label="")
         n.set_tooltip(self.__class__.__name__[4:])
@@ -138,6 +177,22 @@ class FromAny(_Strategy):
             return self.args[1]
 
 class FromState(_Strategy):
+    """
+    Reprograming strategy that should be applied in the specified state
+    """
+    alias_template = 's{}'
+    def __init__(self, state, perturbation, *seq):
+        """
+        :param str state: alias of the state
+        :param ._Perturbation perturbation: perturbation object
+        :keyword ._Strategy seq: optional the next strategy to apply (sequential reprogramming)
+        """
+        assert len(seq) <= 1
+        super().__init__(state, perturbation, *seq)
+    def key(self):
+        return self.args[0]
+    def replace_key(self, key):
+        self.args[0] = key
     def make_start_node(self):
         n = pydot.Node(self.args[0])
         n.set_tooltip(self.__class__.__name__[4:])
@@ -149,9 +204,17 @@ class FromState(_Strategy):
             return self.args[2]
 
 class FromCondition(FromState):
-    pass
+    """
+    Reprogramming strategy that should be applied only with the given condition
+    """
+    alias_template = 'c{}'
 
 class FromSteadyState(FromState):
+    """
+    Reprogramming strategy that should be applied in the given steady state
+    (fixed point).
+    """
+    alias_template = 'a{}'
     def make_start_node(self):
         n = super().make_start_node()
         n.set_style("filled")
@@ -159,6 +222,11 @@ class FromSteadyState(FromState):
         return n
 
 class FromOneInLimitCycle(FromState):
+    """
+    Reprogramming strategy that should be applied in one state of the given
+    cyclic attractor.
+    """
+    alias_template = 'a{}'
     def make_start_node(self):
         n = super().make_start_node()
         n.set_style("dashed")
@@ -166,37 +234,25 @@ class FromOneInLimitCycle(FromState):
 
 
 class ReprogrammingStrategies(object):
+    """
+    Stores a list of reprogramming strategies and offers various visualization
+    methods, including IPython representation.
+    """
     def __init__(self):
+        """
+        """
         self.__d = []
         self.__aliases = {}
         self.__autoaliases = {}
 
-    @property
-    def aliases(self):
-        return pd.DataFrame(self.__aliases).T
-
-    def autoalias(self, pattern, state):
-        h = tuple(sorted(state.items()))
-        reg = self.__autoaliases.get(pattern)
-        if not reg:
-            reg = self.__known_alias[pattern] = {}
-        a = reg.get(h)
-        if not a:
-            a = pattern.format(len(reg))
-            reg[h] = a
-            self.register_alias(a, state)
-        return a
-
-    def register_alias(self, name, state):
-        self.__aliases[name] = state
-
-    def add(self, s, **props):
-        self.__d.append((s, props))
-
-    def _repr_pretty_(self, p, cycle):
-        p.pretty([a[0] for a in self.__d])
-
     def as_graph(self, compact=False):
+        """
+        Returns a directed graph representation of the strategies
+        Edge labels indicate the type and specification of perturbations.
+
+        :keyword bool compact: draw compact edge labels
+        :rtype: `pydot.Dot <https://github.com/pydot/pydot>`_ graph
+        """
         g = pydot.Dot("")
         g.set_rankdir("LR")
         target = pydot.Node("target")
@@ -210,6 +266,18 @@ class ReprogrammingStrategies(object):
         return g
 
     def as_table(self):
+        """
+        Returns a `pandas.DataFrame <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html>`_
+        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.
+        """
         #TODO: support multi-valued
         l = set()
         for a in self.__d:
@@ -253,15 +321,66 @@ class ReprogrammingStrategies(object):
             if val == "*":
                 return "color: black; background-color: yellow"
             return ""
-        df = df.applymap(colorize)
+        df = df.map(colorize)
         return df
 
     def perturbations(self):
+        """
+        Returns the set of :py:meth:`._Strategy.perturbation_sequence` of
+        registered reprogramming strategies.
+
+        :rtype: set(tuple(._Perturbation))
+        """
         ps = set()
         for a in self.__d:
             ps.add(a[0].perturbation_sequence())
         return ps
 
+    @property
+    def aliases(self):
+        """
+        Returns a `pandas.DataFrame <https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html>`_
+        listing the state aliases used by the reprogramming strategies.
+        """
+        return pd.DataFrame(self.__aliases).T
+
+    def autoalias(self, pattern, state):
+        h = tuple(sorted(state.items()))
+        reg = self.__autoaliases.get(pattern)
+        if not reg:
+            reg = self.__known_alias[pattern] = {}
+        a = reg.get(h)
+        if not a:
+            a = pattern.format(len(reg))
+            reg[h] = a
+            self.register_alias(a, state)
+        return a
+
+    def register_alias(self, name, state):
+        """
+        Register `name` as being an alias of `state`.
+
+        :param str name:
+        :param dict[str,int] state:
+        """
+        self.__aliases[name] = state
+
+    def add(self, s, **props):
+        """
+        Add a reprogramming strategy `s`, with optional properties `props`.
+        """
+        self.__d.append((s, props))
+
+    def __iter__(self):
+        """
+        Iterator over registered strategies
+        """
+        return iter(self.__d)
+
+    def _repr_pretty_(self, p, cycle):
+        p.pretty([a[0] for a in self.__d])
+
+
 if IN_IPYTHON:
     try:
         ip = get_ipython()

{algorecell_types-0.90.dist-info → algorecell_types-1.1.dist-info}/METADATA

@@ -1,18 +1,18 @@
-Metadata-Version: 2.1
-Name: algorecell-types
-Version: 0.90
+Metadata-Version: 2.4
+Name: algorecell_types
+Version: 1.1
 Summary: Generic types for reprogramming predictions from logical models
 Home-page: https://github.com/algorecell/algorecell_types
 Author: Loïc Paulevé
 Author-email: loic.pauleve@labri.fr
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Requires-Dist: colomoto-jupyter
+Requires-Dist: colomoto_jupyter
 Requires-Dist: pandas
 Requires-Dist: pydot
-
-UNKNOWN
-
-
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary

algorecell_types-1.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+algorecell_types/__init__.py,sha256=P4P6NkCeR7hKqilgODQys_aF8p3xDdfnrCoI8LJumQo,12456
+algorecell_types-1.1.dist-info/METADATA,sha256=laqEdXcdi3it_9B_p2kim6Teb9GBPdf6B9uhTyaMyGw,553
+algorecell_types-1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+algorecell_types-1.1.dist-info/top_level.txt,sha256=09Tdfvl67VmpJ0S33H6oZLd8RcFSUPHVLIWIoZfYySY,17
+algorecell_types-1.1.dist-info/RECORD,,

{algorecell_types-0.90.dist-info → algorecell_types-1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

algorecell_types-0.90.dist-info/RECORD

@@ -1,5 +0,0 @@
-algorecell_types/__init__.py,sha256=peWkkP78NlyEM5seNkcoQXhZSZRsqeqa5Ho15Nb7kD8,8477
-algorecell_types-0.90.dist-info/METADATA,sha256=6o7Eu4qvBhKpjjp9RwDXwtRyA2TRAeDyiYAD7q4kYgo,483
-algorecell_types-0.90.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-algorecell_types-0.90.dist-info/top_level.txt,sha256=09Tdfvl67VmpJ0S33H6oZLd8RcFSUPHVLIWIoZfYySY,17
-algorecell_types-0.90.dist-info/RECORD,,