def test_filter_first():
net = ReteNetwork()
@Production(Filter(lambda: True))
def test():
pass
net.add_production(test)
assert len(list(net.matches)) == 1
def test_empty_prod():
net = ReteNetwork()
@Production()
def test():
pass
net.add_production(test)
len(list(net.matches)) == 1
def test_production():
class Block(Fact):
pass
@Production(Block(name=V('x'), clear=True))
def is_clear(x):
print(x)
net = ReteNetwork()
net.add_production(is_clear)
def test_bind_first():
net = ReteNetwork()
@Production(Bind(lambda: 1 + 1, V('x')))
def test(x):
pass
net.add_production(test)
assert len(list(net.matches)) == 1
def init_network():
net = ReteNetwork()
c0 = Cond(V('x'), 'on', V('y'))
c1 = Cond(V('y'), 'left-of', V('z'))
c2 = Cond(V('z'), 'color', 'red')
@Production(AND(c0, c1, c2))
def test():
pass
net.add_production(test)
return net
def test_multi_productions():
net = ReteNetwork()
c0 = Cond(V('x'), 'on', V('y'))
c1 = Cond(V('y'), 'left-of', V('z'))
c2 = Cond(V('z'), 'color', 'red')
c3 = Cond(V('z'), 'on', 'table')
c4 = Cond(V('z'), 'left-of', 'B4')
@Production(AND(c0, c1, c2))
def p0():
pass
@Production(AND(c0, c1, c3, c4))
def p1():
pass
net.add_production(p0)
net.add_production(p1)
wmes = [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
WME('B3', 'color', 'red'),
]
for wme in wmes:
net.add_wme(wme)
# add product on the fly
@Production(AND(c0, c1, c3, c2))
def p2():
pass
net.add_production(p2)
assert len(list(p0.activations)) == 1
assert len(list(p1.activations)) == 1
assert len(list(p2.activations)) == 1
assert list(p0.activations)[0].wmes == [wmes[0], wmes[4], wmes[8]]
assert list(p1.activations)[0].wmes == [wmes[0], wmes[4], wmes[7], wmes[6]]
assert list(p2.activations)[0].wmes == [wmes[0], wmes[4], wmes[7], wmes[8]]
net.remove_production(p2)
print(type(p2))
assert len(list(p2.activations)) == 0
def test_intra_condition_consistency():
net = ReteNetwork()
c = Cond(V('x'), 'b', V('x'))
@Production(c)
def test():
pass
net.add_production(test)
wme = WME('a', 'b', 'c')
net.add_wme(wme)
assert len(list(net.matches)) == 0
c2 = Cond(V('x'), 'b', V('z'))
@Production(c2)
def test2():
pass
net.add_production(test2)
assert len(list(net.matches)) == 1
def test_ncc():
net = ReteNetwork()
c0 = Cond(V('x'), 'on', V('y'))
c1 = Cond(V('y'), 'left-of', V('z'))
c2 = Cond(V('z'), 'color', 'red')
c3 = Cond(V('z'), 'on', V('w'))
# @Production(AND(c0, c1, NOT(AND(c2, c3))))
@Production(c0 & c1 & ~(c2 & c3))
def p0():
pass
net.add_production(p0)
wmes = [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
]
for wme in wmes:
net.add_wme(wme)
assert len(list(p0.activations)) == 2
net.add_wme(WME('B3', 'color', 'red'))
assert len(list(p0.activations)) == 1
def test_activation():
net = ReteNetwork()
c0 = Cond(V('x'), 'on', V('y'))
c1 = Cond(V('y'), 'color', 'red')
@Production(AND(c0, c1))
def p():
pass
net.add_production(p)
activations = [p for p in net.matches]
assert len(activations) == 0
wmes = [WME('B1', 'on', 'B2'), WME('B2', 'color', 'red')]
for wme in wmes:
net.add_wme(wme)
print(net.working_memory)
print(net)
activations = [p for p in net.matches]
assert len(activations) == 1
net.remove_wme(wmes[0])
activations = [p for p in net.matches]
assert len(activations) == 0
def test_dup():
# setup
net = ReteNetwork()
c0 = Cond(V('x'), 'self', V('y'))
c1 = Cond(V('x'), 'color', 'red')
c2 = Cond(V('y'), 'color', 'red')
@Production(AND(c0, c1, c2))
def p0():
pass
net.add_production(p0)
wmes = [
WME('B1', 'self', 'B1'),
WME('B1', 'color', 'red'),
]
for wme in wmes:
net.add_wme(wme)
# end
am = net.build_or_share_alpha_memory(c2)
join_on_value_y = am.successors[1]
match_for_all = join_on_value_y.children[0]
assert len(match_for_all.items) == 1
def test_add_remove_not():
net = ReteNetwork()
@Production(~Cond('a', 'on', 'b'))
def not_fun():
pass
net.add_production(not_fun)
assert len(net.beta_root.children) == 1
assert len(list(net.matches)) == 1
wme = WME('a', 'on', 'b')
net.add_wme(wme)
assert len(list(net.matches)) == 0
net.remove_wme(wme)
assert len(list(net.matches)) == 1
net.remove_production(not_fun)
assert len(net.beta_root.children) == 0
def test_black_white():
net = ReteNetwork()
c1 = Cond(V('item'), 'cat', V('cid'))
c2 = Cond(V('item'), 'shop', V('sid'))
white = Ncc(
Neg(V('item'), 'cat', '100'),
Neg(V('item'), 'cat', '101'),
Neg(V('item'), 'cat', '102'),
)
n1 = Neg(V('item'), 'shop', '1')
n2 = Neg(V('item'), 'shop', '2')
n3 = Neg(V('item'), 'shop', '3')
@Production(AND(c1, c2, white, n1, n2, n3))
def p0():
pass
net.add_production(p0)
wmes = [
WME('item:1', 'cat', '101'),
WME('item:1', 'shop', '4'),
WME('item:2', 'cat', '100'),
WME('item:2', 'shop', '1'),
]
for wme in wmes:
net.add_wme(wme)
assert len(list(p0.activations)) == 1
assert list(p0.activations)[0].binding[V('item')] == 'item:1'
def test_negative_condition():
# setup
net = ReteNetwork()
c0 = Cond(V('x'), 'on', V('y'))
c1 = Cond(V('y'), 'left-of', V('z'))
c2 = Neg(V('z'), 'color', 'red')
@Production(AND(c0, c1, c2))
def p0():
pass
net.add_production(p0)
# end
wmes = [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
WME('B3', 'color', 'red'),
]
for wme in wmes:
net.add_wme(wme)
am0 = net.build_or_share_alpha_memory(c0)
am1 = net.build_or_share_alpha_memory(c1)
am2 = net.build_or_share_alpha_memory(c2)
dummy_join = am0.successors[0]
join_on_value_y = am1.successors[0]
join_on_value_z = am2.successors[0]
match_c0 = dummy_join.children[0]
match_c0c1 = join_on_value_y.children[0]
match_c0c1c2 = join_on_value_z.children[0]
print(match_c0.items)
print(match_c0c1.items)
print(type(join_on_value_z))
print(match_c0c1c2.items)
assert list(p0.activations)[0].wmes == [
WME('B1', 'on', 'B3'),
WME('B3', 'left-of', 'B4'), None
]
def test_filter_second():
net = ReteNetwork()
net.add_fact(Fact())
@Production(Fact() & Filter(lambda: True) & Fact())
def test():
pass
net.add_production(test)
assert len(list(net.matches)) == 1
def test_add_remove_empty():
net = ReteNetwork()
@Production()
def empty():
pass
net.add_production(empty)
assert len(net.beta_root.children) == 1
net.remove_production(empty)
assert len(net.beta_root.children) == 0
def test_add_remove_filter():
net = ReteNetwork()
@Production(Filter(lambda: True))
def filter_fun():
pass
net.add_production(filter_fun)
assert len(net.beta_root.children) == 1
net.remove_production(filter_fun)
assert len(net.beta_root.children) == 0
def test_add_remove_bind():
net = ReteNetwork()
@Production(Bind(lambda: 5, V('x')))
def bind(x):
return x
net.add_production(bind)
assert len(net.beta_root.children) == 1
assert list(net.matches)[0].fire() == 5
net.remove_production(bind)
assert len(net.beta_root.children) == 0
def test_adding_removing_facts():
net = ReteNetwork()
f = Fact()
net.add_fact(f)
assert f.id is not None
assert len(net.working_memory) > 0
net.remove_fact(f)
assert f.id is None
assert len(net.working_memory) == 0
def fire_counting():
net = ReteNetwork()
@Production(
Fact(number=V('x')) & ~Fact(before=V('x'))
& Bind(lambda x: str(int(x) + 1), V('y')))
def add1(net, x, y):
f = Fact(number=y, before=x)
net.add_fact(f)
net.add_production(add1)
assert len(net.wmes) == 0
net.add_fact(Fact(number='1'))
assert len(net.wmes) == 2
print(net)
for i in range(5):
net.run(1)
assert len(net.wmes) == (3 * (i + 1)) + 2
def test_root():
# network is root, uses hash
net = ReteNetwork()
c0 = Cond('a', 'b', 'c')
am0 = net.build_or_share_alpha_memory(c0)
assert am0 is not None
am1 = net.build_or_share_alpha_memory(c0)
assert am0 == am1
assert len(net.alpha_hash) == 1
wme = WME('a', 'b', 'c')
net.add_wme(wme)
assert len(am0.items) == 1
def add_to_depth():
net = ReteNetwork()
@Production(
Fact(number=V('x'), depth=V('xd')) & Fact(number=V('y'), depth=V('yd'))
& Filter(lambda xd, yd: xd + yd < 1))
def add(net, x, y, xd, yd):
f = Fact(number=x + y, depth=xd + yd + 1)
net.add_fact(f)
net.add_fact(Fact(name="1", number=1, depth=0))
net.add_fact(Fact(name="2", number=2, depth=0))
# net.add_fact(Fact(name="3", number=3, depth=0))
# net.add_fact(Fact(name="5", number=5, depth=0))
# net.add_fact(Fact(name="7", number=7, depth=0))
net.add_production(add)
while len(list(net.new_matches)) > 0:
# print(len(list(net.new_matches)))
m = net.get_new_match()
m.fire()
def test_facts():
net = ReteNetwork()
wmes = [e for e in net.wmes]
assert len(wmes) == 0
wmes = set([WME('B1', 'on', 'B2'), WME('B2', 'color', 'red')])
for wme in wmes:
net.add_wme(wme)
stored_wmes = set([e for e in net.wmes])
assert len(stored_wmes) == 2
assert len(wmes.union(stored_wmes)) == 2
wmes = list(wmes)
net.remove_wme(wmes[0])
stored_wmes = [e for e in net.wmes]
assert len(stored_wmes) == 1
assert stored_wmes == wmes[1:]
def test_network_case1():
# setup
net = ReteNetwork()
c0 = Cond(V('x'), 'on', V('y'))
c1 = Cond(V('y'), 'left-of', V('z'))
c2 = Cond(V('z'), 'color', 'red')
@Production(AND(c0, c1, c2))
def p0():
pass
net.add_production(p0)
# end
wmes = [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
WME('B3', 'color', 'red')
]
for wme in wmes:
net.add_wme(wme)
am0 = net.build_or_share_alpha_memory(c0)
am1 = net.build_or_share_alpha_memory(c1)
am2 = net.build_or_share_alpha_memory(c2)
dummy_join = am0.successors[0]
join_on_value_y = am1.successors[0]
join_on_value_z = am2.successors[0]
match_c0 = dummy_join.children[0]
match_c0c1 = join_on_value_y.children[0]
match_c0c1c2 = join_on_value_z.children[0]
assert am0.items == [wmes[0], wmes[1], wmes[3], wmes[7]]
assert am1.items == [wmes[4], wmes[6]]
assert am2.items == [wmes[2], wmes[8]]
assert len(match_c0.items) == 4
assert len(match_c0c1.items) == 2
assert len(match_c0c1c2.items) == 1
t0 = Token(Token(None, None), wmes[0])
t1 = Token(t0, wmes[4])
t2 = Token(t1, wmes[8])
assert match_c0c1c2.items[0] == t2
print(wmes[0].tokens)
print(match_c0.items)
print(match_c0c1.items)
print(match_c0c1c2.items)
print()
net.remove_wme(wmes[0])
print(wmes[0].tokens)
print(match_c0.items)
print(match_c0c1.items)
print(match_c0c1c2.items)
assert am0.items == [wmes[1], wmes[3], wmes[7]]
assert am1.items == [wmes[4], wmes[6]]
assert am2.items == [wmes[2], wmes[8]]
assert len(match_c0.items) == 3
assert len(match_c0c1.items) == 1
assert len(match_c0c1c2.items) == 0
def test_add_remove_ncc():
net = ReteNetwork()
@Production(~Fact(first="hello", second="world"))
def ncc_fun():
pass
net.add_production(ncc_fun)
assert len(net.beta_root.children) == 2
assert len(list(net.matches)) == 1
wme = WME('a', 'on', 'b')
net.add_wme(wme)
f = Fact(first='hello', second='world')
net.add_fact(f)
assert len(list(net.matches)) == 0
net.remove_fact(f)
assert len(list(net.matches)) == 1
net.remove_production(ncc_fun)
assert len(net.beta_root.children) == 0
def test_readme_network():
net = ReteNetwork()
f1 = Fact(light_color="red")
net.add_fact(f1)
f1['light_color'] = "green"
net.update_fact(f1)
net.remove_fact(f1)
f1 = Fact(light_color="red")
@Production(V('fact') << Fact(light_color="red"))
def make_green(net, fact):
print('making green')
fact['light_color'] = 'green'
net.update_fact(fact)
@Production(V('fact') << Fact(light_color="green"))
def make_red(net, fact):
print('making red')
fact['light_color'] = 'red'
net.update_fact(fact)
light_net = ReteNetwork()
light_net.add_fact(f1)
light_net.add_production(make_green)
light_net.add_production(make_red)
light_net.update_fact(f1)
# print(light_net)
light_net.run(5)
matches = list(light_net.matches)
print(matches)
new = list(light_net.new_matches) # noqa E262
matches[0].fire()
def test_network_case0():
net = ReteNetwork()
c0 = Cond('x', 'id', '1')
c1 = Cond('x', 'kind', '8')
@Production(AND(c0, c1))
def p0():
pass
net.add_production(p0)
w0 = WME('x', 'id', '1')
w1 = WME('x', 'kind', '8')
net.add_wme(w0)
assert len(list(p0.activations)) == 0
net.remove_wme(w0)
net.add_wme(w1)
assert len(list(p0.activations)) == 0
net.add_wme(w0)
net.add_wme(w1)
assert len(list(p0.activations)) > 0
