moved to v3.4.6

README.md

@@ -74,7 +74,7 @@ They both have a debug field, but neither module really uses it.
 
 ## **Translator**<a name="translator"></a>
 
-Kudasai supports 3 different translation methods at the moment, OpenAI's GPT, Google's Gemini, and DeepL. 
+Kudasai supports 4 different translation methods at the moment, OpenAI's GPT, Google's Gemini  & Google Translate, and DeepL. 
 
 For OpenAI, you'll need an API key, you can get one [here](https://platform.openai.com/docs/api-reference/authentication). This is a paid service with no free tier.
 
@@ -82,13 +82,15 @@ For Gemini, you'll also need an API key, you can get one [here](https://ai.googl
 
 For DeepL, you'll need an API key too, you can get one [here](https://www.deepl.com/pro#developer). DeepL is also a paid service but is free under 500k characters a month.
 
+And for Google Translate, you'll need a Google Cloud API key, you can get one [here](https://cloud.google.com/translate/docs/setup). Google Translate is a paid service, but is free under 500k characters a month. Kudasai uses v2 of the API so make sure you follow the instructions to get credentials for that.
+
 I'd recommend using GPT for most things, as it's generally better at translation.
 
-Mostly straightforward, choose your translation method, fill in your API key, and select your text. You'll also need to add your settings file if on HuggingFace if you want to tune the output, but the default is generally fine.
+Mostly straightforward, choose your translation method, fill in your API key, and select your text. You'll also need to add your settings file if on HuggingFace if you want to tune the output, but the default is generally fine. Although for google translate this needs to be the contents of your service key json, all one one line too.
 
 You can calculate costs here or just translate. Output will show in the appropriate fields.
 
