def test_resolve(self):
word = topic([ieml('wa.')])
p = path('r0')
elems = resolve(word, p)
self.assertSetEqual(elems, {ieml('wa.')})
worda = topic([ieml('wu.')])
wordm = topic([ieml('we.')])
s = fact([(word, worda, wordm)])
p = path('sa:r')
elems = resolve(s, p)
self.assertSetEqual(elems, {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=Fact)
s = r.fact()
p = path("s+a+m + (s+a+m):(r+f)")
elems = resolve(s, p)
self.assertSetEqual(elems, s.topics.union(s.words))
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, p)
self.assertSetEqual(
usl.facts.union(usl.topics).union(usl.words).union(usl.theories),
elems)
def __getitem__(self, item):
from ieml.grammar.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 tuple(sorted(res))
from .word import Word
if item == Word:
return self.words
from .topic import Topic
if item == Topic:
return self.topics
from .fact import Fact
if item == Fact:
return self.facts
from .theory import Theory
if item == Theory:
return self.theories
from .text import Text
if item == Text:
return {self} if self.__class__ == Text else {}
def __getitem__(self, item):
from ieml.grammar.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 tuple(sorted(res))
from .word import Word
if item == Word:
return self.words
from .topic import Topic
if item == Topic:
return self.topics
from .fact import Fact
if item == Fact:
return self.facts
from .theory import Theory
if item == Theory:
return self.theories
from .text import Text
if item == Text:
return {self} if self.__class__ == Text else {}
def usl(arg):
if isinstance(arg, str):
from .parser import IEMLParser
return IEMLParser().parse(arg)
if isinstance(arg, Term):
from .word import Word
return Word(arg)
if isinstance(arg, Usl):
return arg
from ieml.grammar.paths import resolve_ieml_object, path
if isinstance(arg, dict):
# map path -> Ieml_object
return resolve_ieml_object(arg)
# if iterable, can be a list of usl to convert into a text
try:
usl_list = list(arg)
except TypeError:
pass
else:
if len(usl_list) == 0:
return usl('E:')
if all(isinstance(u, Usl) for u in usl_list):
if len(usl_list) == 1:
return usl_list[0]
else:
from ieml.grammar import text
return text(usl_list)
else:
# list of path objects
try:
rules = [(a, b) for a, b in usl_list]
except TypeError:
pass
else:
rules = [(path(a), usl(b)) for a, b in rules]
return resolve_ieml_object(rules)
raise NotImplementedError()
def usl(arg):
if isinstance(arg, str):
from .parser import IEMLParser
return IEMLParser().parse(arg)
if isinstance(arg, Term):
from .word import Word
return Word(arg)
if isinstance(arg, Usl):
return arg
from ieml.grammar.paths import resolve_ieml_object, path
if isinstance(arg, dict):
# map path -> Ieml_object
return resolve_ieml_object(arg)
# if iterable, can be a list of usl to convert into a text
try:
usl_list = list(arg)
except TypeError:
pass
else:
if len(usl_list) == 0:
return usl('E:')
if all(isinstance(u, Usl) for u in usl_list):
if len(usl_list) == 1:
return usl_list[0]
else:
from ieml.grammar import text
return text(usl_list)
else:
# list of path objects
try:
rules = [(a, b) for a, b in usl_list]
except TypeError:
pass
else:
rules = [(path(a), usl(b)) for a, b in rules]
return resolve_ieml_object(rules)
raise NotImplementedError()
def test_rules(self):
rules0 = [(path('r0'), ieml('wa.'))]
obj = resolve_ieml_object(*zip(*rules0))
self.assertEqual(obj, topic([ieml('wa.')]))
rules1 = [(path('r1'), ieml('wa.')), (path('r'), ieml('I:')),
(path('f0'), ieml('we.'))]
obj = resolve_ieml_object(*zip(*rules1))
word1 = topic([ieml('I:'), ieml('wa.')], [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, topic([ieml('I:'), ieml('wa.')], [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: {Word}
}))
p = path('f15684')
self.assertIsInstance(p, Coordinate)
self.assertEqual(p.kind, 'f')
self.assertEqual(p.index, 15684)
self.assertTupleEqual(tuple(p.context), ({Topic}, False, {
Topic: {Word}
}))
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, Theory, Fact, Topic}, True, {
Text: {Theory, Fact, Topic, Word},
Theory: {Fact, Topic},
Fact: {Topic},
Topic: {Word}
}))
def test_context(self):
with self.assertRaises(PathError):
p = path("sma")