maboss 0.8.7__py3-none-any.whl

maboss/__init__.py

@@ -0,0 +1,25 @@
+from .network import *
+from .simulation import *
+from .result import *
+from .results import *
+from .gsparser import load, loadBNet, loadSBML
+from .server import MaBoSSClient
+from .upp import UpdatePopulation
+from .ensemble import EnsembleResult, Ensemble
+import maboss.pipelines
+from colomoto_jupyter import IN_IPYTHON
+import colomoto.setup_helper
+if IN_IPYTHON:
+    from colomoto_jupyter import jupyter_setup
+    from .widgets import *
+
+    import matplotlib.pyplot as plt
+    plt.ion()
+
+    jupyter_setup("mymodule",
+        label="MaBoSS",
+        color="green", # for menu and toolbar
+        menu=menu,
+        toolbar=toolbar,
+        js_api=js_api)
+

maboss/bnetsimulation.py

@@ -0,0 +1,70 @@
+"""
+Class that contains the cMaBoSS simulation.
+"""
+from .sbmlcmabossresult import SBMLCMaBoSSResult
+from sys import stdout
+class BNetSimulation(object):
+
+    def __init__(self, bnet, cfgs=None):
+
+        self.bnet = bnet
+        self.cfgs = cfgs
+
+        self.nb_nodes = self.count_nodes()
+        self.cmaboss = self.get_cmaboss()
+
+        if self.cfgs is None:
+            self.cmaboss_sim = self.cmaboss.MaBoSSSim(self.bnet)
+        else:
+            self.cmaboss_sim = self.cmaboss.MaBoSSSim(self.bnet, self.cfgs)
+   
+    def count_nodes(self):
+        
+        res = 0
+        with open(self.bnet, 'r') as f:
+            lines = f.readlines()
+            for line in lines:
+                if len(line) > 0 and "," in line and line.split(',')[0].strip() != "targets":
+                    res += 1
+        return res
+
+    def print_bnd(self, out=stdout):
+        """Produce the content of the bnd file associated to the simulation."""
+        print(self.cmaboss_sim.str_bnd(), file=out)
+
+    def print_cfg(self, out=stdout):
+        """Produce the content of the cfg file associated to the simulation."""
+        print(self.cmaboss_sim.str_cfg(), file=out)
+
+    def get_cmaboss(self):
+
+        assert self.nb_nodes <= 1024, "Models with more than 1024 nodes are not compatible with this version of MaBoSS"
+
+        if self.nb_nodes <= 64:
+            return __import__("cmaboss")
+        elif self.nb_nodes <= 128:
+            return __import__("cmaboss_128n")
+        elif self.nb_nodes <= 256:
+            return __import__("cmaboss_256n")
+        elif self.nb_nodes <= 512:
+            return __import__("cmaboss_512n")
+        else:
+            return __import__("cmaboss_1024n")
+
+    def get_logical_rules(self):
+
+        out = self.cmaboss_sim.get_logical_rules()    
+        rules = {}
+        for line in out.split("\n"):
+            if ":" in line:
+                node, rule = line.split(" : ", 1)
+                rules.update({node.strip(): rule.strip()})
+
+        return rules
+
+
+    def run(self, only_final_state=False):
+        return SBMLCMaBoSSResult(self, only_final_state)
+
+
+__all__ = ["BNetSimulation"]

maboss/cmabossresult.py

