示例#1
0
def test_retematcher_changes_are_propagated(TestNode):
    from pyknow.engine import KnowledgeEngine
    from pyknow.fact import Fact
    from pyknow.matchers.rete import ReteMatcher
    from pyknow.matchers.rete.token import Token

    matcher = ReteMatcher(KnowledgeEngine())
    tn1 = TestNode()
    tn2 = TestNode()

    matcher.root_node.add_child(tn1, tn1.activate)
    matcher.root_node.add_child(tn2, tn2.activate)

    f1 = Fact(__factid__=1)
    f2 = Fact(__factid__=2)
    f3 = Fact(__factid__=3)
    f4 = Fact(__factid__=4)

    matcher.changes(adding=[f1, f2], deleting=[f3, f4])

    assert Token.valid(f1) in tn1.added
    assert Token.valid(f1) in tn2.added
    assert Token.valid(f2) in tn1.added
    assert Token.valid(f2) in tn2.added
    assert Token.invalid(f3) in tn1.added
    assert Token.invalid(f3) in tn2.added
    assert Token.invalid(f4) in tn1.added
    assert Token.invalid(f4) in tn2.added
示例#2
0
def test_ordinarymatchnode_left_activate_invalid_build_new_tokens(TestNode):
    from pyknow.matchers.rete.nodes import OrdinaryMatchNode
    from pyknow.matchers.rete.token import Token
    from pyknow.fact import Fact

    omn = OrdinaryMatchNode(lambda l, r: True)
    tn1 = TestNode()
    tn2 = TestNode()
    omn.add_child(tn1, tn1.activate)
    omn.add_child(tn2, tn2.activate)

    rt1 = Token.valid(Fact(rightdata='rightdata1'))
    rt2 = Token.valid(Fact(rightdata='rightdata2'))
    omn.right_memory.append(rt1.to_info())
    omn.right_memory.append(rt2.to_info())

    token = Token.invalid(Fact(leftdata='leftdata'))
    omn.activate_left(token)

    assert tn1.added == [Token.invalid([Fact(leftdata='leftdata'),
                                        Fact(rightdata='rightdata1')]),
                         Token.invalid([Fact(leftdata='leftdata'),
                                        Fact(rightdata='rightdata2')])]

    assert tn2.added == [Token.invalid([Fact(leftdata='leftdata'),
                                        Fact(rightdata='rightdata1')]),
                         Token.invalid([Fact(leftdata='leftdata'),
                                        Fact(rightdata='rightdata2')])]
示例#3
0
def test_busnode_remove(TestNode):
    from pyknow.matchers.rete.nodes import BusNode
    from pyknow.matchers.rete.token import Token
    from pyknow.fact import Fact

    bn = BusNode()
    tn1 = TestNode()
    tn2 = TestNode()

    bn.add_child(tn1, tn1.activate)
    bn.add_child(tn2, tn2.activate)

    bn.remove(Fact())

    assert tn1.added == [Token.invalid(Fact())]
    assert tn2.added == [Token.invalid(Fact())]
示例#4
0
def test_notnode_right_activate_valid_match_just_one(TestNode):
    from pyknow.matchers.rete.nodes import NotNode
    from pyknow.matchers.rete.token import Token
    from pyknow.fact import Fact

    nn = NotNode(lambda l, r: True)
    tn1 = TestNode()
    tn2 = TestNode()

    nn.add_child(tn1, tn1.activate)
    nn.add_child(tn2, tn2.activate)

    token = Token.valid(Fact(test='data'))

    nn.left_memory[token.to_info()] = 0

    nn.activate_right(token)

    assert Token.invalid(Fact(test='data')) in tn1.added
    assert Token.invalid(Fact(test='data')) in tn2.added
    assert nn.left_memory[token.to_info()] == 1
示例#5
0
def test_ordinarymatchnode_left_activate_invalid_remove_from_left_memory():
    from pyknow.matchers.rete.nodes import OrdinaryMatchNode
    from pyknow.matchers.rete.token import Token
    from pyknow.fact import Fact

    omn = OrdinaryMatchNode(lambda l, r: True)

    fact = Fact(test='data')
    token = Token.valid(fact)
    omn.left_memory.append(token.to_info())

    omn.activate_left(Token.invalid(fact))

    assert not omn.left_memory
示例#6
0
def test_conflictsetchange_invalid_removes_from_memory():
    from pyknow.fact import Fact
    from pyknow.matchers.rete.nodes import ConflictSetNode
    from pyknow.matchers.rete.token import Token, TokenInfo
    from pyknow.rule import Rule

    csn = ConflictSetNode(Rule())

    f = Fact(test='data')
    f.__factid__ = 1

    csn.memory.add(TokenInfo([f], {'mycontextdata': 'data'}))

    csn.activate(Token.invalid(f, {'mycontextdata': 'data'}))

    assert not csn.memory
示例#7
0
def test_token_shortcut_invalid():
    from pyknow.matchers.rete.token import Token

    assert Token.invalid([]) == Token(Token.TagType.INVALID, [])