def test_resolve(self):
word = Word(Morpheme([ieml('wa.')]))
p = path('r0')
elems = resolve(word, p)
self.assertSetEqual(elems, {ieml('wa.')})
worda = Word(Morpheme([ieml('wu.')]))
wordm = Word(Morpheme([ieml('we.')]))
s = Sentence([Clause(word, worda, wordm)])
p = path('sa:r')
elems = resolve(s, p)
self.assertSetEqual(elems, {Morpheme([ieml('wu.')])})
p = path('sa0+s0+sm0')
elems = resolve(s, p)
self.assertSetEqual(elems, {word, wordm, worda})
t = Text([s, word])
p = path('t')
elems = resolve(t, p)
self.assertSetEqual(elems, {s, word})
p = path('t1')
elems = resolve(t, p)
self.assertSetEqual(elems, {s})
def test_random(self):
r = RandomPoolIEMLObjectGenerator(level=Sentence)
s = r.sentence()
p = path("s+a+m + (s+a+m):(r+f)")
elems = resolve(s, p)
self.assertSetEqual(
elems,
{p
for p in s.tree_iter() if isinstance(p, (Word, Morpheme))})
p = path("t + t:(s+a+m+r+f+(s+a+m):(s+a+m+r+f+(s+a+m):(r+f)))")
usl = random_usl(rank_type=Text)
elems = resolve(usl.ieml_object, p)
self.assertSetEqual(
set(e for e in usl.ieml_object.tree_iter()
if not isinstance(e, (Text, SuperClause, Clause, SyntaxTerm))),
elems)
def __getitem__(self, item):
from ieml.usl.paths import Path, path, resolve
if isinstance(item, str):
item = path(item)
if isinstance(item, Path):
res = resolve(self, item)
if len(res) == 1:
return res.__iter__().__next__()
else:
return list(res)
if isinstance(item, int):
return self.children[item]
def test_rules(self):
rules0 = [(path('r0'), ieml('wa.'))]
obj = resolve_ieml_object(*zip(*rules0))
self.assertEqual(obj, Word(Morpheme([ieml('wa.')])))
rules1 = [(path('r1'), ieml('wa.')), (path('r'), ieml('I:')),
(path('f0'), ieml('we.'))]
obj = resolve_ieml_object(*zip(*rules1))
word1 = Word(Morpheme([ieml('I:'), ieml('wa.')]),
Morpheme([ieml('we.')]))
self.assertEqual(obj, word1)
self.assertEqual(resolve_ieml_object(enumerate_paths(obj)), obj)
r = RandomPoolIEMLObjectGenerator(level=Text)
t = r.text()
self.assertEqual(t, resolve_ieml_object(enumerate_paths(t)))
rules = [(path('r1'), ieml('wa.')), (path('r'), ieml('I:')),
(path('f0'), ieml('we.'))]
obj = resolve_ieml_object(*zip(*rules))
self.assertEqual(
obj,
Word(Morpheme([ieml('I:'), ieml('wa.')]), Morpheme([ieml('we.')])))
def test_path_parser(self):
p = path("t:sa:sa0:f")
self.assertIsInstance(p, ContextPath)
self.assertListEqual(
[c.__class__ for c in p.children],
[Coordinate, MultiplicativePath, MultiplicativePath, Coordinate])
self.assertEqual(str(p), "t:sa:sa0:f")
self.assertTupleEqual(tuple(p.context), ({Text}, False, {
Text: {SyntaxTerm}
}))
p = path('f15684')
self.assertIsInstance(p, Coordinate)
self.assertEqual(p.kind, 'f')
self.assertEqual(p.index, 15684)
self.assertTupleEqual(tuple(p.context), ({Word}, False, {
Word: {SyntaxTerm}
}))
p = path("t0:(s0a0 + s0m0):s:f + t1:s:s:(r+f)")
self.assertIsInstance(p, AdditivePath)
p = path("t:(s+s)a")
self.assertIsInstance(p, ContextPath)
with self.assertRaises(PathError):
p = path("(s:r+s):r")
print(p)
p = path("t + s + s:s + r")
self.assertTupleEqual(
p.context, ({Text, SuperSentence, Sentence, Word}, True, {
Text: {SuperSentence, Sentence, Word, SyntaxTerm},
SuperSentence: {Sentence, Word},
Sentence: {Word},
Word: {SyntaxTerm}
}))
def test_context(self):
with self.assertRaises(PathError):
p = path("sma")