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