@@ -0,0 +1,103 @@
+"""
+Class that contains the results of a MaBoSS simulation.
+"""
+
+import pandas
+import tempfile
+import os
+from .results.baseresult import BaseResult
+from contextlib import ExitStack
+
+class CMaBoSSResult(BaseResult):
+
+    def __init__(self, simul, workdir=None, overwrite=False, prefix="res", only_final_state=False):
+
+        self.simul = simul
+        self.output_nodes = simul.network.get_output()
+        self.only_final_state = only_final_state
+        BaseResult.__init__(self, simul, output_nodes=self.output_nodes)
+        
+        cmaboss_module = simul.get_cmaboss()
+        cmaboss_sim = cmaboss_module.MaBoSSSim(
+            network_str=str(simul.network), 
+            config_str=simul.str_cfg()
+        )
+
+        self.cmaboss_result = cmaboss_sim.run(self.only_final_state)
+
+        if workdir is not None:
+            if not os.path.exists(workdir):
+                os.makedirs(workdir)
+
+            self.cmaboss_result.display_run(os.path.join(workdir, "%s_run.txt" % prefix))
+
+            if self.only_final_state:
+                self.cmaboss_result.display_final_states(os.path.join(workdir, "%s_finalprob.csv" % prefix))
+            else:
+                self.cmaboss_result.display_probtraj(os.path.join(workdir, "%s_probtraj.csv" % prefix))
+                self.cmaboss_result.display_fp(os.path.join(workdir, "%s_fp.csv" % prefix))
+                self.cmaboss_result.display_statdist(os.path.join(workdir, "%s_statdist.csv" % prefix))
+
+
+
+    def get_last_states_probtraj(self):
+        
+        raw_res = self.cmaboss_result.get_last_probtraj()
+        df = pandas.DataFrame(*raw_res)
+        return df
+
+    def get_states_probtraj(self, prob_cutoff=None):
+        if not self.only_final_state:
+
+            raw_res = self.cmaboss_result.get_probtraj()
+            df = pandas.DataFrame(*raw_res)
+            df.sort_index(axis=1, inplace=True)
+
+            if prob_cutoff is not None:
+                maxs = df.max(axis=0)
+                return df[maxs[maxs>prob_cutoff].index]
+
+            return df
+
+    def get_nodes_probtraj(self, nodes=None, prob_cutoff=None):
+        if not self.only_final_state:
+            raw_res = self.cmaboss_result.get_nodes_probtraj(nodes)
+            df = pandas.DataFrame(*raw_res)
+            df.sort_index(axis=1, inplace=True)
+
+            if prob_cutoff is not None:
+                maxs = df.max(axis=0)
+                return df[maxs[maxs>prob_cutoff].index]
+
+            return df
+
+    def get_last_nodes_probtraj(self, nodes=None):
+        raw_res = self.cmaboss_result.get_last_nodes_probtraj(nodes)
+        df = pandas.DataFrame(*raw_res)
+        df.sort_index(axis=0, inplace=True)
+
+        return df
+
+
+
+    def get_fptable(self):
+        if not self.only_final_state:
+            raw_res = self.cmaboss_result.get_fp_table()
+
+            df = pandas.DataFrame(["#%d" % fp for fp in sorted(raw_res.keys())], columns=["FP"])
+
+            df["Proba"] = [raw_res[fp][0] for fp in sorted(raw_res.keys())]
+            df["State"] = [raw_res[fp][1] for fp in sorted(raw_res.keys())]
+
+            raw_nodes = []
+            for node in self.simul.network.keys():
+                # df[node] = [1 if node in raw_res[fp][1].split(" -- ") else 0 for fp in sorted(raw_res.keys())]
+                raw_nodes.append([1 if node in raw_res[fp][1].split(" -- ") else 0 for fp in sorted(raw_res.keys())])
+
+            t_df = pandas.DataFrame(raw_nodes, index=list(self.simul.network.keys())).transpose()
+
+            return pandas.concat([df, t_df], axis=1)
+            # return df
+
+
+__all__ = ["CMaBoSSResult"]

maboss/cmabossresult2.py

