update: rename Translator -> LangProvider and associated elements (NVIDIA#1183)

Author: jmartin-tech

garak/_config.py

@@ -116,7 +116,7 @@ def _nested_dict():
 run.seed = None
 run.soft_probe_prompt_cap = 64
 run.target_lang = "en"
-run.translators = []
+run.langproviders = []
 
 # placeholder
 # generator, probe, detector, buff = {}, {}, {}, {}

garak/attempt.py

@@ -40,8 +40,8 @@ class Attempt:
     :type messages: List(dict)
     :param lang: Language code for prompt as sent to the target
     :type lang: str, valid BCP47
-    :param reverse_translator_outputs: The reverse translation of output based on the original language of the probe
-    :param reverse_translator_outputs: List(str)
+    :param reverse_translation_outputs: The reverse translation of output based on the original language of the probe
+    :param reverse_translation_outputs: List(str)
 
     Expected use
     * an attempt tracks a seed prompt and responses to it
@@ -77,7 +77,7 @@ def __init__(
         goal=None,
         seq=-1,
         lang=None,  # language code for prompt as sent to the target
-        reverse_translator_outputs=None,
+        reverse_translation_outputs=None,
     ) -> None:
         self.uuid = uuid.uuid4()
         self.messages = []
@@ -93,8 +93,8 @@ def __init__(
         if prompt is not None:
             self.prompt = prompt
         self.lang = lang
-        self.reverse_translator_outputs = (
-            {} if reverse_translator_outputs is None else reverse_translator_outputs
+        self.reverse_translation_outputs = (
+            {} if reverse_translation_outputs is None else reverse_translation_outputs
         )
 
     def as_dict(self) -> dict:
@@ -114,7 +114,7 @@ def as_dict(self) -> dict:
             "goal": self.goal,
             "messages": self.messages,
             "lang": self.lang,
-            "reverse_translator_outputs": list(self.reverse_translator_outputs),
+            "reverse_translation_outputs": list(self.reverse_translation_outputs),
         }
 
     @property
@@ -206,12 +206,7 @@ def prompt_for(self, lang) -> str:
 
         When "*" or None are passed returns the prompt passed to the model
         """
-        if (
-            lang is not None
-            and self.lang != "*"
-            and lang != "*"
-            and self.lang != lang
-        ):
+        if lang is not None and self.lang != "*" and lang != "*" and self.lang != lang:
             return self.notes.get(
                 "pre_translation_prompt", self.prompt
             )  # update if found in notes
@@ -223,13 +218,8 @@ def outputs_for(self, lang) -> List[str]:
 
         When "*" or None are passed returns the original model output
         """
-        if (
-            lang is not None
-            and self.lang != "*"
-            and lang != "*"
-            and self.lang != lang
-        ):
-            return self.reverse_translator_outputs
+        if lang is not None and self.lang != "*" and lang != "*" and self.lang != lang:
+            return self.reverse_translation_outputs
         return self.all_outputs
 
     def _expand_prompt_to_histories(self, breadth):

garak/buffs/low_resource_languages.py

@@ -35,23 +35,23 @@ def __init__(self, config_root=_config):
     def transform(
         self, attempt: garak.attempt.Attempt
     ) -> Iterable[garak.attempt.Attempt]:
-        translator = Translator(self.api_key)
+        deepl_translator = Translator(self.api_key)
         prompt = attempt.prompt
         attempt.notes["original_prompt"] = prompt
         for language in LOW_RESOURCE_LANGUAGES:
             attempt.notes["LRL_buff_dest_lang"] = language
-            response = translator.translate_text(prompt, target_lang=language)
+            response = deepl_translator.translate_text(prompt, target_lang=language)
             translated_prompt = response.text
             attempt.prompt = translated_prompt
             yield self._derive_new_attempt(attempt)
 
     def untransform(self, attempt: garak.attempt.Attempt) -> garak.attempt.Attempt:
-        translator = Translator(self.api_key)
+        deepl_translator = Translator(self.api_key)
         outputs = attempt.outputs
         attempt.notes["original_responses"] = outputs
         translated_outputs = list()
         for output in outputs:
-            response = translator.translate_text(output, target_lang="EN-US")
+            response = deepl_translator.translate_text(output, target_lang="EN-US")
             translated_output = response.text
             translated_outputs.append(translated_output)
         attempt.outputs = translated_outputs

garak/harnesses/base.py

@@ -28,15 +28,15 @@ def _initialize_runtime_services():
     """Initialize and validate runtime services required for a successful test"""
 
     from garak.exception import GarakException
-    from garak.langservice import load_translators
+    import garak.langservice
 
     # TODO: this block may be gated in the future to ensure it is only run once. At this time
     # only one harness will execute per run so the output here is reasonable.
     try:
         msg = "🌐 Loading Language services if required."
         logging.info(msg)
         print(msg)
-        load_translators()
+        garak.langservice.load()
     except GarakException as e:
         logging.critical("❌ Language setup failed! ❌", exc_info=e)
         raise e

garak/translators/base.py renamed to garak/langproviders/base.py

@@ -126,7 +126,7 @@ def is_meaning_string(text: str) -> bool:
 
 
 # To be `Configurable` the root object must meet the standard type search criteria
-# { translators:
+# { langproviders:
 #     "local": { # model_type
 #       "language": "<from>-<to>"
 #       "name": "model/name" # model_name
@@ -136,8 +136,8 @@ def is_meaning_string(text: str) -> bool:
 from garak.configurable import Configurable
 
 
-class Translator(Configurable):
-    """Base class for objects that execute translation"""
+class LangProvider(Configurable):
+    """Base class for objects that provision language"""
 
     def __init__(self, config_root: dict = {}) -> None:
         self._load_config(config_root=config_root)
@@ -146,9 +146,9 @@ def __init__(self, config_root: dict = {}) -> None:
 
         self._validate_env_var()
 
-        self._load_translator()
+        self._load_langprovider()
 
-    def _load_translator(self):
+    def _load_langprovider(self):
         raise NotImplementedError
 
     def _translate(self, text: str) -> str:
@@ -218,7 +218,7 @@ def _should_skip_line(self, line: str) -> bool:
     def _clean_line(self, line: str) -> str:
         return remove_english_punctuation(line.strip().lower().split())
 
-    def translate(
+    def get_text(
         self,
         prompts: List[str],
         reverse_translate_judge: bool = False,

garak/translators/local.py renamed to garak/langproviders/local.py

@@ -2,34 +2,34 @@
 # SPDX-License-Identifier: Apache-2.0
 
 
-"""Translator that translates a prompt."""
+"""Local language providers & translators."""
 
 
 from typing import List
 
 from garak.exception import BadGeneratorException
-from garak.translators.base import Translator
+from garak.langproviders.base import LangProvider
 from garak.resources.api.huggingface import HFCompatible
 
 
-class NullTranslator(Translator):
-    """Stand-in translator for pass through"""
+class Passthru(LangProvider):
+    """Stand-in language provision for pass through / noop"""
 
-    def _load_translator(self):
+    def _load_langprovider(self):
         pass
 
     def _translate(self, text: str) -> str:
         return text
 
-    def translate(
+    def get_text(
         self,
         prompts: List[str],
         reverse_translate_judge: bool = False,
     ) -> List[str]:
         return prompts
 
 
-class LocalHFTranslator(Translator, HFCompatible):
+class LocalHFTranslator(LangProvider, HFCompatible):
     """Local translation using Huggingface m2m100 or Helsinki-NLP/opus-mt-* models
 
     Reference:
@@ -56,7 +56,7 @@ def __init__(self, config_root: dict = {}) -> None:
         self.device = self._select_hf_device()
         super().__init__(config_root=config_root)
 
-    def _load_translator(self):
+    def _load_langprovider(self):
         if "m2m100" in self.model_name:
             from transformers import M2M100ForConditionalGeneration, M2M100Tokenizer
 
@@ -89,7 +89,7 @@ def _load_translator(self):
                 self.source_lang in lang_support and self.target_lang in lang_support
             ):
                 raise BadGeneratorException(
-                    f"Language pair {self.language} is not supported for this translator service."
+                    f"Language pair {self.language} is not supported for this translation service."
                 )
 
             self.model = M2M100ForConditionalGeneration.from_pretrained(

garak/translators/remote.py renamed to garak/langproviders/remote.py

@@ -8,12 +8,12 @@
 import logging
 
 from garak.exception import BadGeneratorException
-from garak.translators.base import Translator
+from garak.langproviders.base import LangProvider
 
 VALIDATION_STRING = "A"  # just send a single ASCII character for a sanity check
 
 
-class RivaTranslator(Translator):
+class RivaTranslator(LangProvider):
     """Remote translation using NVIDIA Riva translation API
 
     https://developer.nvidia.com/riva
@@ -47,18 +47,18 @@ class RivaTranslator(Translator):
 
     # avoid attempt to pickle the client attribute
     def __getstate__(self) -> object:
-        self._clear_translator()
+        self._clear_langprovider()
         return dict(self.__dict__)
 
     # restore the client attribute
     def __setstate__(self, d) -> object:
         self.__dict__.update(d)
-        self._load_translator()
+        self._load_langprovider()
 
-    def _clear_translator(self):
+    def _clear_langprovider(self):
         self.client = None
 
-    def _load_translator(self):
+    def _load_langprovider(self):
         if not (
             self.source_lang in self.lang_support
             and self.target_lang in self.lang_support
@@ -91,7 +91,7 @@ def _load_translator(self):
     def _translate(self, text: str) -> str:
         try:
             if self.client is None:
-                self._load_translator()
+                self._load_langprovider()
             response = self.client.translate(
                 [text], "", self._source_lang, self._target_lang
             )
@@ -101,7 +101,7 @@ def _translate(self, text: str) -> str:
             return text
 
 
-class DeeplTranslator(Translator):
+class DeeplTranslator(LangProvider):
     """Remote translation using DeepL translation API
 
     https://www.deepl.com/en/translator
@@ -127,7 +127,7 @@ class DeeplTranslator(Translator):
         "en": "en-US",
     }
 
-    def _load_translator(self):
+    def _load_langprovider(self):
         from deepl import Translator
 
         if not (