def compute_primes_or_exit(fname_bnet: str, fname_primes: str) -> dict:
if not os.path.isfile(fname_bnet):
click.echo(f"file does not exist: fname_bnet={fname_bnet}")
sys.exit()
primes = bnet2primes(bnet=fname_bnet)
if fname_primes:
write_primes(primes=primes, fname_json=fname_primes)
return bnet2primes(bnet=fname_bnet)
def test_completeness():
bnet = "\n".join([
"v0, v0", "v1, v2", "v2, v1", "v3, v1&v0", "v4, v2",
"v5, v3&!v6", "v6, v4&v5"
])
primes = bnet2primes(bnet)
assert completeness(primes, "asynchronous")
assert not completeness(primes, "synchronous")
answer, example = completeness_with_counterexample(primes, "synchronous")
example = state2str(example)
stg = primes2stg(primes, "synchronous")
for x in compute_trap_spaces(primes, "min"):
x = subspace2str(primes, x)
states = list_states_in_subspace(primes, x)
states = [state2str(x) for x in states]
assert not has_path(stg, example, states)
bnet = "\n".join([
"v1, !v1&v2&v3 | v1&!v2&!v3", "v2, !v1&!v2 | v1&v3",
"v3, !v1&v3 | v1&v2", "v4, 1", "v5, v4"
])
primes = bnet2primes(bnet)
assert not completeness(primes, "asynchronous")
answer, example = completeness_with_counterexample(primes, "asynchronous")
assert len(example) == len(primes)
assert completeness(primes, "synchronous")
bnet = "\n".join(
["v1, !v1&v2&v3 | v1&!v2&!v3", "v2, !v1&!v2 | v1&v3", "v3, v2 | v3"])
primes = bnet2primes(bnet)
assert completeness(primes, "asynchronous")
assert completeness(primes, "synchronous")
bnet = "\n".join([
"v1, !v2", "v2, v1", "v3, v1", "v4, v2", "v5, v6",
"v6, v4&v5", "v7, v2", "v8, v5", "v9, v6&v10", "v10, v9&v7"
])
primes = bnet2primes(bnet)
assert completeness(primes, "synchronous")
def test_bnet2primes_a():
fname_in = get_tests_path_in(fname="fileexchange_constants.bnet")
fname_out = get_tests_path_out(fname="fileexchange_stdout1.primes")
file_in = "A, 0\nB, 1"
expected = {"A": [[{}], []], "B": [[], [{}]]}
primes = bnet2primes(bnet=fname_in)
assert primes_are_equal(primes, expected)
primes = bnet2primes(bnet=file_in)
assert primes_are_equal(primes, expected)
primes = bnet2primes(bnet=fname_in, fname_primes=fname_out)
assert primes_are_equal(primes, expected)
def random_truth_table_network(n: int, k: int, seed: int = 0) -> dict:
"""
Creates a random netowrk with `n` components each with a random truthtable of `k` inputs.
The `seed` is used for the randomizer.
Use `0` to generate a random seed.
**arguments**:
* *n*: number of components
* *k*: inputs of each truthtable
* *seed*: the seed of the randomizer
**returns**:
* *primes*: primes implicants
**example**::
>>> primes = random_truth_table_network(n=3, k=2)
"""
assert n > 1
assert k < n
assert k < 10
if seed:
random.seed(seed)
names = [f"v{i}" for i in range(n)]
primes = {}
for v in names:
bnet = f"x, {random_boolean_expression(names=names, k=k)}"
primes[v] = bnet2primes(bnet)["x"]
return primes
def test_bnet2primes_missing_inputs():
fname_in = get_tests_path_in(fname="fileexchange_missing_inputs.bnet")
fname_out = get_tests_path_out(fname="fileexchange_missing_inputs.primes")
primes = bnet2primes(bnet=fname_in, fname_primes=fname_out)
primes_expected = {
"B": [[{
"B": 0
}], [{
"B": 1
}]],
"C": [[{
"C": 0
}], [{
"C": 1
}]],
"A": [[{
"B": 0,
"C": 1
}], [{
"C": 0
}, {
"B": 1
}]]
}
assert primes_are_equal(primes, primes_expected), str(primes)
def test_bnet2primes_empty():
fname_in = get_tests_path_in(fname="fileexchange_empty.bnet")
fname_out = get_tests_path_out(fname="fileexchange_empty.primes")
primes = bnet2primes(bnet=fname_in, fname_primes=fname_out)
primes_expected = {}
assert primes_are_equal(primes, primes_expected), str(primes)
def test_compute_attractors_tarjan():
bnet = "\n".join(["x, !x&y | z", "y, !x | !z", "z, x&!y"])
primes = bnet2primes(bnet)
stg = primes2stg(primes, "asynchronous")
steady_states, cyclic = compute_attractors_tarjan(stg)
assert steady_states == ["101"]
assert cyclic == [{"010", "110"}]
def test_univocality3():
bnet = "\n".join(
["v1, !v1&!v2 | !v3", "v2, v1&v2", "v3, v1&v3 | v2", "v4, 0"])
primes = bnet2primes(bnet)
tspace = {"v1": 0}
answer = univocality(primes, "asynchronous", tspace)
assert answer
def test_steady_states_projected():
bnet = "\n".join(["x, !x&!y | x&y", "y, y", "z, z"])
primes = bnet2primes(bnet)
result = compute_steady_states_projected(primes, ["y", "x"])
result.sort(key=lambda x: tuple(sorted(x.items())))
assert result == [{"x": 0, "y": 1}, {"x": 1, "y": 1}]
def test_bnet2primes_constants():
fname_in = get_tests_path_in(fname="fileexchange_constants.bnet")
fname_out = get_tests_path_out(fname="fileexchange_constants.primes")
primes = bnet2primes(bnet=fname_in, fname_primes=fname_out)
primes_expected = {"A": [[{}], []], "B": [[], [{}]]}
assert primes_are_equal(primes, primes_expected), str(primes)
def test_univocality2():
bnet = "\n".join(
["v1, !v1&!v2 | !v3", "v2, v1&v2", "v3, v1&v3 | v2", "v4, 0"])
primes = bnet2primes(bnet)
answer, example = univocality_with_counterexample(primes, "asynchronous",
{})
assert example is None
def test_best_first_reachability():
primes = bnet2primes(
bnet=get_tests_path_in(fname="randomnet.bnet"),
fname_primes=get_tests_path_out(fname="randomnet.primes"))
initial_space = dict([("Gene%i" % (i + 1), i % 2) for i in range(20)])
goal_space = {"Gene2": 0, "Gene4": 0, "Gene6": 0, "Gene8": 0}
memory = 10000
path = best_first_reachability(primes, initial_space, goal_space, memory)
assert path is not None
def test_univocality():
bnet = "\n".join(
["v1, !v1&!v2 | v2&!v3", "v2, v1&v2", "v3, v2 | v3", "v4, 1"])
primes = bnet2primes(bnet)
univocality(primes, "asynchronous", {"v4": 1})
assert not univocality(primes, "asynchronous", {"v4": 1})
answer, example = univocality_with_counterexample(primes, "asynchronous",
{})
assert (len(example[0]), len(example[1])) == (4, 4)
primes = bnet2primes("""v1, 0 \n v2, v2""")
tspace = {"v1": 0}
answer, example = univocality_with_counterexample(primes, "asynchronous",
tspace)
expected = [{"v1": 0, "v2": 0}, {"v1": 0, "v2": 1}]
assert example[0] in expected
assert example[1] in expected
assert len(example) == 2
def test_bnet2primes_operatorbinding():
fname_in = get_tests_path_in(fname="fileexchange_operatorbinding.bnet")
fname_out = get_tests_path_out(fname="fileexchange_operatorbinding.primes")
primes = bnet2primes(bnet=fname_in, fname_primes=fname_out)
names = "abcde"
results = []
for x in names:
for y in names:
name = x
results.append(
primes_are_equal({name: primes[x]}, {name: primes[y]}))
assert all(results)
def test_faithfulness():
bnet = "\n".join([
"v1, !v1&!v2 | !v2&!v3", "v2, !v1&!v2&v3 | v1&!v3", "v3, !v1&v3 | !v2"
])
primes = bnet2primes(bnet)
assert not faithfulness(primes, "asynchronous", {})
assert faithfulness(primes, "asynchronous", {"v3": 1})
primes = bnet2primes("""v1, 0 \n v2, v1 \n v3, v3""")
answer, example = faithfulness_with_counterexample(primes, "asynchronous",
{"v1": 0})
assert not answer
assert example in [{
"v1": 0,
"v2": 0,
"v3": 0
}, {
"v1": 0,
"v2": 0,
"v3": 1
}]
def test_completeness_naive():
bnet = "\n".join(
["v1, v1 | v2&!v3", "v2, !v1&v2&v3", "v3, !v2&!v3 | v2&v3"])
primes = bnet2primes(bnet)
answer = completeness_naive(primes, "asynchronous", ["00-", "10-"])
assert not answer
assert completeness_naive(primes, "asynchronous",
["00-", "10-", {
"v1": 0,
"v2": 1,
"v3": 1
}])
def test_find_attractor_state_by_randomwalk_and_ctl():
fname_in = get_tests_path_in(fname="randomnet.bnet")
fname_out = get_tests_path_out(fname="randomnet.primes")
primes = bnet2primes(bnet=fname_in, fname_primes=fname_out)
subspace = {"Gene1": 0, "Gene3": 0, "Gene5": 0, "Gene7": 0, "Gene9": 0}
length = 200
attempts = 10
min_trap_spaces = {
"Gene1": 1,
"Gene11": 0,
"Gene12": 1,
"Gene13": 0,
"Gene14": 1,
"Gene15": 0,
"Gene16": 1,
"Gene17": 1,
"Gene18": 1,
"Gene19": 0,
"Gene2": 1,
"Gene20": 1,
"Gene3": 0,
"Gene4": 1,
"Gene5": 0,
"Gene6": 0,
"Gene8": 0,
"Gene9": 0
}
x = find_attractor_state_by_randomwalk_and_ctl(primes, "asynchronous",
subspace, length, attempts)
assert state_is_in_subspace(primes, x, min_trap_spaces)
y = find_attractor_state_by_randomwalk_and_ctl(primes, "synchronous",
subspace, length, attempts)
reachable = list_reachable_states(primes, "synchronous", y, 100)
assert state2str(y) in reachable
z = find_attractor_state_by_randomwalk_and_ctl(primes, "mixed", subspace,
length, attempts)
assert state_is_in_subspace(primes, z, min_trap_spaces)
def test_bnet2primes_results():
fname_in = get_tests_path_in(fname="fileexchange_feedback.bnet")
fname_out = get_tests_path_out(fname="fileexchange_feedback.primes")
primes = bnet2primes(bnet=fname_in, fname_primes=fname_out)
primes_expected = {
"v1": [[{
"v2": 0
}], [{
"v2": 1
}]],
"v2": [[{
"v2": 0
}, {
"v1": 1
}], [{
"v1": 0,
"v2": 1
}]]
}
assert primes_are_equal(primes, primes_expected)
def get_primes(name: str) -> dict:
"""
Returns the prime implicants of the network *name* in the model repository.
Run :ref:`get_all_names` to see all networks currently available.
**arguments**:
* *name*: name of network
**returns**:
* *primes*: the prime implicants
**example**::
>>> primes = get_primes("raf")
"""
path = os.path.join(BASE, name, name + ".bnet")
if os.path.isfile(path):
return bnet2primes(path)
print(" %s does not exist"%path)
raise FileNotFoundError
def test_encoding_bijection():
"""
The mapping from stable and consistent prime implicant sets to trap spaces is surjective but not injective.
Two different arc sets may lead to the same trap space.
In the following example there are four trap stable+consistent arc sets but only two trap spaces.
"""
bnet = "\n".join(["v1,v1|v2", "v2,v1"])
primes = bnet2primes(bnet)
result = compute_trap_spaces(primes, "all")
result.sort(key=lambda x: tuple(sorted(x.items())))
assert result == [{}, {"v1": 0, "v2": 0}, {"v1": 1}, {"v1": 1, "v2": 1}]
result = compute_trap_spaces(primes, "min")
result.sort(key=lambda x: tuple(sorted(x.items())))
assert result == [{"v1": 0, "v2": 0}, {"v1": 1, "v2": 1}]
result = compute_trap_spaces(primes, "max")
result.sort(key=lambda x: tuple(sorted(x.items())))
assert result == [{"v1": 0, "v2": 0}, {"v1": 1}]
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")
attractors = compute_attractors(primes, update="asynchronous", fname_json=fname)
markers = find_outputs(primes)
if markers:
fname = os.path.join(name, name+"_phenos.json")
def test_trap_spaces_bounded():
fname_in = get_tests_path_in(fname="trapspaces_bounded.bnet")
fname_out = get_tests_path_out(fname="trapspaces_bounded.primes")
primes = bnet2primes(fname_in, fname_out)
tspaces_all = compute_trap_spaces(primes, "all")
tspaces_all.sort(key=lambda x: tuple(sorted(x.items())))
expected = [{},
{"v3": 1},
{"v3": 0},
{"v1": 1},
{"v1": 1, "v2": 1},
{"v1": 0, "v2": 0},
{"v3": 1, "v4": 1},
{"v1": 1, "v3": 0},
{"v1": 1, "v3": 1},
{"v1": 1, "v2": 1, "v3": 1},
{"v1": 1, "v3": 1, "v4": 1},
{"v1": 1, "v2": 1, "v3": 0},
{"v1": 0, "v2": 0, "v3": 0},
{"v1": 0, "v2": 0, "v3": 1},
{"v1": 1, "v2": 1, "v4": 1},
{"v1": 0, "v2": 0, "v3": 1, "v4": 1},
{"v1": 1, "v2": 1, "v3": 0, "v4": 1},
{"v1": 1, "v2": 1, "v3": 1, "v4": 1},
{"v1": 0, "v2": 0, "v3": 0, "v4": 0}]
expected.sort(key=lambda x: tuple(sorted(x.items())))
assert tspaces_all == expected
tspaces_min = compute_trap_spaces(primes, "min")
tspaces_min.sort(key=lambda x: tuple(sorted(x.items())))
expected = [
{"v1": 0, "v2": 0, "v3": 0, "v4": 0},
{"v1": 1, "v2": 1, "v3": 1, "v4": 1},
{"v1": 0, "v2": 0, "v3": 1, "v4": 1},
{"v1": 1, "v2": 1, "v3": 0, "v4": 1}]
expected.sort(key=lambda x: tuple(sorted(x.items())))
assert tspaces_min == expected
tspaces_max = compute_trap_spaces(primes, "max")
tspaces_max.sort(key=lambda x: tuple(sorted(x.items())))
expected = [{"v3": 1}, {"v3": 0}, {"v1": 1}, {"v1": 0, "v2": 0}]
expected.sort(key=lambda x: tuple(sorted(x.items())))
assert tspaces_max == expected
tspaces_bounded = compute_trap_spaces_bounded(primes, "max", bounds=(1, 1))
tspaces_bounded.sort(key=lambda x: tuple(sorted(x.items())))
expected = [{"v3": 1}, {"v3": 0}, {"v1": 1}]
expected.sort(key=lambda x: tuple(sorted(x.items())))
assert tspaces_bounded == expected
tspaces_bounded = compute_trap_spaces_bounded(primes, "max", bounds=(2, 3))
tspaces_bounded.sort(key=lambda x: tuple(sorted(x.items())))
expected = [{"v1": 1, "v2": 1},
{"v1": 0, "v2": 0},
{"v3": 1, "v4": 1},
{"v1": 1, "v3": 0},
{"v1": 1, "v3": 1}]
expected.sort(key=lambda x: tuple(sorted(x.items())))
assert tspaces_bounded == expected
tspaces_bounded = compute_trap_spaces_bounded(primes, "all", bounds=(2, 3))
tspaces_bounded.sort(key=lambda x: tuple(sorted(x.items())))
expected = [
{"v1": 1, "v2": 1},
{"v1": 0, "v2": 0},
{"v3": 1, "v4": 1},
{"v1": 1, "v3": 0},
{"v1": 1, "v3": 1},
{"v1": 1, "v2": 1, "v3": 1},
{"v1": 1, "v3": 1, "v4": 1},
{"v1": 1, "v2": 1, "v3": 0},
{"v1": 0, "v2": 0, "v3": 0},
{"v1": 0, "v2": 0, "v3": 1},
{"v1": 1, "v2": 1, "v4": 1}]
expected.sort(key=lambda x: tuple(sorted(x.items())))
assert tspaces_bounded == expected
tspaces_bounded = compute_trap_spaces_bounded(primes, "min", bounds=(2, 3))
tspaces_bounded.sort(key=lambda x: tuple(sorted(x.items())))
expected = [
{"v1": 1, "v2": 1, "v3": 1},
{"v1": 1, "v3": 1, "v4": 1},
{"v1": 1, "v2": 1, "v3": 0},
{"v1": 0, "v2": 0, "v3": 0},
{"v1": 0, "v2": 0, "v3": 1},
{"v1": 1, "v2": 1, "v4": 1}]
expected.sort(key=lambda x: tuple(sorted(x.items())))
assert tspaces_bounded == expected
def test_successor_synchronous():
primes = bnet2primes(
bnet=get_tests_path_in(fname="randomnet.bnet"),
fname_primes=get_tests_path_out(fname="randomnet.primes"))
state = dict([("Gene%i" % (i + 1), i % 2) for i in range(20)])
successor_synchronous(primes, state)
def test_random_mixed_transition():
primes = bnet2primes(
bnet=get_tests_path_in(fname="randomnet.bnet"),
fname_primes=get_tests_path_out(fname="randomnet.primes"))
state = dict([("Gene%i" % (i + 1), i % 2) for i in range(20)])
random_successor_mixed(primes, state)
from pyboolnet.file_exchange import bnet2primes, primes2bnet
from pyboolnet.prime_implicants import find_constants, create_variables
from pyboolnet.repository import get_primes
if __name__ == "__main__":
bnet = """
v1, !v1
v2, 1
v3, v2 & (!v1 | v3)
"""
primes = bnet2primes(bnet)
# finding nodes
const = find_constants(primes)
print(const)
# modifying networks
create_variables(primes, {"v4": "v4 | v2"})
create_variables(primes, {"v5": lambda v1, v2, v3: v1 + v2 + v3 == 1})
print(primes2bnet(primes))
# reading from the repository
primes = get_primes("remy_tumorigenesis")
print(primes2bnet(primes))