@@ -0,0 +1,90 @@
+"""
+Class that contains the results of a MaBoSS simulation.
+"""
+
+import pandas
+import tempfile
+import os
+from .results.baseresult import BaseResult
+from contextlib import ExitStack
+from time import time
+class CMaBoSSResult2(BaseResult):
+
+    def __init__(self, sim, workdir=None, only_final_state=False):
+
+        BaseResult.__init__(self, "some_path")
+        self.cmaboss_simulation = sim.cmaboss.MaBoSSSim(net=sim.cmaboss_net, cfg=sim.cmaboss_cfg)
+        self.cmaboss_result = self.cmaboss_simulation.run(only_last_state=only_final_state)
+
+        self.workdir = workdir
+        self.only_final_state = only_final_state
+
+        if workdir is not None:
+            if not os.path.exists(workdir):
+                os.makedirs(workdir)
+
+            self.cmaboss_result.display_run(os.path.join(workdir, "%s_run.txt" % prefix))
+
+            if self.only_final_state:
+                self.cmaboss_result.display_final_states(os.path.join(workdir, "%s_finalprob.csv" % prefix))
+            else:
+                self.cmaboss_result.display_probtraj(os.path.join(workdir, "%s_probtraj.csv" % prefix))
+                self.cmaboss_result.display_fp(os.path.join(workdir, "%s_fp.csv" % prefix))
+                self.cmaboss_result.display_statdist(os.path.join(workdir, "%s_statdist.csv" % prefix))
+
+
+    def get_last_states_probtraj(self):
+        
+        raw_res = self.cmaboss_result.get_last_probtraj()
+        df = pandas.DataFrame(*raw_res)
+        return df
+
+    def get_states_probtraj(self, prob_cutoff=None):
+        if not self.only_final_state:
+
+            raw_res = self.cmaboss_result.get_probtraj()
+            df = pandas.DataFrame(*raw_res)
+            df.sort_index(axis=1, inplace=True)
+
+            if prob_cutoff is not None:
+                maxs = df.max(axis=0)
+                return df[maxs[maxs>prob_cutoff].index]
+
+            return df
+
+    def get_nodes_probtraj(self, prob_cutoff=None):
+        if not self.only_final_state:
+            raw_res = self.cmaboss_result.get_nodes_probtraj()
+            df = pandas.DataFrame(*raw_res)
+            df.sort_index(axis=1, inplace=True)
+
+            if prob_cutoff is not None:
+                maxs = df.max(axis=0)
+                return df[maxs[maxs>prob_cutoff].index]
+
+            return df
+
+    def get_last_nodes_probtraj(self):
+        raw_res = self.cmaboss_result.get_last_nodes_probtraj()
+        df = pandas.DataFrame(*raw_res)
+        df.sort_index(axis=0, inplace=True)
+
+        return df
+
+
+    def get_fptable(self):
+        if not self.only_final_state:
+            raw_res = self.cmaboss_result.get_fp_table()
+
+            df = pandas.DataFrame(["#%d" % fp for fp in sorted(raw_res.keys())], columns=["FP"])
+
+            df["Proba"] = [raw_res[fp][0] for fp in sorted(raw_res.keys())]
+            df["State"] = [raw_res[fp][1] for fp in sorted(raw_res.keys())]
+
+            for node in self.simul.network.keys():
+                df[node] = [1 if node in raw_res[fp][1].split(" -- ") else 0 for fp in sorted(raw_res.keys())]
+
+            return df
+
+
+__all__ = ["CMaBoSSResult2"]

maboss/cmabosssimulation.py

@@ -0,0 +1,53 @@
+"""
+Class that contains the cMaBoSS simulation.
+"""
+from .cmabossresult2 import CMaBoSSResult2
+
+class CMaBoSSSimulation(object):
+
+    def __init__(self, bnd, cfgs):
+
+        self.bnd = bnd
+        self.cfgs = cfgs
+
+        self.nb_nodes = self.count_nodes()
+        self.cmaboss = self.get_cmaboss()
+
+        self.cmaboss_net = self.cmaboss.MaBoSSNet(self.bnd)
+        self.cmaboss_cfg = self.cmaboss.MaBoSSCfg(self.cmaboss_net, self.cfgs)
+        self.param = {'max_time': self.cmaboss_cfg.getMaxTime()}
+        self.network = {node: None for node in self.cmaboss_net.getListNodes()}
+        
+    def count_nodes(self):
+        
+        res = 0
+        with open(self.bnd, 'r') as f:
+            lines = f.readlines()
+            for line in lines:
+                if line.lower().startswith("node"):
+                    res += 1
+        return res
+
+
+    def get_cmaboss(self):
+
+        assert self.nb_nodes <= 1024, "Models with more than 1024 nodes are not compatible with this version of MaBoSS"
+
+        if self.nb_nodes <= 64:
+            return __import__("cmaboss")
+        elif self.nb_nodes <= 128:
+            return __import__("cmaboss_128n")
+        elif self.nb_nodes <= 256:
+            return __import__("cmaboss_256n")
+        elif self.nb_nodes <= 512:
+            return __import__("cmaboss_512n")
+        else:
+            return __import__("cmaboss_1024n")
+
+    def run(self, workdir=None, only_final_state=False):
+        return CMaBoSSResult2(self, workdir, only_final_state)
+
+    def check(self):
+        return self.cmaboss.MaBoSSSim(net=self.cmaboss_net, cfg=self.cmaboss_cfg)
+
+__all__ = ["CMaBoSSSimulation"]

maboss/ensemble/__init__.py

@@ -0,0 +1,2 @@
+from .result import EnsembleResult
+from .ensemble import Ensemble