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_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_translation(self):
w = ieml(
"[([M:M:.a.-]+[n.-S:.U:.-'S:.-'B:.-',M:.-',M:.-',_])*([E:U:T:.]+[E:.U:.wa.-])]"
)
t = Template(w, ['r0', 'r1'])
translations = t.get_translations(
{
'fr': 'Ces meilleurs "$0" de "$1"',
'en': 'These best "$0" of "$1"'
}, {
'r0': '$0',
'r1': '$1'
})
self.assertEqual(len(translations), len(list(t)))
all_fr = set(t['fr'] for t in translations.values())
self.assertIn(
'Ces meilleurs "scribe" de "Europe nord-centrale | Danemark, Suède, Norvège"',
all_fr)
self.assertIn(
'Ces meilleurs "interprète" de "Europe médiane est | Roumanie, Moldavie, Ukraine"',
all_fr)
w = ieml(
"[([M:M:.a.-]+[n.-S:.U:.-'S:.-'B:.-',M:.-',M:.-',_])*([E:U:T:.]+[E:.U:.wa.-])]"
)
t = Template(w, ['r0', 'r1'])
translations_2 = t.get_translations({
'fr': 'Ces meilleurs "r0" de "r1"',
'en': 'These best "r0" of "r1"'
})
self.assertDictEqual(translations, translations_2)
def test_translation(self):
w = ieml("[([M:M:.a.-]+[n.-S:.U:.-'S:.-'B:.-',M:.-',M:.-',_])*([E:U:T:.]+[E:.U:.wa.-])]")
t = Template(w, ['r0', 'r1'])
translations = t.get_translations({'fr': 'Ces meilleurs "$0" de "$1"', 'en': 'These best "$0" of "$1"'}, {'r0': '$0', 'r1': '$1'})
self.assertEqual(len(translations), len(list(t)))
all_fr = set(t['fr'] for t in translations.values())
self.assertIn('Ces meilleurs "scribe" de "Europe nord-centrale | Danemark, Suède, Norvège"', all_fr)
self.assertIn('Ces meilleurs "interprète" de "Europe médiane est | Roumanie, Moldavie, Ukraine"', all_fr)
w = ieml("[([M:M:.a.-]+[n.-S:.U:.-'S:.-'B:.-',M:.-',M:.-',_])*([E:U:T:.]+[E:.U:.wa.-])]")
t = Template(w, ['r0', 'r1'])
translations_2 = t.get_translations({'fr': 'Ces meilleurs "r0" de "r1"', 'en': 'These best "r0" of "r1"'})
self.assertDictEqual(translations, translations_2)
def replace_paths(u, rules):
k = [(p, t) for p, t in {
**usl(u).paths,
**{path(p): ieml(t)
for p, t in rules.items()}
}.items()]
return usl(k)
def resolve_ieml_object(paths, elements=None):
global _errors, _context_stack
_errors = []
_context_stack = []
if isinstance(paths, dict):
paths = list(paths.items())
if elements is None:
result = _resolve_ctx('', [(d, ieml(e)) for p, e in paths for d in path(p).develop])
else:
result = _resolve_ctx('', [(d, ieml(e)) for e, p in zip(elements, paths) for d in path(p).develop])
if _errors:
raise IEMLObjectResolutionError(_errors)
return result
def resolve_ieml_object(paths, elements=None):
global _errors, _context_stack
_errors = []
_context_stack = []
if isinstance(paths, dict):
paths = list(paths.items())
if elements is None:
result = _resolve_ctx('', [(d, ieml(e)) for p, e in paths
for d in path(p).develop])
else:
result = _resolve_ctx('', [(d, ieml(e))
for e, p in zip(elements, paths)
for d in path(p).develop])
if _errors:
raise IEMLObjectResolutionError(_errors)
return result
def test_text_translation(self):
update = {
'terms': {
"n.-S:.U:.-'T:.-'T:.-',M:.-',S:.-',_": "n.-S:.U:.-'T:.-'T:.-',S:.-',M:.-',_"
}
}
v = create_dictionary_version(update=update)
p = ieml("/[([([n.-S:.U:.-'T:.-'T:.-',M:.-',S:.-',_])]*[([wa.])]*[([we.])])]/")
p.set_dictionary_version(v)
self.assertEqual(str(p), "/[([([n.-S:.U:.-'T:.-'T:.-',S:.-',M:.-',_])]*[([wa.])]*[([we.])])]/")
def test_word_translation(self):
update = {
'terms': {
"n.-S:.U:.-'T:.-'T:.-',M:.-',S:.-',_": "n.-S:.U:.-'T:.-'T:.-',S:.-',M:.-',_"
}
}
v = create_dictionary_version(update=update)
p = ieml("[([n.-S:.U:.-'T:.-'T:.-',M:.-',S:.-',_])]")
p.set_dictionary_version(v)
self.assertEqual(str(p), "[([n.-S:.U:.-'T:.-'T:.-',S:.-',M:.-',_])]")
def usl(arg):
if isinstance(arg, Usl):
return arg
if isinstance(arg, IEMLSyntax):
if isinstance(arg, Term):
return Usl(Word(root=Morpheme([arg])))
return Usl(arg)
if isinstance(arg, str):
return USLParser().parse(arg)
if isinstance(arg, dict):
# map path -> Ieml_object
return Usl(resolve_ieml_object(arg))
try:
rules = [(a, b) for a, b in arg]
except TypeError:
pass
else:
rules = [(path(a), ieml(b)) for a, b in rules]
return Usl(resolve_ieml_object(rules))
raise ValueError("Invalid argument to create an usl object.")
def test_replace(self):
u = usl(Word(Morpheme([ieml('[M:]')])))
u2 = replace_paths(u, {'r0': '[S:]'})
self.assertEqual(u2, usl(Word(Morpheme([ieml('[S:]')]))))
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_create_word(self):
a = Word(Morpheme([ieml('[wa.]'), ieml('[we.]')]))
b = Word(Morpheme(reversed([ieml('[wa.]'), ieml('[we.]')])))
self.assertEqual(a, b)
self.assertEqual(str(a), str(b))
def test_invalid_creation(self):
def test(rules, expected=None):
if expected:
try:
usl(rules)
except IEMLObjectResolutionError as e:
self.assertListEqual(e.errors, expected)
else:
self.fail()
else:
with self.assertRaises(IEMLObjectResolutionError):
usl(rules)
# missing node definition on sm0
test([('s:r', ieml('[we.]')), ('sa0:r', ieml('[wa.]'))],
[('s0m0', "Missing node definition.")])
# empty rules
test([], [('', "Missing node definition.")])
# multiple def for a node
test([('r0', ieml('[wa.]')), ('r0', ieml('[we.]'))], [(
'r0',
'Multiple definition, multiple ieml object provided for the same node.'
)])
# missing index on text
test([('t:r', ieml('[we.]')), ('t2:r', ieml('[wa.]'))],
[('', "Index missing on text definition.")])
# missing index on word
test([('r2', ieml('[we.]')), ('r', ieml('[wa.]'))],
[('', "Index missing on topic definition.")])
test([('s:r', ieml('[wa.]')), ('sm:r', ieml('[we.]')),
('sa1:r', ieml('[wu.]'))],
[('s0a0', 'Missing node definition.')])
# incompatible path
test([('t:r', ieml('[wa.]')), ('s:f', ieml('[we.]'))],
[('', 'No definition, no type inferred on rules list.')])
# mulitple errors
test([("t0:s:f0", ieml('[wa.]')), ("t0:sa:r", ieml('[a.]')),
('t2:r', ieml('[we.]')), ("t0:sm1", topic([ieml('[wu.]')]))],
[('t0:s0', 'No root for the topic node.'),
('t0:s0m0', 'Missing node definition.'),
('t1', 'Missing node definition.')])
def test_word_instanciation(self):
with self.assertRaises(InvalidIEMLObjectArgument):
# "Too many singular sequences"
ieml("[([O:M:.]+[wa.]+[M:M:.])*([O:O:.M:O:.-])]")
def test_parse_term_plus(self):
t = term("f.-O:M:.+M:O:.-s.y.-'")
to_check = ieml("[f.-O:M:.+M:O:.-s.y.-']")
self.assertEqual(to_check, SyntaxTerm(t))
return k + SUB_KLASS[o]
return 'E'
res = sorted(((w, get_mark(w)) for w in word_list), key=lambda k: k[1])
return {k: [w[0] for w in v] for k, v in groupby(res, key=lambda k: k[1])}
def display_ranking(w0, word_list):
print("Ranking from %s" % str(w0))
res = order_word_list(w0, word_list)
for k in sorted(res):
print("-- Rank %s --" % k)
for w in res[k]:
print('\t %s' % str(w))
if __name__ == '__main__':
from pymongo import MongoClient
from ieml.tools import ieml
usls_collection = MongoClient().intlekt.usl
words = [{
**dict(u), 'ieml': ieml(u['ieml'])
} for u in usls_collection.find({"_cls": "USL.Word"})]
display_ranking(words[0]['ieml'], [w['ieml'] for w in words[1:]])
print(words)
def test_promotion(self):
self.assertIsInstance(Word.from_term(ieml('[A:]')), Word)
self.assertIsInstance(Word.from_term(term('[A:]')), Word)
self.assertIsInstance(ieml('[A:]'), SyntaxTerm)
self.assertIsInstance(ieml(term('[A:]')), SyntaxTerm)
def test_is_term(self):
self.assertTrue(Word.from_term(ieml('[A:]')).is_term)
def test_build_template(self):
w = ieml("[([E:M:T:.]+[f.e.-s.i.-']+[g.-'U:M:.-'n.o.-s.o.-',])*([x.a.-]+[M:U:.p.-])]")
t = Template(w, ['r0', 'r2', 'f1'])
self.assertEqual(len(set(t)), 3*3*3)
def test_parse_term_plus(self):
t = term("f.-O:M:.+M:O:.-s.y.-'")
to_check = ieml("[f.-O:M:.+M:O:.-s.y.-']")
self.assertEqual(to_check, Word(t))
def test_build_template(self):
w = ieml("[([E:M:T:.]+[f.e.-s.i.-']+[g.-'U:M:.-'n.o.-s.o.-',])*([x.a.-]+[M:U:.p.-])]")
t = Template(w, ['r0', 'r2', 'f1'])
self.assertEqual(len(set(t)), 3*3*3)
def replace_paths(u, rules):
k = [(p,t) for p, t in {
**usl(u).paths,
**{path(p): ieml(t) for p, t in rules.items()}}.items()]
return usl(k)
