def cyk(self, q):
g = ContextFree.prepare_for_cyk(self.grammar)
if not q:
q = [EPS]
try:
cyk(g, q)
except BaseException:
return False
return True
def test_shouldParseCorrectTypesForThreeLoops(self):
parsed = cyk(self.g, [2, 0, 0, 0, 1])
self.assertIsInstance(parsed, S)
self.assertIsInstance(parsed.to_rule, SAB)
self.assertIsInstance(parsed.to_rule.to_symbols[0], A)
self.assertIsInstance(parsed.to_rule.to_symbols[1], B)
a1 = parsed.to_rule.to_symbols[0]
b = parsed.to_rule.to_symbols[1]
self.assertIsInstance(b.to_rule, B1)
self.assertIsInstance(b.to_rule.to_symbols[0], Terminal)
self.assertIsInstance(a1.to_rule, AAC)
self.assertIsInstance(a1.to_rule.to_symbols[0], A)
self.assertIsInstance(a1.to_rule.to_symbols[1], C)
a2 = a1.to_rule.to_symbols[0]
c1 = a1.to_rule.to_symbols[1]
self.assertIsInstance(c1.to_rule, C0)
self.assertIsInstance(c1.to_rule.to_symbols[0], Terminal)
self.assertIsInstance(a2.to_rule, AAC)
self.assertIsInstance(a2.to_rule.to_symbols[0], A)
self.assertIsInstance(a2.to_rule.to_symbols[1], C)
a3 = a2.to_rule.to_symbols[0]
c2 = a2.to_rule.to_symbols[1]
self.assertIsInstance(c2.to_rule, C0)
self.assertIsInstance(c2.to_rule.to_symbols[0], Terminal)
self.assertIsInstance(a3.to_rule, AAC)
self.assertIsInstance(a3.to_rule.to_symbols[0], A)
self.assertIsInstance(a3.to_rule.to_symbols[1], C)
a4 = a3.to_rule.to_symbols[0]
c3 = a3.to_rule.to_symbols[1]
self.assertIsInstance(c3.to_rule, C0)
self.assertIsInstance(c3.to_rule.to_symbols[0], Terminal)
self.assertIsInstance(a4.to_rule, A2)
self.assertIsInstance(a4.to_rule.to_symbols[0], Terminal)
def test_simpleTestOverUnitRule(self):
g = Grammar(terminals=[0, 1],
nonterminals=[S, A, B, C, D],
rules=[RuleS1AB, RuleB0, RuleACD, RuleCD, RuleDEps],
start_symbol=S)
gr = ContextFree.transform_to_chomsky_normal_form(
ContextFree.remove_unit_rules(
ContextFree.remove_rules_with_epsilon(g)))
pars = cyk(gr, [1, 0])
s = InverseContextFree.epsilon_rules_restore(
InverseContextFree.unit_rules_restore(
InverseContextFree.transform_from_chomsky_normal_form(pars)))
self.assertIsInstance(s, S)
self.assertIsInstance(s.to_rule, RuleS1AB)
self.assertIsInstance(s.to_rule.to_symbols[0], Terminal)
self.assertEqual(s.to_rule.to_symbols[0].s, 1)
b = s.to_rule.to_symbols[2]
self.assertIsInstance(b, B)
self.assertIsInstance(b.to_rule, RuleB0)
self.assertIsInstance(b.to_rule.to_symbols[0], Terminal)
self.assertEqual(b.to_rule.to_symbols[0].s, 0)
a = s.to_rule.to_symbols[1]
self.assertIsInstance(a, A)
self.assertIsInstance(a.to_rule, RuleACD)
d = a.to_rule.to_symbols[1]
self.assertIsInstance(d, D)
self.assertIsInstance(d.to_rule, RuleDEps)
self.assertIs(d.to_rule.to_symbols[0].s, EPS)
c = a.to_rule.to_symbols[0]
self.assertIsInstance(c, C)
self.assertIsInstance(c.to_rule, RuleCD)
d = c.to_rule.to_symbols[0]
self.assertIsInstance(d, D)
self.assertIsInstance(d.to_rule, RuleDEps)
self.assertIs(d.to_rule.to_symbols[0].s, EPS)
def parse_from_tokens(input):
parsed = cyk(_g, input)
parsed = InverseContextFree.transform_from_chomsky_normal_form(parsed)
parsed = InverseContextFree.unit_rules_restore(parsed)
parsed = InverseContextFree.epsilon_rules_restore(parsed)
parsed = InverseCommon.splitted_rules(parsed)
return parsed.get_representation()
def testRealTraversingReturnValues(self):
g = Grammar(terminals=[0],
nonterminals=[A],
rules=[Rules],
start_symbol=A)
res = cyk(g, [0])
def travRule(item, callback):
self.assertIsInstance(item, Rules)
yield item
for ch in item.to_symbols:
yield callback(ch)
def travNonterminals(item, callback):
self.assertIsInstance(item, A)
yield item
yield callback(item.to_rule)
def travTerms(item, callback):
self.assertIsInstance(item, Terminal)
yield item
resp = list(
Traversing.traverse_separated(res, travRule, travNonterminals,
travTerms))
self.assertIsInstance(resp[0], A)
self.assertIsInstance(resp[1], Rules)
self.assertIsInstance(resp[2], Terminal)
self.assertEqual(resp[2].s, 0)
def test_transform(self):
g = Grammar(terminals=[0, 1, 2],
nonterminals=[S, A, B, C],
rules=[RuleSABC, RuleA0, RuleB1, RuleC2],
start_symbol=S)
com = ContextFree.transform_to_chomsky_normal_form(g)
pars = cyk(com, [0, 1, 2])
trans = InverseContextFree.transform_from_chomsky_normal_form(pars)
self.assertIsInstance(trans, S)
self.assertIsInstance(trans.to_rule, RuleSABC)
a = trans.to_rule.to_symbols[0]
b = trans.to_rule.to_symbols[1]
c = trans.to_rule.to_symbols[2]
self.assertIsInstance(a, A)
self.assertIsInstance(a.to_rule, RuleA0)
self.assertIsInstance(a.to_rule.to_symbols[0], Terminal)
self.assertEqual(a.to_rule.to_symbols[0].s, 0)
self.assertIsInstance(b, B)
self.assertIsInstance(b.to_rule, RuleB1)
self.assertIsInstance(b.to_rule.to_symbols[0], Terminal)
self.assertEqual(b.to_rule.to_symbols[0].s, 1)
self.assertIsInstance(c, C)
self.assertIsInstance(c.to_rule, RuleC2)
self.assertIsInstance(c.to_rule.to_symbols[0], Terminal)
self.assertEqual(c.to_rule.to_symbols[0].s, 2)
def test_repeatOfC(self):
g = Grammar(terminals=[0, 1, 2, 3],
nonterminals=[S, A, B, C, D],
rules=[
RuleSA, RuleSB, RuleAC, RuleA0A, RuleBD, RuleB2B,
RuleB3S, RuleC1C, RuleC0, RuleD3D, RuleD2
],
start_symbol=S)
gr = ContextFree.transform_to_chomsky_normal_form(
ContextFree.remove_unit_rules(g))
pars = cyk(gr, [1, 1, 0])
s = InverseContextFree.unit_rules_restore(
InverseContextFree.transform_from_chomsky_normal_form(pars))
self.assertIsInstance(s, S)
self.assertIsInstance(s.to_rule, RuleSA)
a = s.to_rule.to_symbols[0]
self.assertIsInstance(a, A)
self.assertIsInstance(a.to_rule, RuleAC)
c = a.to_rule.to_symbols[0]
self.assertIsInstance(c, C)
self.assertIsInstance(c.to_rule, RuleC1C)
self.assertIsInstance(c.to_rule.to_symbols[0], Terminal)
self.assertEqual(c.to_rule.to_symbols[0].s, 1)
c = c.to_rule.to_symbols[1]
self.assertIsInstance(c, C)
self.assertIsInstance(c.to_rule, RuleC1C)
self.assertIsInstance(c.to_rule.to_symbols[0], Terminal)
self.assertEqual(c.to_rule.to_symbols[0].s, 1)
c = c.to_rule.to_symbols[1]
self.assertIsInstance(c, C)
self.assertIsInstance(c.to_rule, RuleC0)
self.assertIsInstance(c.to_rule.to_symbols[0], Terminal)
self.assertEqual(c.to_rule.to_symbols[0].s, 0)
def test_recursiveTest(self):
class Rule0(Rule): rule=([A], [A, 2])
class Rule1(Rule): rule=([A], [B, C])
class Rule2(Rule): rule=([B], [0])
class Rule3(Rule): rule=([C], [1])
g = Grammar(terminals=[0, 1, 2],
nonterminals=[A, B, C],
rules=[Rule0, Rule1, Rule2, Rule3],
start_symbol=A)
ContextFree.prepare_for_cyk(g, True)
root = cyk(g, [0, 1, 2, 2])
root = InverseContextFree.reverse_cyk_transforms(root)
repre = Traversing.print(root)
expect = \
"""(N)A
`--(R)Rule0
|--(N)A
| `--(R)Rule0
| |--(N)A
| | `--(R)Rule1
| | |--(N)B
| | | `--(R)Rule2
| | | `--(T)0
| | `--(N)C
| | `--(R)Rule3
| | `--(T)1
| `--(T)2
`--(T)2
"""
self.assertEqual(repre, expect)
def test_shouldTraverse(self):
g = Grammar(terminals=[0, 1],
nonterminals=[A, B, C],
rules=[Rule1, Rule2, Rule3],
start_symbol=A)
root = cyk(g, [0, 1])
def traverse_func(item, callback):
if isinstance(item, Rule):
yield item
for el in item.to_symbols:
yield callback(el)
elif isinstance(item, Nonterminal):
yield item
yield callback(item.to_rule)
else:
yield item
gen = Traversing.traverse(root, traverse_func)
res = list(gen)
self.assertTrue(isinstance(res[0], A))
self.assertTrue(isinstance(res[1], Rule1))
self.assertTrue(isinstance(res[2], B))
self.assertTrue(isinstance(res[3], Rule2))
self.assertTrue(isinstance(res[4], Terminal))
self.assertEqual(res[4].s, 0)
self.assertTrue(isinstance(res[5], C))
self.assertTrue(isinstance(res[6], Rule3))
self.assertTrue(isinstance(res[7], Terminal))
self.assertEqual(res[7].s, 1)
def test_parseWithThreeIterations(self):
g = Grammar(terminals=[0, 1],
nonterminals=[S, A, B],
rules=[Rules, AtoAB],
start_symbol=S)
res = cyk(g, [0, 1, 1, 1, 1])
res = InverseCommon.splitted_rules(res)
self.assertIsInstance(res, S)
self.assertIsInstance(res.to_rule, Rules)
a = res.to_rule.to_symbols[0]
b = res.to_rule.to_symbols[1]
self.assertIsInstance(a, A)
self.assertIsInstance(b, B)
self.assertIsInstance(a.to_rule, AtoAB)
self.assertIsInstance(b.to_rule, Rules)
b = a.to_rule.to_symbols[1]
a = a.to_rule.to_symbols[0]
self.assertIsInstance(a, A)
self.assertIsInstance(b, B)
self.assertIsInstance(a.to_rule, AtoAB)
self.assertIsInstance(b.to_rule, Rules)
b = a.to_rule.to_symbols[1]
a = a.to_rule.to_symbols[0]
self.assertIsInstance(a, A)
self.assertIsInstance(b, B)
self.assertIsInstance(a.to_rule, AtoAB)
self.assertIsInstance(b.to_rule, Rules)
b = a.to_rule.to_symbols[1]
a = a.to_rule.to_symbols[0]
self.assertIsInstance(a, A)
self.assertIsInstance(b, B)
self.assertIsInstance(a.to_rule, Rules)
self.assertIsInstance(b.to_rule, Rules)
def test_shouldParseCorrectSymbolsOneLoop(self):
parsed = cyk(self.g, [2, 0, 1])
a = parsed.to_rule.to_symbols[0]
b = parsed.to_rule.to_symbols[1]
c = a.to_rule.to_symbols[1]
a = a.to_rule.to_symbols[0]
self.assertEqual(a.to_rule.to_symbols[0].s, 2)
self.assertEqual(b.to_rule.to_symbols[0].s, 1)
self.assertEqual(c.to_rule.to_symbols[0].s, 0)
def test_rewriteSimple1(self):
g = Grammar(terminals=[0, 1],
nonterminals=[S],
rules=[Rules],
start_symbol=S)
res = cyk(g, [1])
res = InverseCommon.splitted_rules(res)
self.assertIsInstance(res, S)
self.assertIsInstance(res.to_rule, Rules)
def test_shouldParseCorrectSymbols(self):
parsed = cyk(self.g, [0, 1, 2])
a = parsed.to_rule.to_symbols[0]
b = parsed.to_rule.to_symbols[1]
c = b.to_rule.to_symbols[0]
d = b.to_rule.to_symbols[1]
self.assertEqual(a.to_rule.to_symbols[0].s, 0)
self.assertEqual(c.to_rule.to_symbols[0].s, 1)
self.assertEqual(d.to_rule.to_symbols[0].s, 2)
def test_fiveTerminals(self):
result = cyk(self.g, [My(1), My(2), My(3), My(4), My(5)])
terms = filter(lambda x: isinstance(x, Terminal), Traversing.post_order(result))
terms = list(terms)
self.assertEqual(terms[0].s.prop, 1)
self.assertEqual(terms[1].s.prop, 2)
self.assertEqual(terms[2].s.prop, 3)
self.assertEqual(terms[3].s.prop, 4)
self.assertEqual(terms[4].s.prop, 5)
def testAIn(self):
g = Grammar(terminals=[0],
nonterminals=[A],
rules=[Rules],
start_symbol=A)
res = cyk(g, [0])
def trav(item, callback):
self.assertTrue(isinstance(item, A))
Traversing.traverse(res, trav)
def testTraversePostOrder(self):
g = Grammar(terminals=[0],
nonterminals=[A],
rules=[Rules],
start_symbol=A)
res = cyk(g, [0])
resp = list(Traversing.post_order(res))
self.assertIsInstance(resp[2], A)
self.assertIsInstance(resp[1], Rules)
self.assertIsInstance(resp[0], Terminal)
self.assertEqual(resp[0].s, 0)
def test_shouldParseCorrectTypesForNoLoop(self):
parsed = cyk(self.g, [2, 1])
self.assertIsInstance(parsed, S)
self.assertIsInstance(parsed.to_rule, SAB)
self.assertIsInstance(parsed.to_rule.to_symbols[0], A)
self.assertIsInstance(parsed.to_rule.to_symbols[1], B)
a = parsed.to_rule.to_symbols[0]
b = parsed.to_rule.to_symbols[1]
self.assertIsInstance(a.to_rule, A2)
self.assertIsInstance(a.to_rule.to_symbols[0], Terminal)
self.assertIsInstance(b.to_rule, B1)
self.assertIsInstance(b.to_rule.to_symbols[0], Terminal)
def test_nonterminalToTerm(self):
class Rule1(Rule): rule=([A], [0])
g = Grammar(terminals=[0],
nonterminals=[A],
rules=[Rule1],
start_symbol=A)
root = cyk(g, [0])
repre = Traversing.print(root)
expect = \
"""(N)A
`--(R)Rule1
`--(T)0
"""
self.assertEqual(repre, expect)
def test_transform(self):
g = Grammar(terminals=[0, 1],
nonterminals=[S],
rules=[Rules],
start_symbol=S)
tr = ContextFree.transform_to_chomsky_normal_form(g)
pars = cyk(tr, [0, 1])
rest = InverseContextFree.transform_from_chomsky_normal_form(pars)
self.assertIsInstance(rest, S)
self.assertIsInstance(rest.to_rule, Rules)
self.assertIsInstance(rest.to_rule.to_symbols[0], Terminal)
self.assertIsInstance(rest.to_rule.to_symbols[1], Terminal)
self.assertEqual(rest.to_rule.to_symbols[0].s, 0)
self.assertEqual(rest.to_rule.to_symbols[1].s, 1)
def test_shouldParseCorrectSymbolsThreeLoops(self):
parsed = cyk(self.g, [2, 0, 0, 0, 1])
a1 = parsed.to_rule.to_symbols[0]
b = parsed.to_rule.to_symbols[1]
a2 = a1.to_rule.to_symbols[0]
c1 = a1.to_rule.to_symbols[1]
a3 = a2.to_rule.to_symbols[0]
c2 = a2.to_rule.to_symbols[1]
a4 = a3.to_rule.to_symbols[0]
c3 = a3.to_rule.to_symbols[1]
self.assertEqual(a4.to_rule.to_symbols[0].s, 2)
self.assertEqual(c3.to_rule.to_symbols[0].s, 0)
self.assertEqual(c2.to_rule.to_symbols[0].s, 0)
self.assertEqual(c1.to_rule.to_symbols[0].s, 0)
self.assertEqual(b.to_rule.to_symbols[0].s, 1)
def test_shouldParseAndUseValues(self):
parsed = cyk(self.g, [My(1), My(2)])
parsed = InverseContextFree.transform_from_chomsky_normal_form(parsed)
parsed = InverseContextFree.unit_rules_restore(parsed)
parsed = InverseContextFree.epsilon_rules_restore(parsed)
self.assertIsInstance(parsed, S)
self.assertIsInstance(parsed.to_rule, R)
left = parsed.to_rule.to_symbols[0]
right = parsed.to_rule.to_symbols[1]
self.assertIsInstance(left, Terminal)
self.assertIsInstance(left.s, My)
self.assertEqual(left.s.prop, 1)
self.assertIsInstance(right, Terminal)
self.assertIsInstance(right.s, My)
self.assertEqual(right.s.prop, 2)
def test_transform(self):
g = Grammar(terminals=[0, 1, 2, 3],
nonterminals=[S, A, B, C],
rules=[RuleS, RuleA, RuleB, RuleS0, RuleA1, RuleB2, RuleC3],
start_symbol=S)
gr = ContextFree.transform_to_chomsky_normal_form(g)
pars = cyk(gr, [1, 3, 1, 2, 3, 1, 3])
trans = InverseContextFree.transform_from_chomsky_normal_form(pars)
self.assertIsInstance(trans, S)
self.assertIsInstance(trans.to_rule, RuleS)
a = trans.to_rule.to_symbols[0]
self.assertIsInstance(a, A)
self.assertIsInstance(a.to_rule, RuleA1)
self.assertIsInstance(a.to_rule.to_symbols[0], Terminal)
self.assertEqual(a.to_rule.to_symbols[0].s, 1)
b = trans.to_rule.to_symbols[1]
self.assertIsInstance(b, B)
self.assertIsInstance(b.to_rule, RuleB)
c = b.to_rule.to_symbols[0]
self.assertIsInstance(c, C)
self.assertIsInstance(c.to_rule, RuleC3)
self.assertIsInstance(c.to_rule.to_symbols[0], Terminal)
self.assertEqual(c.to_rule.to_symbols[0].s, 3)
s = b.to_rule.to_symbols[1]
self.assertIsInstance(s, S)
self.assertIsInstance(s.to_rule, RuleS)
self.assertIsInstance(s.to_rule.to_symbols[0], A)
self.assertIsInstance(s.to_rule.to_symbols[0].to_rule, RuleA1)
self.assertIsInstance(s.to_rule.to_symbols[0].to_rule.to_symbols[0], Terminal)
self.assertEqual(s.to_rule.to_symbols[0].to_rule.to_symbols[0].s, 1)
self.assertIsInstance(s.to_rule.to_symbols[1], B)
self.assertIsInstance(s.to_rule.to_symbols[1].to_rule, RuleB2)
self.assertIsInstance(s.to_rule.to_symbols[1].to_rule.to_symbols[0], Terminal)
self.assertEqual(s.to_rule.to_symbols[1].to_rule.to_symbols[0].s, 2)
self.assertIsInstance(s.to_rule.to_symbols[2], C)
self.assertIsInstance(s.to_rule.to_symbols[2].to_rule, RuleC3)
self.assertIsInstance(s.to_rule.to_symbols[2].to_rule.to_symbols[0], Terminal)
self.assertEqual(s.to_rule.to_symbols[2].to_rule.to_symbols[0].s, 3)
self.assertIsInstance(b.to_rule.to_symbols[2], A)
self.assertIsInstance(b.to_rule.to_symbols[2].to_rule, RuleA1)
self.assertIsInstance(b.to_rule.to_symbols[2].to_rule.to_symbols[0], Terminal)
self.assertEqual(b.to_rule.to_symbols[2].to_rule.to_symbols[0].s, 1)
self.assertIsInstance(pars.to_rule.to_symbols[2], C)
self.assertIsInstance(pars.to_rule.to_symbols[2].to_rule, RuleC3)
self.assertIsInstance(pars.to_rule.to_symbols[2].to_rule.to_symbols[0], Terminal)
self.assertEqual(pars.to_rule.to_symbols[2].to_rule.to_symbols[0].s, 3)
def test_cnf_grammar_is_equiv():
lines = ['S a S b S', 'S eps']
g, symbols = split_cfg(lines)
tmp_g = ContextFree.transform_to_chomsky_normal_form(g)
new_g = ContextFree.prepare_for_cyk(tmp_g)
assert cyk(new_g, 'abab')
assert cyk(new_g, 'aabb')
with raises(Exception):
cyk(new_g, 'aba')
with raises(Exception):
cyk(new_g, 'abba')
def testTraversingOwnTypes(self):
g = Grammar(terminals=[0],
nonterminals=[A],
rules=[Rules],
start_symbol=A)
res = cyk(g, [0])
def travRule(item, callback):
self.assertIsInstance(item, Rules)
def travNonterminals(item, callback):
self.assertIsInstance(item, A)
def travTerms(item, callback):
self.assertIsInstance(item, Terminal)
Traversing.traverse_separated(res, travRule, travNonterminals,
travTerms)
def test_shouldParseCorrectTypes(self):
parsed = cyk(self.g, [0, 1, 2])
self.assertIsInstance(parsed, S)
self.assertIsInstance(parsed.to_rule, SAB)
self.assertIsInstance(parsed.to_rule.to_symbols[0], A)
self.assertIsInstance(parsed.to_rule.to_symbols[1], B)
a = parsed.to_rule.to_symbols[0]
b = parsed.to_rule.to_symbols[1]
self.assertIsInstance(a.to_rule, A0)
self.assertIsInstance(a.to_rule.to_symbols[0], Terminal)
self.assertIsInstance(b.to_rule, BCD)
self.assertIsInstance(b.to_rule.to_symbols[0], C)
self.assertIsInstance(b.to_rule.to_symbols[1], D)
c = b.to_rule.to_symbols[0]
d = b.to_rule.to_symbols[1]
self.assertIsInstance(c.to_rule, C1)
self.assertIsInstance(c.to_rule.to_symbols[0], Terminal)
self.assertIsInstance(d.to_rule, D2)
self.assertIsInstance(d.to_rule.to_symbols[0], Terminal)
def test_split_cfg_grammar():
lines = ['S a S b S', 'S eps']
g, symbols = split_cfg(lines)
assert len(g.terminals) == 3
assert len(g.nonterminals) == 1
assert len(g.rules) == 2
# Checks if grammar accepts right words using library methods
new_g = ContextFree.prepare_for_cyk(g)
assert cyk(new_g, 'abab')
assert cyk(new_g, 'aabb')
with raises(Exception):
cyk(new_g, 'aba')
with raises(Exception):
cyk(new_g, 'abba')
def test_simpleTestOverUnitRule(self):
g = Grammar(
terminals=[0, 1, 2, 3],
nonterminals=[S, A, B, C],
rules=[RuleS0A, RuleAB, RuleAEps, RuleBEps, RuleB1C, RuleC11],
start_symbol=S)
gr = ContextFree.transform_to_chomsky_normal_form(
ContextFree.remove_unit_rules(
ContextFree.remove_rules_with_epsilon(g)))
pars = cyk(gr, [0])
s = InverseContextFree.epsilon_rules_restore(
InverseContextFree.unit_rules_restore(
InverseContextFree.transform_from_chomsky_normal_form(pars)))
self.assertIsInstance(s, S)
self.assertIsInstance(s.to_rule, RuleS0A)
self.assertIsInstance(s.to_rule.to_symbols[0], Terminal)
self.assertEqual(s.to_rule.to_symbols[0].s, 0)
a = s.to_rule.to_symbols[1]
self.assertIsInstance(a, A)
self.assertIsInstance(a.to_rule, RuleAEps)
self.assertIs(a.to_rule.to_symbols[0].s, EPS)
def test_splitTest(self):
class Rule1(Rule): rule=([A], [B, C])
class Rule2(Rule): rule=([B], [0])
class Rule3(Rule): rule=([C], [1])
g = Grammar(terminals=[0, 1],
nonterminals=[A, B, C],
rules=[Rule1, Rule2, Rule3],
start_symbol=A)
root = cyk(g, [0, 1])
repre = Traversing.print(root)
expect = \
"""(N)A
`--(R)Rule1
|--(N)B
| `--(R)Rule2
| `--(T)0
`--(N)C
`--(R)Rule3
`--(T)1
"""
self.assertEqual(repre, expect)
def test_directTo2(self):
g = Grammar(terminals=[0, 1, 2, 3],
nonterminals=[S, A, B, C, D],
rules=[
RuleSA, RuleSB, RuleAC, RuleA0A, RuleA1S, RuleBD,
RuleB2B, RuleB3S, RuleC1C, RuleC0, RuleD3D, RuleD2
],
start_symbol=S)
gr = ContextFree.transform_to_chomsky_normal_form(
ContextFree.remove_unit_rules(g))
pars = cyk(gr, [2])
s = InverseContextFree.unit_rules_restore(
InverseContextFree.transform_from_chomsky_normal_form(pars))
self.assertIsInstance(s, S)
self.assertIsInstance(s.to_rule, RuleSB)
b = s.to_rule.to_symbols[0]
self.assertIsInstance(b, B)
self.assertIsInstance(b.to_rule, RuleBD)
d = b.to_rule.to_symbols[0]
self.assertIsInstance(d, D)
self.assertIsInstance(d.to_rule, RuleD2)
self.assertIsInstance(d.to_rule.to_symbols[0], Terminal)
self.assertEqual(d.to_rule.to_symbols[0].s, 2)
def testRealTraversing(self):
g = Grammar(terminals=[0],
nonterminals=[A],
rules=[Rules],
start_symbol=A)
res = cyk(g, [0])
def travRule(item, callback):
self.assertIsInstance(item, Rules)
yield item
for ch in item.to_symbols:
yield callback(ch)
def travNonterminals(item, callback):
self.assertIsInstance(item, A)
yield item
yield callback(item.to_rule)
def travTerms(item, callback):
self.assertIsInstance(item, Terminal)
yield item
Traversing.traverse_separated(res, travRule, travNonterminals,
travTerms)
