Add machine_translate_pofile management command

wagtail_localize/machine_translators/deepl.py

@@ -16,19 +16,19 @@ def language_code(code, is_target=False):
 class DeepLTranslator(BaseMachineTranslator):
  display_name = "DeepL"
 
- def translate(self, source_locale, target_locale, strings):
+ def translate(self, source_language_code, target_language_code, strings):
  response = requests.post('https://api.deepl.com/v2/translate', {
  'auth_key': self.options['AUTH_KEY'],
  'text': [string.data for string in strings],
  'tag_handling': 'xml',
- 'source_lang': language_code(source_locale.language_code),
- 'target_lang': language_code(target_locale.language_code, is_target=True),
+ 'source_lang': language_code(source_language_code),
+ 'target_lang': language_code(target_language_code, is_target=True),
  })
 
  return {
  string: StringValue(translation['text'])
  for string, translation in zip(strings, response.json()['translations'])
  }
 
- def can_translate(self, source_locale, target_locale):
- return language_code(source_locale.language_code) != language_code(target_locale.language_code, is_target=True)
+ def can_translate(self, source_language_code, target_language_code):
+ return language_code(source_language_code) != language_code(target_language_code, is_target=True)

wagtail_localize/machine_translators/tests/test_dummy_translator.py

@@ -24,7 +24,7 @@ def test_translate_text(self):
  def test_translate_html(self):
  string, attrs = StringValue.from_source_html('<a href="https://en.wikipedia.org/wiki/World">Hello world!</a>. <b>This is a test</b>.')
 
- translations = DummyTranslator({}).translate(self.english_locale, self.french_locale, [
+ translations = DummyTranslator({}).translate(self.english_locale.language_code, self.french_locale.language_code, [
  string
  ])
 
@@ -33,11 +33,11 @@ def test_translate_html(self):
  def test_can_translate(self):
  canada_french_locale = Locale.objects.create(language_code="fr-CA")
 
- self.assertTrue(DummyTranslator({}).can_translate(self.english_locale, self.french_locale))
- self.assertTrue(DummyTranslator({}).can_translate(self.english_locale, canada_french_locale))
+ self.assertTrue(DummyTranslator({}).can_translate(self.english_locale.language_code, self.french_locale.language_code))
+ self.assertTrue(DummyTranslator({}).can_translate(self.english_locale.language_code, canada_french_locale.language_code))
 
  # Can't translate the same language
- self.assertFalse(DummyTranslator({}).can_translate(self.english_locale, self.english_locale))
+ self.assertFalse(DummyTranslator({}).can_translate(self.english_locale.language_code, self.english_locale.language_code))
 
  # Can't translate two variants of the same language
- self.assertFalse(DummyTranslator({}).can_translate(self.french_locale, canada_french_locale))
+ self.assertFalse(DummyTranslator({}).can_translate(self.french_locale.language_code, canada_french_locale.language_code))

wagtail_localize/management/commands/machine_translate_pofile.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+import polib
+from django.core.management.base import BaseCommand
+
+from wagtail_localize.machine_translators import get_machine_translator
+from wagtail_localize.strings import StringValue
+
+
+class Command(BaseCommand):
+ def add_arguments(self, parser):
+ parser.add_argument('source_language_code', type=str)
+ parser.add_argument('target_language_code', type=str)
+ parser.add_argument('pofile', type=Path)
+
+ def handle(self, source_language_code, target_language_code, pofile, **options):
+ po = polib.pofile(str(pofile))
+
+ messages = set(StringValue(entry.msgid) for entry in po)
+
+ translator = get_machine_translator()
+ translations = translator.translate(source_language_code, target_language_code, list(messages))
+
+ new_po = polib.POFile()
+
+ for entry in po:
+ entry.msgstr = translations[StringValue(entry.msgid)].data
+ new_po.append(entry)
+
+ print(str(new_po))

wagtail_localize/views/edit_translation.py

@@ -822,7 +822,7 @@ def machine_translate(request, translation_id):
  segments[segment.string].append((string_segment.string_id, string_segment.context_id))
 
  if segments:
- translations = translator.translate(translation.source.locale, translation.target_locale, segments.keys())
+ translations = translator.translate(translation.source.locale.language_code, translation.target_locale.language_code, segments.keys())
 
  with transaction.atomic():
  for string, contexts in segments.items():