def test_trapspaces_that_intersect_subspace():
primes = get_primes("raf")
assert compute_trapspaces_that_intersect_subspace(primes, {"Raf": 1, "Mek": 0, "Erk": 0}, "min") == [{"Raf": 1, "Mek": 0, "Erk": 0}]
assert compute_trapspaces_that_intersect_subspace(primes, {"Erk": 0}, "min") == [{"Raf": 1, "Mek": 0, "Erk": 0}]
assert compute_trapspaces_that_intersect_subspace(primes, {"Erk": 0}, "all") == [{}, {'Erk': 0, 'Mek': 0}, {'Erk': 0, 'Mek': 0, 'Raf': 1}]
assert compute_trapspaces_that_intersect_subspace(primes, {"Erk": 0}, "max") == [{'Erk': 0, 'Mek': 0}]
assert compute_trapspaces_that_intersect_subspace(primes, {}, "all") == [{}, {'Erk': 1, 'Mek': 1}, {'Erk': 0, 'Mek': 0}, {'Erk': 0, 'Mek': 0, 'Raf': 1}]
def test_known_trap_spaces_for_mapk():
primes = get_primes("grieco_mapk")
tspaces = compute_trap_spaces(primes, type_="min")
assert len(tspaces) == 18
tspaces = compute_trap_spaces(primes, type_="max")
assert len(tspaces) == 9
def test_compute_json():
primes = get_primes("n5s3")
fname = get_tests_path_out(fname="n5s3_attrs.json")
attractors = compute_attractors(primes=primes,
update="asynchronous",
fname_json=fname,
max_output=2)
assert attractors
def test_create_basins_piechart():
try:
primes = get_primes("n5s3")
attractors = compute_attractors(primes, update="asynchronous")
compute_basins(attractors)
fname_image = get_tests_path_out(fname="basins_piechart")
create_basins_piechart(attractors, fname_image=fname_image)
except NameError:
pass
def test_find_minimal_autonomous_nodes():
primes = get_primes("randomnet_n15k3")
igraph = primes2igraph(primes)
nodes = find_minimal_autonomous_nodes(igraph, core=set())
expected = [{
"Gene8", "Gene9", "Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6",
"Gene7", "Gene12", "Gene13", "Gene10", "Gene11", "Gene14"
}]
assert expected == nodes
def test_find_vanham_variables():
primes = get_primes("multivalued")
result = find_vanham_variables(primes)
expected = {
2: ["input", "x2", "x3", "x6_level2"],
3: ["x1"],
4: ["x4"],
5: ["x5"]
}
assert result == expected
def test_energy():
primes = get_primes("raf")
answer = energy(primes, "000")
expected = 1
assert answer == expected
answer = energy(primes, "010")
expected = 3
assert answer == expected
answer = energy(primes, "001")
expected = 0
assert answer == expected
def test_enumerate_states():
primes = get_primes("raf")
prop = "!Erk | (Raf & Mek)"
expected = {"010", "011", "001", "000", "111"}
answer = set(enumerate_states(primes, prop))
assert answer == expected
prop = "0"
expected = set([])
answer = set(enumerate_states(primes, prop))
assert answer == expected
prop = "TRUE"
expected = {"010", "011", "001", "000", "111", "110", "101", "100"}
answer = set(enumerate_states(primes, prop))
assert answer == expected
def test_size_state_space():
primes = get_primes("multivalued")
result = size_state_space(primes, van_ham=False, fixed_inputs=False)
expected = 2**13
assert result == expected
result = size_state_space(primes, van_ham=False, fixed_inputs=True)
expected = 2**12
assert result == expected
result = size_state_space(primes, van_ham=True, fixed_inputs=False)
expected = 2**4*3*4*5
assert result == expected
result = size_state_space(primes, van_ham=True, fixed_inputs=True)
expected = 2**3*3*4*5
assert result == expected
from pyboolnet.repository import get_primes
from pyboolnet.state_transition_graphs import create_stg_image
from pyboolnet.state_transition_graphs import energy, random_walk, add_style_path, add_style_anonymous, stg2image, \
primes2stg
from pyboolnet.state_transition_graphs import sccgraph2image
from pyboolnet.state_transition_graphs import stg2sccgraph, stg2condensationgraph, best_first_reachability
if __name__ == "__main__":
primes = get_primes("xiao_wnt5a")
create_stg_image(primes, "asynchronous", "stg.pdf")
create_stg_image(primes,
"asynchronous",
"stg2.pdf",
initial_states={
"x4": 0,
"x5": 0
},
styles=["anonymous", "tendencies", "mintrapspaces"])
# drawing paths
path = random_walk(primes,
"asynchronous",
initial_state="--00---",
length=4)
stg = primes2stg(primes, "asynchronous", initial_states={"x4": 0, "x5": 0})
add_style_path(stg, path, color="red")
add_style_anonymous(stg)
stg2image(stg, "stg3.pdf")
# drawing factor graphs
from pyboolnet.repository import get_primes
from pyboolnet.state_transition_graphs import primes2stg
from pyboolnet.attractors import compute_attractors_tarjan, compute_attractors, find_attractor_state_by_randomwalk_and_ctl
if __name__ == "__main__":
# attractor computation with Tarjan
primes = get_primes("tournier_apoptosis")
stg = primes2stg(primes, "asynchronous")
steady, cyclic = compute_attractors_tarjan(stg)
print(steady)
print(cyclic)
# random walk attractor detection
state = find_attractor_state_by_randomwalk_and_ctl(primes, "asynchronous")
print(state)
# model checking based attractor detection
attrs = compute_attractors(primes, "asynchronous", fname_json="attrs.json")
print(attrs["is_complete"])
for x in attrs["attractors"]:
print(x["is_steady"])
print(x["state"]["str"])
def test_primes2eqn():
fname_out = get_tests_path_out(fname="fileexchange_primes2eqn.eqn")
primes = get_primes("raf")
primes2eqn(primes, fname_out)
from pyboolnet.repository import get_primes
from pyboolnet.trap_spaces import compute_trap_spaces, compute_steady_states
if __name__ == "__main__":
# compute minimal and maximal trap spaces
primes = get_primes("remy_tumorigenesis")
mints = compute_trap_spaces(primes, "min")
print(len(mints))
max_trap_spaces = compute_trap_spaces(primes, "max")
print(len(max_trap_spaces))
print(max_trap_spaces)
# compute steady states using the ASP solver
steady = compute_steady_states(primes)
print(len(steady))
def primes():
return get_primes("n5s3")
def test_stg2htg():
fname_out = get_tests_path_out(fname="raf_htg.pdf")
primes = get_primes("raf")
stg = primes2stg(primes, "asynchronous")
htg = stg2htg(stg)
htg2image(htg, fname_out)
def test_stg2sccgraph():
fname_out = get_tests_path_out(fname="raf_sccgraph.pdf")
primes = get_primes("raf")
stg = primes2stg(primes, "asynchronous")
scc_graph = stg2sccgraph(stg)
sccgraph2image(scc_graph, fname_out)
def test_compute_basins():
primes = get_primes("n5s3")
attractors = compute_attractors(primes, update="asynchronous")
compute_basins(attractors)
def test_cycle_free_basins():
primes = get_primes("n5s3")
cycle_free_basin(primes, update="asynchronous")
def test_strong_basins():
primes = get_primes("n5s3")
strong_basin(primes, update="asynchronous")
def test_weak_basins():
primes = get_primes("n5s3")
weak_basin(primes, update="asynchronous")
from pyboolnet.phenotypes import compute_phenotypes, compute_phenotype_diagram, create_phenotypes_piechart
from pyboolnet.attractors import compute_attractors
from pyboolnet.repository import get_primes
if __name__ == "__main__":
# compute the commitment diagram
primes = get_primes("arellano_rootstem")
print(sorted(primes))
attractors = compute_attractors(primes, "asynchronous")
markers = ["WOX", "MGP"]
phenotypes = compute_phenotypes(attractors, markers, fname_json="phenos.json")
# inspect marker patterns
for pheno in phenotypes["phenotypes"]:
print(pheno["name"])
print(pheno["pattern"])
# draw diagram
diagram = compute_phenotype_diagram(phenotypes, fname_image="phenos_diagram.pdf")
# draw pie chart
create_phenotypes_piechart(diagram, fname_image="phenos_piechart.pdf")
def attractors():
return compute_attractors(primes=get_primes("raf"), update="asynchronous")
sys.exit(1)
def steady_states_projected(primes: dict, project: List[str] = [], max_output: int = 1000, fname_asp: Optional[str] = None):
print("ERROR: steady_states_projected is removed, use compute_steady_states_projected")
sys.exit(1)
def trapspaces_that_contain_state(primes: dict, state: dict, type_: str, fname_asp: str = None, representation: str = "dict", max_output: int = 1000):
print("ERROR: trapspaces_that_contain_state is removed, use compute_trapspaces_that_contain_state")
sys.exit(1)
def trapspaces_that_intersect_subspace(primes: dict, subspace: dict, type_: str, fname_asp: str = None, representation: str = "dict", max_output: int = 1000):
print("ERROR: trapspaces_that_intersect_subspace is removed, use compute_trapspaces_that_intersect_subspace")
sys.exit(1)
def trapspaces_within_subspace(primes: dict, subspace: dict, type_: str, fname_asp: str = None, representation: str = "dict", max_output: int = 1000):
print("ERROR: trapspaces_within_subspace is removed, use compute_trapspaces_within_subspace")
sys.exit(1)
if __name__ == '__main__':
from pyboolnet.repository import get_primes
from pyboolnet.external.potassco import primes2asp
primes = get_primes("raf")
asp_text = primes2asp(primes, "", None, None, type_="min")
print(asp_text)
def test_trapspaces_that_contain_state_max_output():
primes = get_primes("raf")
answer = compute_trapspaces_that_contain_state(primes, {"Raf": 1, "Mek": 0, "Erk": 0}, "all", max_output=1)
assert len(answer) == 1
assert answer[0] in compute_trapspaces_that_contain_state(primes, {"Raf": 1, "Mek": 0, "Erk": 0}, "all", max_output=1000)
def test_stg2condensationgraph():
fname_out = get_tests_path_out(fname="raf_cgraph.pdf")
primes = get_primes("raf")
stg = primes2stg(primes, "asynchronous")
cgraph = stg2condensationgraph(stg)
condensationgraph2image(cgraph, fname_out)
def test_completeness_max_output():
primes = get_primes("davidich_yeast")
assert completeness(primes, "asynchronous", max_output=10000)
assert not completeness(primes, "asynchronous", max_output=2)
def test_trapspaces_that_contain_state():
primes = get_primes("raf")
assert compute_trapspaces_that_contain_state(primes, {"Raf": 1, "Mek": 0, "Erk": 0}, "min", fname_asp=None) == [{"Raf": 1, "Mek": 0, "Erk": 0}]
assert compute_trapspaces_that_contain_state(primes, {"Raf": 0, "Mek": 1, "Erk": 1}, "min", fname_asp=None) == [{"Mek": 1, "Erk": 1}]
assert compute_trapspaces_that_contain_state(primes, {"Raf": 1, "Mek": 1, "Erk": 0}, "min", fname_asp=None) == [{}]
def test_random_state():
primes = get_primes(name="n6s1c2")
assert type(random_state(primes=primes)) is dict
assert type(random_state(primes=primes, subspace="111-0-")) is dict
def test_create_image():
fname = get_tests_path_out(fname="interactiongraphs_create_image.pdf")
primes = get_primes("raf")
create_image(primes, fname)
from pyboolnet.file_exchange import bnet2primes
from pyboolnet.repository import get_primes
if __name__ == "__main__":
for name in ["tournier_apoptosis", "grieco_mapk", "remy_tumorigenesis", "dahlhaus_neuroplastoma"]:
primes = get_primes(name)
fname = os.path.join(name, name+"_attractors_sync.json")
compute_attractors(primes, update="synchronous", fname_json=fname)
fname = os.path.join(name, name+"_attractors_mixed.json")
compute_attractors(primes, update="mixed", fname_json=fname)
names = get_all_names()
for name in names:
if name == "n12c5":
continue # takes forever to compute prime implicants
primes = bnet2primes(os.path.join(name, name + ".bnet"))
fname = os.path.join(name, name+"_igraph.pdf")
create_stg_image(primes, fname)
names = PyBoolNet.Repository.names_with_fast_analysis()
for name in names:
primes = bnet2primes(os.path.join(name, name + ".bnet"))
fname = os.path.join(name, name+"_attractors.json")
