def p_poly_morpheme(self, p):
""" poly_morpheme : morpheme_sum group_list
| morpheme_sum
| group_list"""
if len(p) == 3:
p[0] = PolyMorpheme(constant=p[1], groups=p[2])
elif isinstance(p[1][0], Script):
p[0] = PolyMorpheme(constant=p[1], groups=())
else:
p[0] = PolyMorpheme(constant=[], groups=p[1])
def test_table_2d_paradigm_pm(self):
u = usl("l.-T:.U:.-',n.-T:.A:.-',b.-S:.A:.-'U:.-'U:.-',_ m1(E:S:.x.- S:.E:A:S:.- T:.E:A:T:.-) m1(u.A:.- a.S:.- t.o.-c.-' k.i.-t.i.-t.u.-' n.-T:.A:.-' l.-T:.U:.-',n.-T:.A:.-',m.-B:.U:.-'m.-B:.U:.-'E:A:T:.-',_ l.-T:.U:.-',n.-T:.A:.-',d.-S:.U:.-',_) m1(p.E:A:S:.- E:.-U:.d.-l.-')")
root_group0 = path(">group_0 1")
root_group1 = path(">group_1 1")
table = UslTable2D(u, rows=root_group1, columns=root_group0)
self.assertEqual(table.rows, sorted(table.rows))
self.assertEqual(table.columns, sorted(table.columns))
cells = table.cells
self.assertTrue(all(len(cells[0]) == len(row) for row in cells))
dim = (len(cells), len(cells[0]))
print(dim)
dim_column = root_group0.deference(u).cardinal
dim_row = root_group1.deference(u).cardinal
self.assertEqual((dim_row, dim_column), dim)
self.assertEqual(dim[0] * dim[1] * 3, u.cardinal)
all_cells = list(chain.from_iterable(cells))
for c in all_cells:
self.assertEqual(c.cardinal, 3)
self.assertEqual(len(all_cells), dim[0] * dim[1])
self.assertEqual(len(all_cells), len(set(all_cells)))
self.assertEqual({PolyMorpheme([m]) for v in table.column_paths_variation for p, m in v},
root_group0.deference(u).singular_sequences_set)
self.assertEqual({PolyMorpheme([m]) for v in table.row_paths_variation for p, m in v},
root_group1.deference(u).singular_sequences_set)
for r, cells_row in zip(table.rows, cells):
for r_c, cell in zip(r.singular_sequences, cells_row):
for m_r in r_c.morphemes:
if not m_r.empty:
self.assertIn(m_r, cell.morphemes)
for c, cells_column in zip(table.columns, zip(*cells)):
for c_r, cell in zip(c.singular_sequences, cells_column):
for m_c in c_r.morphemes:
if not m_c.empty:
self.assertIn(m_c, cell.morphemes)
def p_lexeme(self, p):
"""lexeme : LPAREN poly_morpheme RPAREN LPAREN poly_morpheme RPAREN LPAREN poly_morpheme RPAREN
| LPAREN RPAREN LPAREN poly_morpheme RPAREN LPAREN poly_morpheme RPAREN
| LPAREN RPAREN LPAREN RPAREN LPAREN poly_morpheme RPAREN
| LPAREN poly_morpheme RPAREN LPAREN poly_morpheme RPAREN
| LPAREN RPAREN LPAREN poly_morpheme RPAREN
| LPAREN poly_morpheme RPAREN
| LPAREN RPAREN"""
if len(p) == 10:
p[0] = Lexeme(pm_flexion=PolyMorpheme(
constant=p[2].constant + p[8].constant,
groups=p[2].groups + p[8].groups),
pm_content=p[5])
elif len(p) == 9:
p[0] = Lexeme(pm_flexion=p[7], pm_content=p[4])
elif len(p) == 8:
p[0] = Lexeme(pm_flexion=p[6],
pm_content=PolyMorpheme(constant=[]))
elif len(p) == 7:
p[0] = Lexeme(pm_flexion=p[2], pm_content=p[5])
elif len(p) == 6:
p[0] = Lexeme(pm_flexion=PolyMorpheme(constant=[]),
pm_content=p[4])
elif len(p) == 4:
p[0] = Lexeme(pm_flexion=p[2],
pm_content=PolyMorpheme(constant=[]))
else:
p[0] = Lexeme(pm_flexion=PolyMorpheme(constant=[]),
pm_content=PolyMorpheme(constant=[]))
def _compute_singular_sequences(self):
res = [(NULL_SCRIPTS[0],)]
if len(self.items) == 0:
return res
for i in range(0, self.multiplicity):
for m in combinations(self.items, i + 1):
res.append(tuple(m))
from ieml.usl import PolyMorpheme
return tuple(PolyMorpheme(constant=list(r)) for r in res)
def test_table_lexeme_content_flexion_paradigm(self):
u = usl("(m1(E:.wo.U:.-t.o.-' E:.wo.A:.-t.o.-'))(n.-T:.A:.-' m1(E:T:S:. E:T:T:. we.f.T:.- u.A:.- p.E:A:S:.- s.-S:.A:.-') m1(E:S:.x.- n.-T:.U:.-'))")
root_group1 = path(">flexion")
root_group0 = path(">content")
table = UslTable2D(u, rows=root_group1, columns=root_group0)
self.assertEqual(table.rows, sorted(table.rows))
self.assertEqual(table.columns, sorted(table.columns))
cells = table.cells
self.assertTrue(all(len(cells[0]) == len(row) for row in cells))
dim = (len(cells), len(cells[0]))
print(dim)
dim_column = root_group0.deference(u).cardinal
dim_row = root_group1.deference(u).cardinal
self.assertEqual((dim_row, dim_column), dim)
self.assertEqual(dim[0] * dim[1], u.cardinal)
all_cells = list(chain.from_iterable(cells))
for c in all_cells:
self.assertEqual(c.cardinal, 1)
self.assertEqual(len(all_cells), dim[0] * dim[1])
self.assertEqual(len(all_cells), len(set(all_cells)))
self.assertEqual({PolyMorpheme([m]) for v in table.row_paths_variation for p, m in v},
root_group1.deference(u).singular_sequences_set)
self.assertEqual({m for v in table.column_paths_variation for p, m in v if not m.empty},
set(root_group0.deference(u).morphemes))
for r, cells_row in zip(table.rows, cells):
self.assertEqual(r.cardinal, dim[1])
for r_c, cell in zip(r.singular_sequences, cells_row):
for m_r in r_c.morphemes:
if not m_r.empty:
self.assertIn(m_r, cell.morphemes)
for c, cells_column in zip(table.columns, zip(*cells)):
self.assertEqual(c.cardinal, dim[0])
for c_r, cell in zip(c.singular_sequences, cells_column):
for m_c in c_r.morphemes:
if not m_c.empty:
self.assertIn(m_c, cell.morphemes)
def check_table(self, u, root_group0, root_group1):
table = UslTable2D(u, rows=root_group0, columns=root_group1)
self.assertEqual(table.rows, sorted(table.rows))
self.assertEqual(table.columns, sorted(table.columns))
cells = table.cells
self.assertTrue(all(len(cells[0]) == len(row) for row in cells))
dim = (len(cells), len(cells[0]))
print(dim)
self.assertEqual((1 if root_group0 is None else root_group0.deference(u).cardinal,
root_group1.deference(u).cardinal), dim)
for c in chain.from_iterable(cells):
self.assertEqual(c.cardinal, 1)
all_cells = set(chain.from_iterable(cells))
self.assertEqual(len(all_cells), dim[0] * dim[1])
self.assertEqual({PolyMorpheme([m]) for v in table.row_paths_variation for p, m in v},
set() if root_group0 is None else root_group0.deference(u).singular_sequences_set)
self.assertEqual({PolyMorpheme([m]) for v in table.column_paths_variation for p, m in v},
root_group1.deference(u).singular_sequences_set)
for r, cells_row in zip(table.rows, cells):
for r_c, cell in zip(r.singular_sequences, cells_row):
for m_r in r_c.morphemes:
if not m_r.empty:
self.assertIn(m_r, cell.morphemes)
for c, cells_column in zip(table.columns, zip(*cells)):
for c_r, cell in zip(c.singular_sequences, cells_column):
for m_c in c_r.morphemes:
if not m_c.empty:
self.assertIn(m_c, cell.morphemes)
def rewrite_word(w: Word):
res = []
word_role = w.role.constant if w.syntagmatic_fun.__class__ not in [DependantQualitySyntagmaticFunction, IndependantQualitySyntagmaticFunction] else \
w.role.constant[1:]
for r, sfun in w.syntagmatic_fun.actors.items():
if all(l.actor.empty for l in sfun.actors.values() if l.actor is not None) and \
(len(word_role) < len(r.constant) or any(rw != rn for rw, rn in zip(word_role, r.constant))):
continue
actor_flexion = [
s for s in sfun.actor.pm_flexion.constant
if str(s) not in TO_REMOVE.get(sfun.__class__, [])
]
res.append([
r.constant,
Lexeme(PolyMorpheme(constant=actor_flexion), sfun.actor.pm_content)
])
sfun = w.syntagmatic_fun._from_list(res)
return Word(sfun, role=w.role, context_type=w.syntagmatic_fun.__class__)
def usl(
arg: Union[str, Script, USL, Iterable[Tuple['UslPath', Union[USL,
Script]]]]
) -> USL:
"""
Cast argument to an USL type, depending on the argument type.
- If argument is a string, it is parsed by ieml.usl.parser.IEMLParser.parse
- if argument is a ieml.dictionary.Script, the returned object is a
ieml.usl.polymorpheme.PolyMorpheme with the argument as the constant.
- if argument is an ieml.usl.usl.USL, the argument is returned
- if argument is a list of (ieml.usl.decoration.path.UslPath, ieml.usl.usl.USL)
:param arg:
:type arg: Union[str, Script, USL, Iterable[Tuple['UslPath', Union[USL, Script]]]]
:return: an ieml.usl.usl.USL
"""
if isinstance(arg, str):
from ieml.usl.parser import IEMLParser
return IEMLParser().parse(arg)
if isinstance(arg, Script):
from ieml.usl import PolyMorpheme
return PolyMorpheme(constant=[arg])
if isinstance(arg, USL):
return arg
#if iterable, can be a list of (path, usl) to convert into an usl
try:
usl_list = list(arg)
except TypeError:
pass
else:
if not usl_list:
from ieml.usl import PolyMorpheme
return PolyMorpheme(constant=[])
from ieml.usl.decoration.path import UslPath, usl_from_path_values
if not all(
isinstance(u, (USL, Script)) and isinstance(p, UslPath)
for p, u in usl_list):
raise ValueError(
"Invalid iterable of (UslPath, USL) to create an USL from.")
return usl_from_path_values(usl_list)
# from ieml.lexicon.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.lexicon 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()