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()