UI translation

Author: GreenWizard2015

core/CAIAssistant.py

@@ -72,10 +72,9 @@ def _translateShallow(self, text, translation, language):
     translation = res['Translation']
     flags = res['Flags']
     totalIssues = sum([int(v) for v in flags.values()])
-    if totalIssues < 2:
-      return translation # all ok, no need to run deep translation
-    
-    return res, translation, res.get('Notification', '')
+    # if totalIssues < 2:
+    #   return translation # all ok, no need to run deep translation
+    return res, translation, totalIssues < 2
 
   def _translateDeep(self, text, translation, language, inputLanguage, flags):
     # extract first word from input language, can be separated by space, comma, etc.,
@@ -96,17 +95,15 @@ def _translateDeep(self, text, translation, language, inputLanguage, flags):
 
   def translate(self, text, fastTranslation, language):
     # run shallow translation
-    res = self._translateShallow(text=text, translation=fastTranslation, language=language)
-    if isinstance(res, str):
-      yield res
-      return # all ok, no need to run deep translation
-    
-    raw, translation, notification = res
-    yield translation, notification # yield shallow translation with notification
+    raw, translation, done = self._translateShallow(
+      text=text, translation=fastTranslation, language=language
+    )
+    yield translation, not done
+    if done: return
     # run deep translation
     yield self._translateDeep(
       text=text, translation=translation, language=language,
       inputLanguage=raw.get('Input language', 'unknown'),
       flags=raw['Flags']
-    )
+    ), False # no more pending translations
     return

core/worker.py

@@ -1,6 +1,7 @@
 import threading
 from googletrans import Translator
 import time
+from functools import lru_cache
 from .CAIAssistant import CAIAssistant
 
 class CWorker(threading.Thread):
@@ -22,7 +23,19 @@ def run(self):
       self._forceTranslateEvent.clear()
 
       text, language = self._events.userInput()
-      isForceTranslate = isForceTranslate or (language['code'] != oldLanguage['code'])
+      isLanguageChanged = language['code'] != oldLanguage['code']
+      if isLanguageChanged: # reload UI translation if language changed
+        try:
+          newLocalization = self._updateLocalization(
+            languageName=language['name'], languageCode=language['code']
+          )
+          self._events.updateLocalization(newLocalization)
+          oldText = None # reset text
+          oldLanguage = dict(language)
+        except Exception as e:
+          self._events.error(e)
+        continue
+      
       T = time.time()
       if not isForceTranslate:
         if text == oldText: continue # Not changed
@@ -51,8 +64,10 @@ def _performTranslate(self, text, force, language):
       self._events.fastTranslated(fastText)
       if not force: return
 
-      for fullText in self._fullTranslate(text, fastTranslation=fastText, language=language):
-        self._events.fullTranslated(fullText)
+
+      translationProcess = self._fullTranslate(text, fastTranslation=fastText, language=language)
+      for fullText, hasMore in translationProcess:
+        self._events.fullTranslated(fullText, pending=hasMore)
         if self._forceTranslateEvent.is_set(): break # stop if force another translate
         continue
     finally:
@@ -77,4 +92,14 @@ def _fullTranslate(self, text, fastTranslation, language):
     for translation in translationProcess:
       yield translation
       continue
-    return
+    return
+  
+  @lru_cache(maxsize=None)
+  def _updateLocalization(self, languageName, languageCode):
+    strings = self._events.localizationStrings()
+    res = self._translatorFast.translate('\n'.join(strings), dest=languageCode).text.split('\n')
+    res = [x.strip() for x in res]
+    res = [x for x in res if len(x) > 0]
+    assert len(strings) == len(res)
+    res = {k: v for k, v in zip(strings, res)}
+    return res

main.py

@@ -22,6 +22,11 @@
 class App(tk.Frame):
   def __init__(self, master, languages, currentLanguage=None):
     super().__init__(master)
+    self._localizationMap = {}
+    # predefine messages
+    self._localization('Processing...')
+    self._localization('Translation is not accurate and will be updated soon.')
+    # set up UI
     self._master = master
     self._languages = languages
     self._currentLanguage = currentLanguage or self._languages.keys()[0]