-For further details on the settings file, see [here](#translation-with-llms-settings).
+For further details on the settings file, see [here](#translation-with-llms-settings). Note that Google Translate has no settings.
 
 ---------------------------------------------------------------------------------------------------------------------------------------------------
 

handlers/json_handler.py

@@ -25,7 +25,6 @@ class JsonHandler:
     with open(FileEnsurer.translation_settings_description_path, 'r', encoding='utf-8') as file:
         translation_settings_message = file.read()
 
-
 ##-------------------start-of-validate_json()--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
     @staticmethod
@@ -125,6 +124,12 @@ class JsonHandler:
             assert all(key in gemini_settings for key in gemini_keys), "gemini settings keys missing"
             assert all(key in deepl_settings for key in deepl_keys), "deepl settings keys missing"
 
+            ## ensure that those sections don't have any extra keys
+            assert all(key in base_translation_keys for key in base_translation_settings), "base translation settings has extra keys"
+            assert all(key in openai_keys for key in openai_settings), "openai settings has extra keys" 
+            assert all(key in gemini_keys for key in gemini_settings), "gemini settings has extra keys"
+            assert all(key in deepl_keys for key in deepl_settings), "deepl settings has extra keys"
+
             ## validate each key using the validation rules
             for key, validate in validation_rules.items():
                 if(key in base_translation_settings and not validate(base_translation_settings[key])):

kudasai.py

@@ -6,7 +6,6 @@ import asyncio
 import re
 import typing
 import logging
-import argparse
 
 ## third-party libraries
 from kairyou import Kairyou
@@ -307,11 +306,12 @@ async def main() -> None:
 
         if(len(sys.argv) <= 1):
             await run_console_version()
-        
+
         elif(len(sys.argv) in [2, 3, 4, 5, 6]):
             await run_cli_version()
 
         else:
+            print(f"Invalid number of arguments ({len(sys.argv)}), max of 6. Please use --help for more information.")
             print_usage_statement()
 
     except Exception as e:
@@ -346,8 +346,6 @@ async def run_console_version():
 
         raise e
     
-    print("In progress...")
-
     await Kudasai.run_kudasai()
 
 ##-------------------start-of-run_cli_version()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -369,7 +367,7 @@ async def run_cli_version():
         """
 
         conditions = [
-            (lambda arg: arg in ["deepl", "openai", "gemini"], "translation_method"),
+            (lambda arg: arg in ["deepl", "openai", "gemini", "google_translate"], "translation_method"),
             (lambda arg: os.path.exists(arg) and not ".json" in arg, "text_to_translate"),
             (lambda arg: len(arg) > 10 and not os.path.exists(arg), "api_key"),
             (lambda arg: arg == "translate", "identifier"),
@@ -378,11 +376,12 @@ async def run_cli_version():
 
         for condition, result in conditions:
             if(condition(arg)):
-                print(result)
+                print(f"Determined argument for '{arg}' as '{result}'")
+                logging.debug(f"Determined argument for '{arg}' as '{result}'")
                 return result
-
-        raise Exception("Invalid argument. Please use 'deepl', 'openai', or 'gemini'.")
-        
+            
+        raise Exception("Invalid argument. Please use 'deepl', 'openai', or 'gemini', or 'google_translate')")
+    
     mode = ""
 
     try:
@@ -419,7 +418,9 @@ async def run_cli_version():
             method_to_translation_mode = {
                 "openai": "1",
                 "gemini": "2",
-                "deepl": "3"
+                "deepl": "3",
+                "google_translate": "4",
+                "google translate": "4"
             }
 
             Kudasai.text_to_preprocess = FileEnsurer.standard_read_file(sys.argv[arg_indices['text_to_translate_index']].strip('"'))
@@ -498,6 +499,7 @@ Modes:
 Additional Notes:
 - All arguments should be enclosed in double quotes if they contain spaces. But double quotes are optional and will be striped. Single quotes are not allowed
 - For more information, refer to the documentation at README.md
+- For google translate, enter the method as 'google_translate', also google_translate doesn't support the api_key argument
 """)
 
 

lib/gui/HUGGING_FACE_README.md

@@ -74,7 +74,7 @@ They both have a debug field, but neither module really uses it.
 
 ## **Translator**<a name="translator"></a>
 
-Kudasai supports 3 different translation methods at the moment, OpenAI's GPT, Google's Gemini, and DeepL. 
+Kudasai supports 4 different translation methods at the moment, OpenAI's GPT, Google's Gemini  & Google Translate, and DeepL. 
 
 For OpenAI, you'll need an API key, you can get one [here](https://platform.openai.com/docs/api-reference/authentication). This is a paid service with no free tier.
 
@@ -82,13 +82,15 @@ For Gemini, you'll also need an API key, you can get one [here](https://ai.googl
 
 For DeepL, you'll need an API key too, you can get one [here](https://www.deepl.com/pro#developer). DeepL is also a paid service but is free under 500k characters a month.
 
+And for Google Translate, you'll need a Google Cloud API key, you can get one [here](https://cloud.google.com/translate/docs/setup). Google Translate is a paid service, but is free under 500k characters a month. Kudasai uses v2 of the API so make sure you follow the instructions to get credentials for that.
+
 I'd recommend using GPT for most things, as it's generally better at translation.
 
-Mostly straightforward, choose your translation method, fill in your API key, and select your text. You'll also need to add your settings file if on HuggingFace if you want to tune the output, but the default is generally fine.
+Mostly straightforward, choose your translation method, fill in your API key, and select your text. You'll also need to add your settings file if on HuggingFace if you want to tune the output, but the default is generally fine. Although for google translate this needs to be the contents of your service key json, all one one line too.
 
 You can calculate costs here or just translate. Output will show in the appropriate fields.
 
-For further details on the settings file, see [here](#translation-with-llms-settings).
+For further details on the settings file, see [here](#translation-with-llms-settings). Note that Google Translate has no settings.
 
 ---------------------------------------------------------------------------------------------------------------------------------------------------
 

modules/common/file_ensurer.py

@@ -63,6 +63,7 @@ class FileEnsurer():
     deepl_api_key_path = os.path.join(secrets_dir, "deepl_api_key.txt")
     openai_api_key_path = os.path.join(secrets_dir,'openai_api_key.txt')
     gemini_api_key_path = os.path.join(secrets_dir,'gemini_api_key.txt')
+    google_translate_service_key_json_path = os.path.join(secrets_dir, "google_translate_service_key.json")
 
     ## favicon
     favicon_path = os.path.join(gui_lib, "Kudasai_Logo.png")

modules/common/toolkit.py

@@ -15,7 +15,7 @@ class Toolkit():
 
     """
 
-    CURRENT_VERSION = "v3.4.5"
+    CURRENT_VERSION = "v3.4.6"
 
 ##-------------------start-of-clear_console()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 

modules/common/translator.py

@@ -29,7 +29,7 @@ class Translator:
     """
     
     Translator is a class that is used to interact with translation methods and translate text.
-    Currently supports OpenAI, Gemini, and DeepL.
+    Currently supports OpenAI, Gemini, DeepL, and Google Translate.
     
     """
     
@@ -51,6 +51,9 @@ class Translator:
     ## same as above, but for deepl, just the text to be translated
     deepl_translation_batches:typing.List[str] = []
 
+    ## also the same for google translate
+    google_translate_translation_batches:typing.List[str] = []
+
     num_occurred_malformed_batches = 0
 
     ## semaphore to limit the number of concurrent batches
@@ -58,7 +61,7 @@ class Translator:
 
     ##--------------------------------------------------------------------------------------------------------------------------
 
-    TRANSLATION_METHOD:typing.Literal["openai", "gemini", "deepl"] = "openai"
+    TRANSLATION_METHOD:typing.Literal["openai", "gemini", "deepl", "google translate"] = "deepl"
 
     translation_print_result = ""
 
@@ -156,7 +159,7 @@ class Translator:
 
             JsonHandler.validate_json()
 
-            if(not Translator.is_cli):
+            if(not Translator.is_cli and Translator.TRANSLATION_METHOD != "google translate"):
                 await Translator.check_settings()
 
             ## set actual start time to the end of the settings configuration
@@ -194,10 +197,11 @@ class Translator:
             "1": ("openai", FileEnsurer.openai_api_key_path),
             "2": ("gemini", FileEnsurer.gemini_api_key_path),
             "3": ("deepl", FileEnsurer.deepl_api_key_path),
+            "4": ("google translate", FileEnsurer.google_translate_service_key_json_path)
         }
 
         if(not Translator.is_cli):
-            method = input("What method would you like to use for translation? (1 for OpenAI, 2 for Gemini, 3 for Deepl, or any other key to exit) : \n")
+            method = input("What method would you like to use for translation? (1 for OpenAI, 2 for Gemini, 3 for Deepl, 4 for Google Translate), or any other key to exit) : \n")
 
             if(method not in translation_methods.keys()):
                 print("\nThank you for using Kudasai, goodbye.")
@@ -212,8 +216,14 @@ class Translator:
         Translator.TRANSLATION_METHOD, api_key_path = translation_methods.get(method, ("deepl", FileEnsurer.deepl_api_key_path))
         
         if(Translator.pre_provided_api_key != ""):
-            encoded_key = base64.b64encode(Translator.pre_provided_api_key.encode('utf-8')).decode('utf-8')
+            if(Translator.TRANSLATION_METHOD == "google translate"):
+                encoded_key = base64.b64encode(Translator.pre_provided_api_key.encode('utf-8')).decode('utf-8')
+
+            else:
+                encoded_key = Translator.pre_provided_api_key
+
             Translator.pre_provided_api_key = ""
+            
             with open(api_key_path, 'w+', encoding='utf-8') as file: 
                 file.write(encoded_key)
 
@@ -246,14 +256,28 @@ class Translator:
 
         """
 
+        def get_api_key_from_file():
+            with open(api_key_path, 'r', encoding='utf-8') as file: 
+                return base64.b64decode((file.read()).encode('utf-8')).decode('utf-8')
+
+        def save_api_key(api_key):
+            if(service != "Google translate"):
+                encoded_key = base64.b64encode(api_key.encode('utf-8')).decode('utf-8')
+                FileEnsurer.standard_overwrite_file(api_key_path, encoded_key, omit=True)
+            else:
+                FileEnsurer.standard_overwrite_file(api_key_path, api_key, omit=True)
+
         ## get saved API key if exists
         try:
-            with open(api_key_path, 'r', encoding='utf-8') as file: 
-                api_key = base64.b64decode((file.read()).encode('utf-8')).decode('utf-8')
+
+            if(service != "Google translate"):
+                api_key = get_api_key_from_file()
+            else:
+                api_key = api_key_path
 
             api_key_setter(service.lower(), api_key)
 
-            is_valid, e =  api_key_tester(service.lower())
+            is_valid, e = api_key_tester(service.lower())
 
             ## if not valid, raise the exception that caused the test to fail
             if(not is_valid and e is not None):
@@ -267,20 +291,31 @@ class Translator:
         except:
 
             Toolkit.clear_console()
+
+            input_message = (
+                f"DO NOT DELETE YOUR COPY OF THE API KEY\n\nPlease enter the {service} API key you have : " 
+                if(service != "Google translate") 
+                else "DO NOT DELETE YOUR COPY OF THE SERVICE JSON\n\nPlease enter the contents of the service json file (on one line): "
+            )
                 
-            api_key = input(f"DO NOT DELETE YOUR COPY OF THE API KEY\n\nPlease enter the {service} API key you have : ")
+            api_key = input(input_message).strip('"').strip("'").strip()
+
+            ## preemptively save the api key for google translate
+            if(service == "Google translate"):
+                save_api_key(api_key)
+                time.sleep(1)
+                api_key = api_key_path
 
-            ## if valid save the API key
             try: 
 
                 api_key_setter(service.lower(), api_key)
 
-                is_valid, e =  api_key_tester(service.lower())
+                is_valid, e = api_key_tester(service.lower())
 
                 if(not is_valid and e is not None):
                     raise e
-
-                FileEnsurer.standard_overwrite_file(api_key_path, base64.b64encode(api_key.encode('utf-8')).decode('utf-8'), omit=True)
+                
+                save_api_key(api_key)
                 
             ## if invalid key exit
             except (GoogleAuthError, OpenAIAuthenticationError, DeepLAuthorizationException):
@@ -324,7 +359,7 @@ class Translator:
         Translator.gemini_translation_batches = []
         Translator.num_occurred_malformed_batches = 0
         Translator.translation_print_result = ""
-        Translator.TRANSLATION_METHOD = "openai"
+        Translator.TRANSLATION_METHOD = "deepl"
         Translator.pre_provided_api_key = ""
         Translator.is_cli = False
 
@@ -339,12 +374,13 @@ class Translator:
 
         """
 
-        print("Are these settings okay? (1 for yes or 2 for no) : \n\n")
+        print("Are these settings okay? (1 for yes or 2 for no):")
 
         method_to_section_dict = {
             "openai": ("openai settings", "OpenAI", FileEnsurer.openai_api_key_path),
             "gemini": ("gemini settings", "Gemini", FileEnsurer.gemini_api_key_path),
-            "deepl": ("deepl settings", "DeepL", FileEnsurer.deepl_api_key_path)
+            "deepl": ("deepl settings", "DeepL", FileEnsurer.deepl_api_key_path),
+            "google translate": (None, None, FileEnsurer.google_translate_service_key_json_path)
         }
 
         section_to_target, method_name, api_key_path = method_to_section_dict[Translator.TRANSLATION_METHOD]
@@ -361,7 +397,7 @@ class Translator:
                 JsonHandler.reset_translation_settings_to_default()
                 JsonHandler.load_translation_settings()
 
-                print("Are these settings okay? (1 for yes or 2 for no) : \n\n")
+                print("Are these settings okay? (1 for yes or 2 for no) : \n")
                 JsonHandler.log_translation_settings(output_to_console=True, specific_section=section_to_target)
             else:
                 FileEnsurer.exit_kudasai()
@@ -439,7 +475,8 @@ class Translator:
         exception_dict = {
             "openai": (OpenAIAuthenticationError, OpenAIInternalServerError, OpenAIRateLimitError, OpenAIAPITimeoutError, OpenAIAPIConnectionError, OpenAIAPIStatusError),
             "gemini": GoogleAPIError,
-            "deepl": DeepLException
+            "deepl": DeepLException,
+            "google translate": GoogleAPIError
         }
         
         Translator.decorator_to_use = backoff.on_exception(
@@ -460,7 +497,8 @@ class Translator:
         translation_methods = {
             "openai": JsonHandler.current_translation_settings["openai settings"]["openai_model"],
             "gemini": JsonHandler.current_translation_settings["gemini settings"]["gemini_model"],
-            "deepl": "deepl"
+            "deepl": "deepl",
+            "google translate": "google translate"
         }
         
         model = translation_methods[Translator.TRANSLATION_METHOD]
@@ -512,34 +550,36 @@ class Translator:
         """
 
         async_requests = []
-        
+
         translation_batches_methods = {
             "openai": Translator.openai_translation_batches,
             "gemini": Translator.gemini_translation_batches,
-            "deepl": Translator.deepl_translation_batches
+            "deepl": Translator.deepl_translation_batches,
+            "google translate": Translator.google_translate_translation_batches
         }
-        
+
         translation_batches = translation_batches_methods[Translator.TRANSLATION_METHOD]
         batch_length = len(translation_batches)
-        
-        if(Translator.TRANSLATION_METHOD != "deepl"):
+        batch_number = 1  # Initialize batch number
 
+        if(Translator.TRANSLATION_METHOD not in ["deepl", "google translate"]):
             for i in range(0, batch_length, 2):
                 instructions = translation_batches[i]
-                prompt = translation_batches[i+1]
-            
+                prompt = translation_batches[i + 1]
+
                 assert isinstance(instructions, (SystemTranslationMessage, str))
                 assert isinstance(prompt, (ModelTranslationMessage, str))
-            
-                async_requests.append(Translator.handle_translation(model, i, batch_length, prompt, instructions))
+
+                async_requests.append(Translator.handle_translation(model, batch_number, batch_length//2, prompt, instructions))
+                batch_number += 1
 
         else:
             for i, batch in enumerate(translation_batches):
-
                 assert isinstance(batch, str)
-            
-                async_requests.append(Translator.handle_translation(model, i, batch_length, batch, None))
-        
+
+                async_requests.append(Translator.handle_translation(model, batch_number, batch_length, batch, None))
+                batch_number += 1
+
         return async_requests
 
 ##-------------------start-of-generate_text_to_translate_batches()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -579,14 +619,14 @@ class Translator:
             if(len(prompt) < Translator.number_of_lines_per_batch):
                 if(is_special_char or is_part_in_sentence or is_part_char):
                     prompt.append(f'{sentence}\n')
-                    logging.debug(f"Sentence : {sentence}, Sentence is a pov change or part marker... adding to prompt.")
+                    logging.debug(f"Sentence : {sentence} Sentence is a pov change or part marker... adding to prompt.")
 
                 elif(non_word_pattern.match(sentence) or KatakanaUtil.is_punctuation(sentence) and not has_quotes):
-                    logging.debug(f"Sentence : {sentence}, Sentence is punctuation... skipping.")
+                    logging.debug(f"Sentence : {sentence} Sentence is punctuation or spacing... skipping.")
 
                 elif(sentence):
                     prompt.append(f'{sentence}\n')
-                    logging.debug(f"Sentence : {sentence}, Sentence is a valid sentence... adding to prompt.")
+                    logging.debug(f"Sentence : {sentence} Sentence is a valid sentence... adding to prompt.")
             else:
                 return prompt, index
         
@@ -627,15 +667,19 @@ class Translator:
                 Translator.gemini_translation_batches.append(Translator.gemini_prompt)
                 Translator.gemini_translation_batches.append(batch)
 
-            else:
+            elif(Translator.TRANSLATION_METHOD == 'deepl'):
                 Translator.deepl_translation_batches.append(batch)
 
+            elif(Translator.TRANSLATION_METHOD == 'google translate'):
+                Translator.google_translate_translation_batches.append(batch)
+
         logging_message = "Built Messages: \n\n"
 
         batches_to_iterate = {
             "openai": Translator.openai_translation_batches,
             "gemini": Translator.gemini_translation_batches,
-            "deepl": Translator.deepl_translation_batches
+            "deepl": Translator.deepl_translation_batches,
+            "google translate": Translator.google_translate_translation_batches
         }
 
         i = 0
@@ -648,7 +692,7 @@ class Translator:
 
             message = str(message) if Translator.TRANSLATION_METHOD != 'openai' else message.content # type: ignore
 
-            if(i % 2 == 1 and Translator.TRANSLATION_METHOD != 'deepl'):
+            if(i % 2 == 1 and Translator.TRANSLATION_METHOD not in ['deepl', 'google_translate']):
                 logging_message += "\n" "------------------------" "\n"
 
             logging_message += message + "\n"
@@ -677,6 +721,7 @@ class Translator:
             "openai": Translator.openai_system_message,
             "gemini": Translator.gemini_prompt,
             "deepl": None,
+            "google translate": None
         }
         
         translation_instructions = translation_instructions_methods[Translator.TRANSLATION_METHOD]
@@ -689,6 +734,8 @@ class Translator:
         if(Translator.TRANSLATION_METHOD == "gemini"):
             logging.info(f"As of Kudasai {Toolkit.CURRENT_VERSION}, Gemini Pro 1.0 is free to use under 15 requests per minute, Gemini Pro 1.5 is free to use under 2 requests per minute. Requests correspond to number_of_current_batches in the translation settings.")
         
+        entity_word = "tokens" if Translator.TRANSLATION_METHOD in ["openai", "gemini"] else "characters"
+
         logging.info("Estimated number of tokens : " + str(num_tokens))
         logging.info("Estimated minimum cost : " + str(min_cost) + " USD")
 
@@ -706,7 +753,7 @@ class Translator:
     
     @staticmethod
     async def handle_translation(model:str, 
-                                 batch_index:int,
+                                 batch_number:int,
                                  length_of_batch:int, 
                                  text_to_translate:typing.Union[str, ModelTranslationMessage],
                                  translation_instructions:typing.Union[str, SystemTranslationMessage, None]) -> tuple[int, str, str]: 
@@ -717,13 +764,13 @@ class Translator:
 
         Parameters:
         model (string) : The model of the service used to translate the text.
-        batch_index (int) : Which batch we are currently on.
+        batch_number (int) : Which batch we are currently on.
         length_of_batch (int) : How long the batches are.
         text_to_translate (typing.Union[str, ModelTranslationMessage]) : The text to translate.
         translation_instructions (typing.Union[str, SystemTranslationMessage, None]) : The translation instructions.
 
         Returns:
-        batch_index (int) : The batch index.
+        batch_number (int) : The batch index.
         text_to_translate (str) : The text to translate.
         translated_text (str) : The translated text
 
@@ -738,17 +785,16 @@ class Translator:
                 ## For the webgui
                 if(FileEnsurer.do_interrupt == True):
                     raise Exception("Interrupted by user.")
-
-                batch_number = (batch_index // 2) + 1
-
-                logging.info(f"Trying translation for batch {batch_number} of {length_of_batch//2}...")
+                
+                logging.info(f"Trying translation for batch {batch_number} of {length_of_batch}...")
 
                 try:
 
                     translation_methods = {
                         "openai": EasyTL.openai_translate_async,
                         "gemini": EasyTL.gemini_translate_async,
-                        "deepl": EasyTL.deepl_translate_async
+                        "deepl": EasyTL.deepl_translate_async,
+                        "google translate": EasyTL.googletl_translate_async
                     }
                     
                     translation_params = {
@@ -781,6 +827,10 @@ class Translator:
                             "split_sentences": Translator.deepl_split_sentences,
                             "preserve_formatting": Translator.deepl_preserve_formatting,
                             "formality": Translator.deepl_formality
+                        },
+                        "google translate": {
+                            "text": text_to_translate,
+                            "decorator": Translator.decorator_to_use
                         }
                     }
                     
@@ -791,7 +841,7 @@ class Translator:
                 ## will only occur if the max_batch_duration is exceeded, so we just return the untranslated text
                 except MaxBatchDurationExceededException:
 
-                    logging.error(f"Batch {batch_number} of {length_of_batch//2} was not translated due to exceeding the max request duration, returning the untranslated text...")
+                    logging.error(f"Batch {batch_number} of {length_of_batch} was not translated due to exceeding the max request duration, returning the untranslated text...")
                     break
 
                 ## do not even bother if not a gpt 4 model, because gpt-3 seems unable to format properly
@@ -804,12 +854,12 @@ class Translator:
                     break
 
                 if(num_tries >= Translator.num_of_malform_retries):
-                    logging.warning(f"Batch {batch_number} of {length_of_batch//2} was malformed but exceeded the max number of retries ({Translator.num_of_malform_retries})")
+                    logging.warning(f"Batch {batch_number} of {length_of_batch} was malformed but exceeded the max number of retries ({Translator.num_of_malform_retries})")
                     break
 
                 else:
                     num_tries += 1
-                    logging.warning(f"Batch {batch_number} of {length_of_batch//2} was malformed, retrying...")
+                    logging.warning(f"Batch {batch_number} of {length_of_batch} was malformed, retrying...")
                     Translator.num_occurred_malformed_batches += 1
 
             if(isinstance(text_to_translate, ModelTranslationMessage)):
@@ -818,9 +868,9 @@ class Translator:
             if(isinstance(translated_message, typing.List)):
                 translated_message = ''.join(translated_message) # type: ignore
 
-            logging.info(f"Translation for batch {batch_number} of {length_of_batch//2} completed.")
+            logging.info(f"Translation for batch {batch_number} of {length_of_batch} completed.")
 
-            return batch_index, text_to_translate, translated_message # type: ignore
+            return batch_number, text_to_translate, translated_message # type: ignore
     
 ##-------------------start-of-check_if_translation_is_good()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
@@ -917,7 +967,7 @@ class Translator:
                     index = patched_sentences.index(Translator.translated_text[i])
                     Translator.translated_text[i] = patched_sentences[index]
 
-        ## mode 2 just assumes the LLM formatted it properly
+        ## mode 2 just assumes the translation method formatted it properly
         elif(Translator.sentence_fragmenter_mode == 2):
             
             Translator.translated_text.append(translated_message + '\n\n')

requirements.txt

@@ -1,5 +1,5 @@
 backoff==2.2.1
 gradio==4.20.0
-kairyou==1.5.0
-easytl==0.4.0-alpha-2
+kairyou==1.6.1
+easytl==0.4.0-alpha-3
 ja_core_news_lg @ https://github.com/explosion/spacy-models/releases/download/ja_core_news_lg-3.7.0/ja_core_news_lg-3.7.0-py3-none-any.whl#sha256=f08eecb4d40523045c9478ce59a67564fd71edd215f32c076fa91dc1f05cc7fd

webgui.py

@@ -1,6 +1,7 @@
 ## built-in libraries
 import typing
 import base64
+import asyncio
 
 ## third-party libraries
 import gradio as gr
@@ -123,7 +124,7 @@ class KudasaiGUI:
 ##-------------------start-of-get_saved_api_key()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
             
             @staticmethod
-            def get_saved_api_key(service_name:typing.Literal["openai","gemini","deepl"]) -> str:
+            def get_saved_api_key(service_name:typing.Literal["openai","gemini","deepl","google translate"]) -> str:
 
                 """
                 Gets the saved api key from the config folder, if it exists.
@@ -139,13 +140,16 @@ class KudasaiGUI:
                 service_to_path = {
                     "openai": FileEnsurer.openai_api_key_path,
                     "gemini": FileEnsurer.gemini_api_key_path,
-                    "deepl": FileEnsurer.deepl_api_key_path
+                    "deepl": FileEnsurer.deepl_api_key_path,
+                    "google_translate": FileEnsurer.google_translate_service_key_json_path
                 }
 
                 api_key_path = service_to_path.get(service_name, "")
 
 
                 try:
+                    if(service_name == "google translate"):
+                        return api_key_path
                     ## Api key is encoded in base 64 so we need to decode it before returning
                     return base64.b64decode(FileEnsurer.standard_read_file(api_key_path).encode('utf-8')).decode('utf-8')
                 
@@ -165,6 +169,11 @@ class KudasaiGUI:
 
                 """
 
+                if(Translator.TRANSLATION_METHOD == "google translate"):
+                    FileEnsurer.standard_overwrite_file(FileEnsurer.google_translate_service_key_json_path, str(api_key), omit=True)
+                    await asyncio.sleep(2)
+                    api_key = FileEnsurer.google_translate_service_key_json_path
+
                 try:
 
                     EasyTL.set_credentials(Translator.TRANSLATION_METHOD, str(api_key))
@@ -193,14 +202,18 @@ class KudasaiGUI:
                 method_to_path = {
                     "openai": FileEnsurer.openai_api_key_path,
                     "gemini": FileEnsurer.gemini_api_key_path,
-                    "deepl": FileEnsurer.deepl_api_key_path
+                    "deepl": FileEnsurer.deepl_api_key_path,
+                    "google translate": FileEnsurer.google_translate_service_key_json_path
                 }
 
                 path_to_api_key = method_to_path.get(Translator.TRANSLATION_METHOD, None)
 
                 assert path_to_api_key is not None, "Invalid translation method"
 
-                FileEnsurer.standard_overwrite_file(path_to_api_key, base64.b64encode(str(api_key).encode('utf-8')).decode('utf-8'), omit=True)
+                if(Translator.TRANSLATION_METHOD != "google translate"):
+                    api_key = base64.b64encode(str(api_key).encode('utf-8')).decode('utf-8')
+
+                FileEnsurer.standard_overwrite_file(path_to_api_key, str(api_key), omit=True)
 
 ##-------------------start-of-create_new_key_value_tuple_pairs()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------    
 
@@ -353,10 +366,10 @@ class KudasaiGUI:
                             self.input_translation_rules_file = gr.File(value = FileEnsurer.config_translation_settings_path, label='Translation Settings File', file_count='single', file_types=['.json'], type='filepath')
 
                             with gr.Row():
-                                self.llm_option_dropdown = gr.Dropdown(label='Translation Method', choices=["OpenAI", "Gemini", "DeepL"], value="OpenAI", show_label=True, interactive=True)
+                                self.llm_option_dropdown = gr.Dropdown(label='Translation Method', choices=["OpenAI", "Gemini", "DeepL", "Google Translate"], value="DeepL", show_label=True, interactive=True)
                             
                             with gr.Row():
-                                self.translator_api_key_input = gr.Textbox(label='API Key', value=get_saved_api_key("openai"), lines=1, max_lines=2, show_label=True, interactive=True, type='password')
+                                self.translator_api_key_input = gr.Textbox(label='API Key', value=get_saved_api_key("deepl"), lines=1, max_lines=1, show_label=True, interactive=True, type='password')
 
                             with gr.Row():
                                 self.translator_translate_button = gr.Button('Translate', variant="primary")
@@ -390,7 +403,7 @@ class KudasaiGUI:
 
                         with gr.Column():
                             gr.Markdown("Base Translation Settings")
-                            gr.Markdown("These settings are used for OpenAI, Gemini, and DeepL.")
+                            gr.Markdown("These settings are used for OpenAI, Gemini, DeepL, and Google Translate")
                             gr.Markdown("Please ensure to thoroughly read and understand these settings before making any modifications. Each setting has a specific impact on the translation methods. Some settings may affect one or two translation methods, but not the others. Incorrect adjustments could lead to unexpected results or errors in the translation process.")
 
 
@@ -931,9 +944,12 @@ class KudasaiGUI:
                 elif(translation_method == "Gemini"):
                     Translator.TRANSLATION_METHOD = "gemini"
 
-                else:
+                elif(translation_method == "DeepL"):
                     Translator.TRANSLATION_METHOD = "deepl"
 
+                elif(translation_method == "Google Translate"):
+                    Translator.TRANSLATION_METHOD = "google translate"
+
                 ## api key as well
                 await set_translator_api_key(api_key)
                 
@@ -988,13 +1004,7 @@ class KudasaiGUI:
 
                 if(input_txt_file is None and input_text == ""):
                     raise gr.Error("No TXT file or text selected")
-                
-                if(api_key == "" and translation_method not in ["OpenAI","DeepL"]):
-                    raise gr.Error("No API key provided. Does not charge for cost estimation, but is required for Gemini Cost Calculation")
-                
-                if(Kudasai.connection == False and translation_method != "OpenAI"):
-                    raise gr.Error("No internet connection detected, please connect to the internet and reload the page to calculate costs for Gemini")
-                
+                                
                 if(translation_settings_file is None):
                     raise gr.Error("No Translation Settings File selected")
                 
@@ -1005,12 +1015,11 @@ class KudasaiGUI:
 
                 Translator.TRANSLATION_METHOD = str(translation_method.lower()) # type: ignore
 
-                await set_translator_api_key(api_key)
-
                 translation_methods = {
                     "openai": GuiJsonUtil.fetch_translation_settings_key_values("openai settings","openai_model"),
                     "gemini": GuiJsonUtil.fetch_translation_settings_key_values("gemini settings","gemini_model"),
-                    "deepl": "deep"
+                    "deepl": "deepl",
+                    "google translate": "google translate"
                 }
 
                 model = translation_methods.get(Translator.TRANSLATION_METHOD) 
@@ -1024,7 +1033,8 @@ class KudasaiGUI:
                 translation_instructions_dict = {
                     "openai": GuiJsonUtil.fetch_translation_settings_key_values("openai settings","openai_system_message"),
                     "gemini": GuiJsonUtil.fetch_translation_settings_key_values("gemini settings","gemini_prompt"),
-                    "deepl": None
+                    "deepl": None,
+                    "google translate": None
                 }
 
                 translation_instructions = translation_instructions_dict.get(Translator.TRANSLATION_METHOD)
@@ -1034,9 +1044,9 @@ class KudasaiGUI:
                 if(Translator.TRANSLATION_METHOD == "gemini"):
                     cost_estimation = f"As of Kudasai {Toolkit.CURRENT_VERSION}, Gemini Pro 1.0 is free to use under 15 requests per minute, Gemini Pro 1.5 is free to use under 2 requests per minute.\nIt is up to you to set these in the settings json.\n"
 
-                token_type = "characters" if Translator.TRANSLATION_METHOD == "deepl" else "tokens"
+                entity_type = "characters" if Translator.TRANSLATION_METHOD in ["deepl", "google translate"] else "tokens"
 
-                cost_estimation += f"Estimated number of {token_type} : {num_tokens}\nEstimated minimum cost : {estimated_cost} USD\nThis is a rough estimate, please remember to check actual cost on the appropriate platform when needed"
+                cost_estimation += f"Estimated number of {entity_type} : {num_tokens}\nEstimated minimum cost : {estimated_cost} USD\nThis is a rough estimate, please remember to check actual cost on the appropriate platform when needed"
                 
                 gr.Info(cost_estimation)