def test_expand_compose_into_paths_pm2(self): u = usl( "s.-S:.U:.-' n.-T:.A:.-' d.-S:.U:.-' m1(E:.-U:.b.-l.-' E:.-U:.f.-l.-') m1(E:.-B:.k.-l.-')" ) p_u = list(u.iter_structure_path_by_script_ss()) res = usl_from_path_values(p_u) self.assertEqual(str(u), str(res))
def test_expand_compose_into_paths_empty_exclamation(self): u = usl( '[E:A:. (E:.-n.S:.-\')(b.a.- b.o.-n.o.-s.u.-\' f.a.-b.a.-f.o.-\') > E:A:. E:A:. ()(n.-S:.U:.-\'B:.-\'B:.-\',B:.-\',B:.-\',_ n.-S:.U:.-\'B:.-\'B:.-\',T:.-\',S:.-\',_) > ! E:A:. E:U:. ()]' ) p_u = list(u.iter_structure_path_by_script_ss()) res = usl_from_path_values(p_u) self.assertEqual(str(u), str(res))
def test_paths_values_to_usl(self): pm = [(">constant>S:", "S:"), (">constant>B:", "B:"), (">group_0 2>T:", "T:"), (">group_0 2>A:", "A:")] res = usl_from_path_values(pm) self.assertIsInstance(res, PolyMorpheme) self.assertEqual(str(res), "S: B: m2(A: T:)") pm = [(">content>constant>S:", "S:"), (">content>constant>B:", "B:"), (">content>group_0 1>T:", "T:")] res = usl_from_path_values(pm) self.assertIsInstance(res, Lexeme) self.assertEqual(str(res), "()(S: B: m1(T:))") pm = [(">role>! E:A:.>content>constant>S:", "S:"), (">role>E:A:. E:A:.>content>constant>B:", "B:"), (">role>E:A:. E:A:.>content>group_0>T:", "T:")] res = usl_from_path_values(pm) self.assertIsInstance(res, Word) self.assertEqual(str(res), "[! E:A:. ()(S:) > E:A:. E:A:. ()(B: m1(T:))]")
def test_usl_from_path_pm(self): structure = [(">constant>b.-S:.A:.-'S:.-'S:.-',", "b.-S:.A:.-'S:.-'S:.-',"), (">constant>k.a.-k.a.-'", "k.a.-k.a.-'"), (">constant", "U:"), (">constant", "E:")] usl_parser = IEMLParser().parse path_parser = PathParser().parse structure = [(path_parser(p), usl_parser(u)) for p, u in structure] u = usl_from_path_values(structure) self.assertEqual(str(u), "U: k.a.-k.a.-' b.-S:.A:.-'S:.-'S:.-',")
def test_usl_from_path_flexion_paradigm(self): structure = [ (">flexion", "E:.wo.U:.-t.o.-'"), (">flexion", "E:.wo.A:.-t.o.-'"), (">content>constant", "U:"), ] usl_parser = IEMLParser().parse path_parser = PathParser().parse structure = [(path_parser(p), usl_parser(u)) for p, u in structure] u = usl_from_path_values(structure) self.assertEqual(str(u), "(m1(E:.wo.U:.-t.o.-' E:.wo.A:.-t.o.-'))(U:)")
def test_expand_compose_into_paths(self): # parser = IEMLParser().parse gitdb = GitInterface( origin='https://github.com/plevyieml/ieml-language.git') gitdb.pull() db = IEMLDatabase(folder=gitdb.folder) usls = db.list(type=Word, parse=True) + db.list( type=PolyMorpheme, parse=True) + db.list(type=Lexeme, parse=True) for u in tqdm.tqdm(usls): p_u = list(u.iter_structure_path_by_script_ss()) res = usl_from_path_values(p_u) self.assertEqual(str(u), str(res), "expand_compose_into_paths failed on: " + str(u))
def test_usl_from_path(self): structure = { ">role>! E:A:.>flexion>E:": "E:", ">role>! E:A:.>content>constant>b.-S:.A:.-'S:.-'S:.-',": "b.-S:.A:.-'S:.-'S:.-',", ">role>E:A:. E:A:.>flexion>E:": "E:", ">role>E:A:. E:A:.>flexion>E:U:T:.": "E:U:T:.", ">role>E:A:. E:A:.>flexion>E:A:T:.": "E:A:T:.", ">role>E:A:. E:A:.>flexion>E:S:T:.": "E:S:T:.", ">role>E:A:. E:A:.>flexion>E:B:T:.": "E:B:T:.", ">role>E:A:. E:A:.>flexion>E:T:T:.": "E:T:T:.", ">role>E:A:. E:A:.>content>constant>k.a.-k.a.-'": "k.a.-k.a.-'" } usl_parser = IEMLParser().parse path_parser = PathParser().parse structure = [(path_parser(p), usl_parser(u)) for p, u in structure.items()] u = usl_from_path_values(structure) self.assertEqual( u, usl("[! E:A:. ()(b.-S:.A:.-'S:.-'S:.-',) > E:A:. E:A:. (m1(E:U:T:. E:A:T:. E:S:T:. E:B:T:. E:T:T:.))(k.a.-k.a.-')]" ))
def test_expand_compose_into_paths_pm(self): u = usl("E:T:S:. n.-T:.A:.-'") p_u = list(u.iter_structure_path_by_script_ss()) res = usl_from_path_values(p_u) self.assertEqual(str(u), str(res))
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()