bilsearch mode

apertium_apy/apy.py

@@ -40,6 +40,7 @@
 from apertium_apy.handlers import (
     AnalyzeHandler,
     BaseHandler,
+    BilsearchHandler,
     CoverageHandler,
     GenerateHandler,
     GuesserHandler,
@@ -136,6 +137,8 @@ def setup_handler(
             handler.spellers[lang_src] = (dirpath, modename)
     for dirpath, modename, lang_pair in modes['guesser']:
         handler.guessers[lang_pair] = (dirpath, modename)
+    for dirpath, modename, lang_pair in modes['bilsearch']:
+        handler.bilsearch[lang_pair] = (dirpath, modename)
 
     handler.init_pairs_graph()
     handler.init_paths()
@@ -285,6 +288,7 @@ def setup_application(args):
         (r'/identifyLang', IdentifyLangHandler),
         (r'/getLocale', GetLocaleHandler),
         (r'/pipedebug', PipeDebugHandler),
+        (r'/bilsearch', BilsearchHandler),
     ]  # type: List[Tuple[str, Type[tornado.web.RequestHandler]]]
 
     if importlib_util.find_spec('streamparser'):

apertium_apy/handlers/__init__.py

@@ -17,3 +17,4 @@
 from apertium_apy.handlers.translate_doc import TranslateDocHandler  # noqa: F401
 from apertium_apy.handlers.translate_raw import TranslateRawHandler  # noqa: F401
 from apertium_apy.handlers.translate_webpage import TranslateWebpageHandler  # noqa: F401
+from apertium_apy.handlers.bilsearch import BilsearchHandler  # noqa: F401

apertium_apy/handlers/base.py

@@ -36,6 +36,7 @@ class BaseHandler(tornado.web.RequestHandler):
     taggers = {}  # type: Dict[str, Tuple[str, str]]
     spellers = {}  # type: Dict[str, Tuple[str, str]]
     guessers = {}  # type: Dict[str, Tuple[str, str]]
+    bilsearch = {} # type: Dict[str, Tuple[str, str]]
     pairprefs = {}        # type: Dict[str, Dict[str, Dict[str, str]]]
     # (l1, l2): [translation.Pipeline], only contains flushing pairs!
     pipelines = {}  # type: Dict[Tuple[str, str], List[Union[FlushingPipeline, SimplePipeline]]]

apertium_apy/handlers/list_modes.py

@@ -31,6 +31,18 @@ def get(self):
             self.send_response({lang_src: modename for (lang_src, (path, modename)) in self.spellers.items()})
         elif query == 'guessers':
             self.send_response({lang_src: modename for (lang_src, (path, modename)) in self.guessers.items()})
+        elif query == 'bilsearch':
+            src = self.get_argument('src', default=None)
+            response_data = []
+            if src:
+                pairs = [(src, trg) for trg in self.paths[src]]
+            else:
+                pairs = [(p[0], p[1]) for par in self.pairs for p in [par.split('-')]]
+            for (l1, l2) in pairs:
+                response_data.append({'sourceLanguage': l1, 'targetLanguage': l2})
+                if self.get_arguments('include_deprecated_codes'):
+                    response_data.append({'sourceLanguage': to_alpha2_code(l1), 'targetLanguage': to_alpha2_code(l2)})
+            self.send_response({'responseData': response_data, 'responseDetails': None, 'responseStatus': 200})
 
         else:
             self.send_error(400, explanation='Expecting q argument to be one of analysers, generators, guessers, spellers, disambiguators, or pairs')

apertium_apy/mode_search.py

@@ -42,6 +42,7 @@ def search_path(rootpath, include_pairs=True, verbosity=1):
         'spell': re.compile(r'(({0}(-{0})?)-spell)\.mode'.format(lang_code)),
         'tokenise': re.compile(r'(({0}(-{0})?)-tokenise)\.mode'.format(lang_code)),
         'guesser': re.compile(r'(({0}(-{0})?)-guess(er)?)\.mode'.format(lang_code)),
+        'bilsearch': re.compile(r'({0})-({0})-bilsearch\.mode'.format(lang_code)),
     }
     modes = {
         'pair': [],
@@ -51,6 +52,7 @@ def search_path(rootpath, include_pairs=True, verbosity=1):
         'spell': [],
         'tokenise': [],
         'guesser': [],
+        'bilsearch': [],
     }  # type: Dict[str, List[Tuple[str, str, str]]]
 
     real_root = os.path.abspath(os.path.realpath(rootpath))
@@ -63,14 +65,20 @@ def search_path(rootpath, include_pairs=True, verbosity=1):
             for mtype, regex in type_re.items():
                 m = regex.match(filename)
                 if m:
-                    if mtype != 'pair':
-                        modename = m.group(1)  # e.g. en-es-anmorph
+                    if mtype == 'bilsearch':
+                        lang_src = to_alpha3_code(m.group(1))
+                        lang_trg = to_alpha3_code(m.group(2))
+                        lang_pair = f"{lang_src}-{lang_trg}"
+                        modename = f"{lang_pair}-bilsearch"
+                        dir_of_modes = os.path.dirname(dirpath)
+                        mode = (dir_of_modes, modename, lang_pair)
+                        modes[mtype].append(mode)
+                    elif mtype != 'pair':
+                        modename = m.group(1)
                         langlist = [to_alpha3_code(x) for x in m.group(2).split('-')]
-                        lang_pair = '-'.join(langlist)  # e.g. en-es
+                        lang_pair = '-'.join(langlist)
                         dir_of_modes = os.path.dirname(dirpath)
-                        mode = (dir_of_modes,
-                                modename,
-                                lang_pair)
+                        mode = (dir_of_modes, modename, lang_pair)
                         modes[mtype].append(mode)
                     elif include_pairs:
                         lang_src = m.group(1)

language_names/manual-additions.tsv

@@ -281,6 +281,7 @@ szl	xh	xosa
 szl	zh	chińskŏ
 szl	zu	zulu
 tki	tki	توركمانجه
+uk	uum	урумська
 vro	vro	võro
 wad	wad	Wamesa
 wal	wal	Wolaytta