def get_test_word_instance():
morpheme_subst = Morpheme(map(SyntaxTerm, [term("a.i.-"), term("i.i.-")]))
morpheme_attr = Morpheme(
map(SyntaxTerm, [term("E:A:T:."),
term("E:S:.wa.-"),
term("E:S:.o.-")]))
return Word(morpheme_subst, morpheme_attr)
def get_topics_list():
#this list is already sorted
terms_list = [term("E:A:T:."), term("E:.S:.wa.-"), term("E:.-S:.o.-t.-'"), term("a.i.-"), term("i.i.-"), term("u.M:M:.-")]
# a small yield to check the word before returning it :-°
for t in terms_list:
word_obj = topic([t])
yield word_obj
def test_irregular2(self):
scripts = ["M:M:.-O:M:.+M:O:.-E:.-+s.y.-'", "wa.F:.-"]
t = term(scripts[0])
self.assertEqual(len(t.script.tables), 1)
self.assertEqual(t.script.tables[0].dim, 3)
self.assertEqual(t.rank, 0)
t = term(scripts[1])
self.assertEqual(len(t.script.tables), 1)
self.assertEqual(t.script.tables[0].dim, 1)
self.assertEqual(t.rank, 3)
def word(arg, literals=None):
if isinstance(arg, Word):
if arg.literals != literals and literals is not None:
return Word(arg.term, literals=literals)
else:
return arg
else:
return Word(term(arg), literals=literals)
def test_symmetry(self):
t = term('wa.')
r = t.relations
for reltype in RELATIONS:
for tt in r[reltype]:
if t not in tt.relations[inverse_relation(reltype)]:
self.fail('Missing link "%s" --> "%s" (%s) in relations db.'%(str(tt), str(t), reltype))
def test_symmetry(self):
t = term('wa.')
r = t.relations
for reltype in RELATIONS:
for tt in r[reltype]:
if t not in tt.relations[inverse_relation(reltype)]:
self.fail(
'Missing link "%s" --> "%s" (%s) in relations db.' %
(str(tt), str(t), reltype))
def test_phonetic(self):
self.assertEqual(term("A:").phonetic, "A")
self.assertEqual(term("wa.").phonetic, "wa.")
self.assertEqual(term("we.M:M:.-").phonetic, "weMM-")
self.assertEqual(term("E:.-U:.y.-t.-'").phonetic, "EUyt..")
self.assertEqual(term("S:.-U:.-'T:.-wa.e.-'t.-x.-s.y.-',").phonetic, "SUTwaetxsy--")
self.assertEqual(term("t.i.-s.i.-'u.T:.-U:.-'wo.-',S:.-',_").phonetic, "tisiuTUwoS_")
self.assertEqual(term("f.o.-f.o.-',n.i.-f.i.-',x.-A:.-',_E:A:.-',_;").phonetic, "fofonifixAEA~")
# d = Dictionary()
# self.assertEqual(len(set(t.phonetic for t in d)), len(d))
def test_phonetic(self):
self.assertEqual(term("A:").phonetic, "A")
self.assertEqual(term("wa.").phonetic, "wa.")
self.assertEqual(term("we.M:M:.-").phonetic, "weMM-")
self.assertEqual(term("E:.-U:.y.-t.-'").phonetic, "EUyt..")
self.assertEqual(
term("S:.-U:.-'T:.-wa.e.-'t.-x.-s.y.-',").phonetic, "SUTwaetxsy--")
self.assertEqual(
term("t.i.-s.i.-'u.T:.-U:.-'wo.-',S:.-',_").phonetic,
"tisiuTUwoS_")
self.assertEqual(
term("f.o.-f.o.-',n.i.-f.i.-',x.-A:.-',_E:A:.-',_;").phonetic,
"fofonifixAEA~")
def get_words_list():
#this list is already sorted
terms_list = [
term("E:A:T:."),
term("E:.S:.wa.-"),
term("E:.-S:.o.-t.-'"),
term("a.i.-"),
term("i.i.-"),
term("u.M:M:.-")
]
# a small yield to check the word before returning it :-°
for t in terms_list:
word_obj = Word(Morpheme(SyntaxTerm(t)))
yield word_obj
def get_test_word_instance():
morpheme_subst = [term("a.i.-"), term("i.i.-")]
morpheme_attr = [term("E:A:T:."), term("E:S:.wa.-"),term("E:S:.o.-")]
return word(morpheme_subst, morpheme_attr)
def test_terms_creation(self):
t = term('E:E:A:.')
self.assertIsNotNone(t)
self.assertEqual(str(t), '[E:E:A:.]')
self.assertEqual(t, term('[E:E:A:.]'))
self.assertNotEqual(t, term('[E:E:B:.]'))
def get_test_morpheme_instance():
morpheme = [term("E:A:T:."), term("E:S:.wa.-"),term("E:S:.o.-")]
return morpheme
def test_tables_term(self):
term("B:.S:.n.-k.-+n.-n.S:.U:.-+n.B:.U:.-+n.T:.A:.-'+B:.B:.n.-k.-+n.-u.S:.-+u.B:.-+u.T:.-'").tables_term
def test_invalid_term(self):
with self.assertRaises(CannotParse):
self.parser.parse("[([A:A:A:.-'])]")
with self.assertRaises(TermNotFoundInDictionary):
term("A:A:A:.")
def test_promotion(self):
self.assertIsInstance(usl('[A:]'), Word)
self.assertIsInstance(topic(['[A:]']), Topic)
self.assertIsInstance(term('[A:]'), Term)
def get_test_morpheme_instance():
morpheme = Morpheme(
map(SyntaxTerm, [term("E:A:T:."),
term("E:S:.wa.-"),
term("E:S:.o.-")]))
return morpheme
def test_terms_creation(self):
t = term('E:E:A:.')
self.assertIsNotNone(t)
self.assertEqual(str(t), '[E:E:A:.]')
self.assertEqual(t, term('[E:E:A:.]'))
self.assertNotEqual(t, term('[E:E:B:.]'))
def test_table_relations(self):
t_p = term("M:M:.u.-")
t_ss = term("s.u.-")
self.assertFalse(t_p.relations.to(t_ss, relations_types=['table_2']))
def test_relations_to(self):
self.assertTrue(term('wa.').relations.to(term('we.')))
def test_no_reflexive_relations(self):
self.assertEqual(term('O:O:.O:O:.t.-').relations.opposed, ())
from ieml.dictionary import term
from ieml.grammar import topic, fact, usl
root = topic([term("i.i.-"), # fabriquer
term("a.i.-")], # vendre
[term("E:S:.o.-"), # vouloir futur
term("E:S:.wa.-"), # 1ere personne pluriel
term("E:A:T:.")]) # beaucoup
objects = [
{
'usl': usl(root),
'tags': {
'FR': "Nous avons l'intention de fabriquer et de vendre beaucoup",
'EN': "We intend to manufacture and sell a lot"
},
'keywords': {
'FR': [],
'EN': []
}
},
{
'usl': usl(fact([(
root,
topic([term("t.i.-s.i.-'u.T:.-U:.-'wo.-',B:.-',_M:.-',_;")]), # véhicule a roue sans conducteur
topic([term("E:E:T:.")]) # COD
), (
root,
topic([term("S:.-'B:.-'n.-S:.U:.-',")]), # Europe
topic([term("E:T:.f.-")]) # dans
from ieml.dictionary import term
from ieml.grammar import topic, fact, usl
root = topic(
[
term("i.i.-"), # fabriquer
term("a.i.-")
], # vendre
[
term("E:S:.o.-"), # vouloir futur
term("E:S:.wa.-"), # 1ere personne pluriel
term("E:A:T:.")
]) # beaucoup
objects = [
{
'usl': usl(root),
'tags': {
'FR': "Nous avons l'intention de fabriquer et de vendre beaucoup",
'EN': "We intend to manufacture and sell a lot"
},
'keywords': {
'FR': [],
'EN': []
}
},
{
'usl':
usl(
fact([
(
def test_relations_order(self):
t = term('M:M:.O:O:.-')
self.assertTupleEqual(t.relations.contains, tuple(sorted(t.relations.contains)))
def test_table_relations(self):
t_p = term("M:M:.u.-")
t_ss = term("s.u.-")
self.assertFalse(t_p.relations.to(t_ss, relations_types=['table_2']))
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_relations_to(self):
self.assertTrue(term('wa.').relations.to(term('we.')))
def test_no_reflexive_relations(self):
self.assertEqual(term('O:O:.O:O:.t.-').relations.opposed, ())
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_relations_order(self):
t = term("M:M:.u.-")
self.assertTupleEqual(t.relations.contains,
tuple(sorted(t.relations.contains)))
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))
def test_irregular(self):
t = term("i.B:.-+u.M:.-U:.-'")
self.assertEqual(len(t.script.tables), 1)
self.assertEqual(t.script.tables[0].dim, 1)
def test_invalid_term(self):
with self.assertRaises(CannotParse):
self.parser.parse("[([A:A:A:.-'])]")
with self.assertRaises(TermNotFoundInDictionary):
term("A:A:A:.")