@@ -34,9 +39,18 @@ def __init__(self, master, languages, currentLanguage=None):
     self._worker = CWorker(self)
     self._worker.start()
     return
+  
+  def _localization(self, text):
+    res = self._localizationMap.get(text)
+    if res is None:
+      self._localizationMap[text] = res = tk.StringVar(value=text)
+    return res
 
   def _UI_inputArea(self, owner):
-    label = tk.Label(owner, text="Input Text:", justify="left", anchor="w")
+    label = tk.Label(
+      owner, justify="left", anchor="w",
+      textvariable=self._localization("Input Text:")
+    )
     label.pack(side="top", fill=tk.X)
 
     self._inputText = tkst.ScrolledText(owner)
@@ -61,22 +75,28 @@ def _UI_languageSelection(self, owner):
     self._language.pack(side="top", anchor="ne", padx=5, pady=5)
     self._language.bind("<<ComboboxSelected>>", self.onSelectLanguage)
     try:
-      self._language.set('Slovak')
+      self._language.set(self._languages[self._currentLanguage])
     except tk.TclError:
       pass
     return
 
   def _UI_outputArea(self, owner):
     self._UI_languageSelection(owner)
     # fast translation
-    label = tk.Label(owner, text=self.UITextFor("Fast Translation:"), justify="left", anchor="w")
+    label = tk.Label(
+      owner, justify="left", anchor="w",
+      textvariable=self._localization("Fast and inaccurate translation:")
+    )
     label.pack(side="top", fill=tk.X)
 
     self._fastOutputText = tkst.ScrolledText(owner, height=15)
     self._fastOutputText.pack(side="top", fill=tk.BOTH, expand=tk.YES)
 
     # full translation
-    label = tk.Label(owner, text=self.UITextFor("Full Translation:"), justify="left", anchor="w")
+    label = tk.Label(
+      owner, justify="left", anchor="w",
+      textvariable=self._localization("Slow and improved translation:")
+    )
     label.pack(side="top", fill=tk.X)
 
     self._fullOutputText = tkst.ScrolledText(owner)
@@ -110,23 +130,22 @@ def startTranslate(self, force=False):
     # set output text to "Processing..."
     if force:
       self._fullOutputText.delete("1.0", tk.END)
-      self._fullOutputText.insert(tk.END, self.UITextFor("Processing..."))
+      self._fullOutputText.insert(tk.END, self._localization("Processing...").get())
     return
 
   def fastTranslated(self, text):
     self._fastOutputText.delete("1.0", tk.END)
     self._fastOutputText.insert(tk.END, text)
     return
 
-  def fullTranslated(self, text):
-    notification = None
-    if isinstance(text, tuple):
-      text, notification = text
-
+  def fullTranslated(self, text, pending):
     self._fullOutputText.delete("1.0", tk.END)
     self._fullOutputText.insert(tk.END, text)
 
-    if notification is not None:
+    if pending:
+      notification = self._localization(
+        "Translation is not accurate and will be updated soon."
+      ).get()
       self._fullOutputText.insert(tk.END, "\n----------------\n" + notification)
     return
 
@@ -144,9 +163,15 @@ def onSelectLanguage(self, event):
     if code is None: return
 
     self._currentLanguage = code
-    # TODO: translate UI?
     return
 
+  def updateLocalization(self, localization):
+    for k, v in localization.items():
+      self._localizationMap[k].set(v)
+    return
+  
+  def localizationStrings(self): return list(self._localizationMap.keys())
+  
 if '__main__' == __name__:
   app = App(
     master=tk.Tk(),

prompts/translate_shallow.txt

@@ -12,5 +12,4 @@ reply in exactly next format:
 @Contains sarcasm: {{Yes/No}}
 @Complex sentence: {{Yes/No}}
 @Complex topic: {{Yes/No}}
-@Notification: {{"Translation is not accurate and will be updated soon." in {Language}, no comments}}
 ```