push v3.4.3 files

README.md

@@ -32,7 +32,7 @@ This readme is for the Hugging Space instance of Kudasai's WebGUI and the WebGUI
 
 Streamlining Japanese-English Translation with Advanced Preprocessing and Integrated Translation Technologies.
 
-Preprocessor is sourced from an external package, which I also designed, called [Kairyou](https://github.com/Bikatr7/Kairyou).
+Preprocessor and Translation logic is sourced from external packages, which I also designed, see [Kairyou](https://github.com/Bikatr7/Kairyou) and [EasyTL](https://github.com/Bikatr7/easytl) for more information.
 
 Kudasai has a public trello board, you can find it [here](https://trello.com/b/Wsuwr24S/kudasai) to see what I'm working on.
 

custom_classes/messages.py

@@ -1,54 +0,0 @@
-##-------------------start-of-Message--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-class Message:
-
-    """
-
-    Message is a class that is used to send translation batches to the OpenAI API.
-
-    """
-
-    def __init__(self, content: str):
-        self._content = content
-
-    @property
-    def role(self):
-        raise NotImplementedError
-
-    @property
-    def content(self):
-        return self._content
-    
-    def to_dict(self):
-        return {
-            'role': self.role,
-            'content': self.content
-        }
-
-##-------------------start-of-SystemTranslationMessage--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-class SystemTranslationMessage(Message):
-
-    """
-
-    SystemTranslationMessage is a class that is used to send the system message to the OpenAI API.
-
-    """
-
-    @property
-    def role(self):
-        return 'system'
-
-##-------------------start-of-ModelTranslationMessage--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-class ModelTranslationMessage(Message):
-
-    """
-
-    ModelTranslationMessage is a class that is used to send the model/user message to the OpenAI API.
-    
-    """
-    
-    @property
-    def role(self):
-        return 'user'

handlers/json_handler.py

@@ -2,6 +2,9 @@
 import json
 import typing
 
+## third-party libraries
+from easytl import ALLOWED_GEMINI_MODELS, ALLOWED_OPENAI_MODELS
+
 ## custom modules
 from modules.common.file_ensurer import FileEnsurer
 from modules.common.logger import Logger
@@ -144,13 +147,13 @@ gemini_stream, gemini_stop_sequences and gemini_candidate_count are included for
             "number_of_malformed_batch_retries": lambda x: isinstance(x, int) and x >= 0,
             "batch_retry_timeout": lambda x: isinstance(x, int) and x >= 0,
             "number_of_concurrent_batches": lambda x: isinstance(x, int) and x >= 0,
-            "openai_model": lambda x: isinstance(x, str) and x in FileEnsurer.ALLOWED_OPENAI_MODELS,
+            "openai_model": lambda x: isinstance(x, str) and x in ALLOWED_OPENAI_MODELS,
             "openai_system_message": lambda x: x not in ["", "None", None],
             "openai_temperature": lambda x: isinstance(x, float) and 0 <= x <= 2,
             "openai_top_p": lambda x: isinstance(x, float) and 0 <= x <= 1,
             "openai_max_tokens": lambda x: x is None or isinstance(x, int) and x > 0,
             "openai_presence_penalty": lambda x: isinstance(x, float) and -2 <= x <= 2,
-            "gemini_model": lambda x: isinstance(x, str) and x in FileEnsurer.ALLOWED_GEMINI_MODELS,
+            "gemini_model": lambda x: isinstance(x, str) and x in ALLOWED_GEMINI_MODELS,
             "gemini_prompt": lambda x: x not in ["", "None", None],
             "gemini_temperature": lambda x: isinstance(x, float) and 0 <= x <= 2,
             "gemini_top_p": lambda x: x is None or (isinstance(x, float) and 0 <= x <= 2),
@@ -360,7 +363,7 @@ gemini_stream, gemini_stop_sequences and gemini_candidate_count are included for
             "number_of_malformed_batch_retries": {"type": int, "constraints": lambda x: x >= 0},
             "batch_retry_timeout": {"type": int, "constraints": lambda x: x >= 0},
             "number_of_concurrent_batches": {"type": int, "constraints": lambda x: x >= 0},
-            "openai_model": {"type": str, "constraints": lambda x: x in FileEnsurer.ALLOWED_OPENAI_MODELS},
+            "openai_model": {"type": str, "constraints": lambda x: x in ALLOWED_OPENAI_MODELS},
             "openai_system_message": {"type": str, "constraints": lambda x: x not in ["", "None", None]},
             "openai_temperature": {"type": float, "constraints": lambda x: 0 <= x <= 2},
             "openai_top_p": {"type": float, "constraints": lambda x: 0 <= x <= 2},
@@ -371,7 +374,7 @@ gemini_stream, gemini_stop_sequences and gemini_candidate_count are included for
             "openai_max_tokens": {"type": int, "constraints": lambda x: x is None or isinstance(x, int)},
             "openai_presence_penalty": {"type": float, "constraints": lambda x: -2 <= x <= 2},
             "openai_frequency_penalty": {"type": float, "constraints": lambda x: -2 <= x <= 2},
-            "gemini_model": {"type": str, "constraints": lambda x: x in FileEnsurer.ALLOWED_GEMINI_MODELS},
+            "gemini_model": {"type": str, "constraints": lambda x: x in ALLOWED_GEMINI_MODELS},
             "gemini_prompt": {"type": str, "constraints": lambda x: x not in ["", "None", None]},
             "gemini_temperature": {"type": float, "constraints": lambda x: 0 <= x <= 2},
             "gemini_top_p": {"type": float, "constraints": lambda x: x is None or (isinstance(x, float) and 0 <= x <= 2)},

models/kaiseki.py

@@ -1,5 +1,6 @@
 ## Basically Deprecated, use Kijiku instead. Currently only maintained for backwards compatibility.
 ##---------------------------------------
+##---------------------------------------
 ## built-in libraries
 import string
 import time
@@ -7,8 +8,10 @@ import re
 import base64
 import time
 
+## third-party libraries
+from easytl import EasyTL
+
 ## custom modules
-from translation_services.deepl_service import DeepLService
 from modules.common.toolkit import Toolkit
 from modules.common.file_ensurer import FileEnsurer
 from modules.common.logger import Logger
@@ -105,8 +108,10 @@ class Kaiseki:
             with open(FileEnsurer.deepl_api_key_path, 'r', encoding='utf-8') as file:
                 api_key = base64.b64decode((file.read()).encode('utf-8')).decode('utf-8')
 
-            DeepLService.set_api_key(api_key)
-            DeepLService.test_api_key_validity()
+            EasyTL.set_api_key("deepl", api_key)
+            is_valid, e = EasyTL.test_api_key_validity("deepl")
+
+            assert is_valid == True, e
 
             Logger.log_action("Used saved api key in " + FileEnsurer.deepl_api_key_path, output=True)
 
@@ -118,8 +123,10 @@ class Kaiseki:
             ## if valid save the api key
             try: 
 
-                DeepLService.set_api_key(api_key)
-                DeepLService.test_api_key_validity()
+                EasyTL.set_api_key("deepl", api_key)
+                is_valid, e = EasyTL.test_api_key_validity("deepl")
+
+                assert is_valid, e
 
                 time.sleep(.1)
                     
@@ -136,7 +143,7 @@ class Kaiseki:
                 
                 Toolkit.pause_console()
                     
-                raise e
+                raise e # type: ignore
 
             ## other error, alert user and raise it
             except Exception as e: 
@@ -452,7 +459,9 @@ class Kaiseki:
                 single_quote_active = True
                 
             try:
-                results = DeepLService.translate(Kaiseki.sentence_parts[i], source_lang= "JA", target_lang="EN-US")
+                results = EasyTL.deepl_translate(text=Kaiseki.sentence_parts[i], source_lang= "JA", target_lang="EN-US")
+
+                assert isinstance(results, str), "ValueError: " + str(results)
 
                 translated_part = results.rstrip(''.join(c for c in string.punctuation if c not in "'\""))
                 translated_part = translated_part.rstrip() 
@@ -464,7 +473,9 @@ class Kaiseki:
 
                 ## translates the quote and re-adds it back to the sentence part
                 if(single_quote_active == True): 
-                    quote = DeepLService.translate(quote, source_lang= "JA", target_lang="EN-US")
+                    results = EasyTL.deepl_translate(text=Kaiseki.sentence_parts[i], source_lang= "JA", target_lang="EN-US")
+
+                    assert isinstance(results, str), "ValueError: " + str(results)
                     
                     quote = quote.rstrip(''.join(c for c in string.punctuation if c not in "'\""))
                     quote = quote.rstrip() 

models/kijiku.py

@@ -9,8 +9,8 @@ import os
 
 ## third party modules
 from kairyou import KatakanaUtil
+from easytl import EasyTL, Message, SystemTranslationMessage, ModelTranslationMessage
 
-import tiktoken
 import backoff
 
 ## custom modules
@@ -22,11 +22,6 @@ from modules.common.toolkit import Toolkit
 from modules.common.exceptions import AuthenticationError, MaxBatchDurationExceededException, AuthenticationError, InternalServerError, RateLimitError, APITimeoutError, GoogleAuthError
 from modules.common.decorators import permission_error_decorator
 
-from custom_classes.messages import SystemTranslationMessage, ModelTranslationMessage, Message
-
-from translation_services.openai_service import OpenAIService
-from translation_services.gemini_service import GeminiService
-
 ##-------------------start-of-Kijiku--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
 class Kijiku:
@@ -48,7 +43,7 @@ class Kijiku:
 
     ## the messages that will be sent to the api, contains a system message and a model message, system message is the instructions,
     ## model message is the text that will be translated  
-    openai_translation_batches:typing.List[Message] = []
+    openai_translation_batches:typing.List[SystemTranslationMessage | ModelTranslationMessage] = []
 
     ## meanwhile for gemini, we just need to send the prompt and the text to be translated concatenated together
     gemini_translation_batches:typing.List[str] = []
@@ -74,6 +69,8 @@ class Kijiku:
     batch_retry_timeout:float
     num_concurrent_batches:int
 
+    decorator_to_use:typing.Callable
+
 ##-------------------start-of-get_max_batch_duration()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     
     @staticmethod
@@ -196,10 +193,10 @@ class Kijiku:
         Toolkit.clear_console()
 
         if(Kijiku.LLM_TYPE == "openai"):
-            await Kijiku.init_api_key("OpenAI", FileEnsurer.openai_api_key_path, OpenAIService.set_api_key, OpenAIService.test_api_key_validity)
+            await Kijiku.init_api_key("OpenAI", FileEnsurer.openai_api_key_path, EasyTL.set_api_key, EasyTL.test_api_key_validity)
 
         else:
-            await Kijiku.init_api_key("Gemini", FileEnsurer.gemini_api_key_path, GeminiService.set_api_key, GeminiService.test_api_key_validity)
+            await Kijiku.init_api_key("Gemini", FileEnsurer.gemini_api_key_path, EasyTL.set_api_key, EasyTL.test_api_key_validity)
 
         ## try to load the kijiku rules
         try: 
@@ -232,17 +229,14 @@ class Kijiku:
 
         """
 
-        if(service != "OpenAI"):
-            GeminiService.redefine_client()
-
         ## 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')
 
-            api_key_setter(api_key)
+            api_key_setter(service.lower(), api_key)
 
-            is_valid, e = await api_key_tester()
+            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):
@@ -263,9 +257,9 @@ class Kijiku:
             ## if valid save the API key
             try: 
 
-                api_key_setter(api_key)
+                api_key_setter(service.lower(), api_key)
 
-                is_valid, e = await api_key_tester()
+                is_valid, e =  api_key_tester(service.lower())
 
                 if(not is_valid and e is not None):
                     raise e
@@ -365,14 +359,14 @@ class Kijiku:
                 if(os.path.exists(FileEnsurer.openai_api_key_path)):
 
                     os.remove(FileEnsurer.openai_api_key_path)
-                    await Kijiku.init_api_key("OpenAI", FileEnsurer.openai_api_key_path, OpenAIService.set_api_key, OpenAIService.test_api_key_validity)
+                    await Kijiku.init_api_key("OpenAI", FileEnsurer.openai_api_key_path, EasyTL.set_api_key, EasyTL.test_api_key_validity)
 
             else:
     
                 if(os.path.exists(FileEnsurer.gemini_api_key_path)):
 
                     os.remove(FileEnsurer.gemini_api_key_path)
-                    await Kijiku.init_api_key("Gemini", FileEnsurer.gemini_api_key_path, GeminiService.set_api_key, GeminiService.test_api_key_validity)
+                    await Kijiku.init_api_key("Gemini", FileEnsurer.gemini_api_key_path, EasyTL.set_api_key, EasyTL.test_api_key_validity)
 
         Toolkit.clear_console()
 
@@ -409,41 +403,34 @@ class Kijiku:
 
         Kijiku._semaphore = asyncio.Semaphore(Kijiku.num_concurrent_batches)
 
-        OpenAIService.model = JsonHandler.current_kijiku_rules["openai settings"]["openai_model"]
-        OpenAIService.system_message = JsonHandler.current_kijiku_rules["openai settings"]["openai_system_message"]
-        OpenAIService.temperature = float(JsonHandler.current_kijiku_rules["openai settings"]["openai_temperature"])
-        OpenAIService.top_p = float(JsonHandler.current_kijiku_rules["openai settings"]["openai_top_p"])
-        OpenAIService.n = int(JsonHandler.current_kijiku_rules["openai settings"]["openai_n"])
-        OpenAIService.stream = bool(JsonHandler.current_kijiku_rules["openai settings"]["openai_stream"])
-        OpenAIService.stop = JsonHandler.current_kijiku_rules["openai settings"]["openai_stop"]
-        OpenAIService.logit_bias = JsonHandler.current_kijiku_rules["openai settings"]["openai_logit_bias"]
-        OpenAIService.max_tokens = JsonHandler.current_kijiku_rules["openai settings"]["openai_max_tokens"]
-        OpenAIService.presence_penalty = float(JsonHandler.current_kijiku_rules["openai settings"]["openai_presence_penalty"])
-        OpenAIService.frequency_penalty = float(JsonHandler.current_kijiku_rules["openai settings"]["openai_frequency_penalty"])
-
-        GeminiService.model = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_model"]
-        GeminiService.prompt = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_prompt"]
-        GeminiService.temperature = float(JsonHandler.current_kijiku_rules["gemini settings"]["gemini_temperature"])
-        GeminiService.top_p = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_top_p"]
-        GeminiService.top_k = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_top_k"]
-        GeminiService.candidate_count = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_candidate_count"]
-        GeminiService.stream = bool(JsonHandler.current_kijiku_rules["gemini settings"]["gemini_stream"])
-        GeminiService.stop_sequences = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_stop_sequences"]
-        GeminiService.max_output_tokens = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_max_output_tokens"]
+        Kijiku.openai_model = JsonHandler.current_kijiku_rules["openai settings"]["openai_model"]
+        Kijiku.openai_system_message = JsonHandler.current_kijiku_rules["openai settings"]["openai_system_message"]
+        Kijiku.openai_temperature = float(JsonHandler.current_kijiku_rules["openai settings"]["openai_temperature"])
+        Kijiku.openai_top_p = float(JsonHandler.current_kijiku_rules["openai settings"]["openai_top_p"])
+        Kijiku.openai_n = int(JsonHandler.current_kijiku_rules["openai settings"]["openai_n"])
+        Kijiku.openai_stream = bool(JsonHandler.current_kijiku_rules["openai settings"]["openai_stream"])
+        Kijiku.openai_stop = JsonHandler.current_kijiku_rules["openai settings"]["openai_stop"]
+        Kijiku.openai_logit_bias = JsonHandler.current_kijiku_rules["openai settings"]["openai_logit_bias"]
+        Kijiku.openai_max_tokens = JsonHandler.current_kijiku_rules["openai settings"]["openai_max_tokens"]
+        Kijiku.openai_presence_penalty = float(JsonHandler.current_kijiku_rules["openai settings"]["openai_presence_penalty"])
+        Kijiku.openai_frequency_penalty = float(JsonHandler.current_kijiku_rules["openai settings"]["openai_frequency_penalty"])
+
+        Kijiku.gemini_model = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_model"]
+        Kijiku.gemini_prompt = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_prompt"]
+        Kijiku.gemini_temperature = float(JsonHandler.current_kijiku_rules["gemini settings"]["gemini_temperature"])
+        Kijiku.gemini_top_p = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_top_p"]
+        Kijiku.gemini_top_k = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_top_k"]
+        Kijiku.gemini_candidate_count = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_candidate_count"]
+        Kijiku.gemini_stream = bool(JsonHandler.current_kijiku_rules["gemini settings"]["gemini_stream"])
+        Kijiku.gemini_stop_sequences = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_stop_sequences"]
+        Kijiku.gemini_max_output_tokens = JsonHandler.current_kijiku_rules["gemini settings"]["gemini_max_output_tokens"]
 
-        if(Kijiku.LLM_TYPE == "openai"):
 
-            ## set the decorator to use
-            decorator_to_use = backoff.on_exception(backoff.expo, max_time=lambda: Kijiku.get_max_batch_duration(), exception=(AuthenticationError, InternalServerError, RateLimitError, APITimeoutError), on_backoff=lambda details: Kijiku.log_retry(details), on_giveup=lambda details: Kijiku.log_failure(details), raise_on_giveup=False)
-
-            OpenAIService.set_decorator(decorator_to_use)
+        if(Kijiku.LLM_TYPE == "openai"):
+            Kijiku.decorator_to_use = backoff.on_exception(backoff.expo, max_time=lambda: Kijiku.get_max_batch_duration(), exception=(AuthenticationError, InternalServerError, RateLimitError, APITimeoutError), on_backoff=lambda details: Kijiku.log_retry(details), on_giveup=lambda details: Kijiku.log_failure(details), raise_on_giveup=False)
 
         else:
-        
-            decorator_to_use = backoff.on_exception(backoff.expo, max_time=lambda: Kijiku.get_max_batch_duration(), exception=(Exception), on_backoff=lambda details: Kijiku.log_retry(details), on_giveup=lambda details: Kijiku.log_failure(details), raise_on_giveup=False)
-
-            GeminiService.redefine_client()
-            GeminiService.set_decorator(decorator_to_use)
+            Kijiku.decorator_to_use = backoff.on_exception(backoff.expo, max_time=lambda: Kijiku.get_max_batch_duration(), exception=(Exception), on_backoff=lambda details: Kijiku.log_retry(details), on_giveup=lambda details: Kijiku.log_failure(details), raise_on_giveup=False)
 
         Toolkit.clear_console()
 
@@ -453,7 +440,7 @@ class Kijiku:
 
         Kijiku.build_translation_batches()
 
-        model = OpenAIService.model if Kijiku.LLM_TYPE == "openai" else GeminiService.model
+        model = JsonHandler.current_kijiku_rules["openai settings"]["openai_model"] if Kijiku.LLM_TYPE == "openai" else JsonHandler.current_kijiku_rules["gemini settings"]["gemini_model"]
 
         await Kijiku.handle_cost_estimate_prompt(model, omit_prompt=is_webgui)
 
@@ -519,7 +506,14 @@ class Kijiku:
         translation_batches = Kijiku.openai_translation_batches if Kijiku.LLM_TYPE == "openai" else Kijiku.gemini_translation_batches
 
         for i in range(0, len(translation_batches), 2):
-            async_requests.append(Kijiku.handle_translation(model, i, len(translation_batches), translation_batches[i], translation_batches[i+1]))
+
+            instructions = translation_batches[i]
+            prompt = translation_batches[i+1]
+
+            assert isinstance(instructions, SystemTranslationMessage) or isinstance(instructions, str)
+            assert isinstance(prompt, ModelTranslationMessage) or isinstance(prompt, str)
+
+            async_requests.append(Kijiku.handle_translation(model, i, len(translation_batches), instructions, prompt))
 
         return async_requests
 
@@ -601,16 +595,16 @@ class Kijiku:
             if(Kijiku.LLM_TYPE == 'openai'):
 
                 if(Kijiku.prompt_assembly_mode == 1):
-                    system_msg = SystemTranslationMessage(content=str(OpenAIService.system_message))
+                    system_msg = SystemTranslationMessage(content=str(Kijiku.openai_system_message))
                 else:
-                    system_msg = ModelTranslationMessage(content=str(OpenAIService.system_message))
+                    system_msg = SystemTranslationMessage(content=str(Kijiku.openai_system_message))
 
                 Kijiku.openai_translation_batches.append(system_msg)
                 model_msg = ModelTranslationMessage(content=batch)
                 Kijiku.openai_translation_batches.append(model_msg)
 
             else:
-                Kijiku.gemini_translation_batches.append(GeminiService.prompt)
+                Kijiku.gemini_translation_batches.append(Kijiku.gemini_prompt)
                 Kijiku.gemini_translation_batches.append(batch)
 
         Logger.log_barrier()
@@ -630,177 +624,6 @@ class Kijiku:
 
             Logger.log_action(message)
 
-##-------------------start-of-estimate_cost()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def estimate_cost(model:str, price_case:int | None = None) -> typing.Tuple[int, float, str]:
-
-        """
-
-        Attempts to estimate cost.
-
-        Parameters:
-        model (string) : the model used to translate the text.
-        price_case (int) : the price case used to calculate the cost.
-
-        Returns:
-        num_tokens (int) : the number of tokens used.
-        min_cost (float) : the minimum cost of translation.
-        model (string) : the model used to translate the text.
-
-        """
-
-        MODEL_COSTS = {
-            "gpt-3.5-turbo": {"price_case": 2, "input_cost": 0.0010, "output_cost": 0.0020},
-            "gpt-4": {"price_case": 4, "input_cost": 0.01, "output_cost": 0.03},
-            "gpt-4-turbo-preview": {"price_case": 4, "input_cost": 0.01, "output_cost": 0.03},
-            "gpt-3.5-turbo-0613": {"price_case": 1, "input_cost": 0.0015, "output_cost": 0.0020},
-            "gpt-3.5-turbo-0301": {"price_case": 1, "input_cost": 0.0015, "output_cost": 0.0020},
-            "gpt-3.5-turbo-1106": {"price_case": 2, "input_cost": 0.0010, "output_cost": 0.0020},
-            "gpt-3.5-turbo-0125": {"price_case": 7, "input_cost": 0.0005, "output_cost": 0.0015},
-            "gpt-3.5-turbo-16k-0613": {"price_case": 3, "input_cost": 0.0030, "output_cost": 0.0040},
-            "gpt-4-1106-preview": {"price_case": 4, "input_cost": 0.01, "output_cost": 0.03},
-            "gpt-4-0125-preview": {"price_case": 4, "input_cost": 0.01, "output_cost": 0.03},
-            "gpt-4-0314": {"price_case": 5, "input_cost": 0.03, "output_cost": 0.06},
-            "gpt-4-0613": {"price_case": 5, "input_cost": 0.03, "output_cost": 0.06},
-            "gpt-4-32k-0314": {"price_case": 6, "input_cost": 0.06, "output_cost": 0.012},
-            "gpt-4-32k-0613": {"price_case": 6, "input_cost": 0.06, "output_cost": 0.012},
-            "gemini-1.0-pro-001": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-1.0-pro-vision-001": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-1.0-pro": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-1.0-pro-vision": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-1.0-pro-latest": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-1.0-pro-vision-latest": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-1.5-pro-latest": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-1.0-ultra-latest": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-pro": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-pro-vision": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0},
-            "gemini-ultra": {"price_case": 8, "input_cost": 0.0, "output_cost": 0.0}
-        }
-
-        assert model in FileEnsurer.ALLOWED_OPENAI_MODELS or model in FileEnsurer.ALLOWED_GEMINI_MODELS, f"""Kudasai does not support : {model}"""
-
-        ## default models are first, then the rest are sorted by price case
-        if(price_case is None):
-
-            if(model == "gpt-3.5-turbo"):
-                print("Warning: gpt-3.5-turbo may change over time. Returning num tokens assuming gpt-3.5-turbo-1106 as it is the most recent version of gpt-3.5-turbo.")
-                return Kijiku.estimate_cost("gpt-3.5-turbo-1106", price_case=2)
-            
-            elif(model == "gpt-4"):
-                print("Warning: gpt-4 may change over time. Returning num tokens assuming gpt-4-1106-preview as it is the most recent version of gpt-4.")
-                return Kijiku.estimate_cost("gpt-4-1106-preview", price_case=4)
-            
-            elif(model == "gpt-4-turbo-preview"):
-                print("Warning: gpt-4-turbo-preview may change over time. Returning num tokens assuming gpt-4-0125-preview as it is the most recent version of gpt-4-turbo-preview.")
-                return Kijiku.estimate_cost("gpt-4-0125-preview", price_case=4)
-            
-            elif(model == "gpt-3.5-turbo-0613"):
-                print("Warning: gpt-3.5-turbo-0613 is considered depreciated by OpenAI as of November 6, 2023 and could be shutdown as early as June 13, 2024. Consider switching to gpt-3.5-turbo-1106.")
-                return Kijiku.estimate_cost(model, price_case=1)
-
-            elif(model == "gpt-3.5-turbo-0301"):
-                print("Warning: gpt-3.5-turbo-0301 is considered depreciated by OpenAI as of June 13, 2023 and could be shutdown as early as June 13, 2024. Consider switching to gpt-3.5-turbo-1106 unless you are specifically trying to break the filter.")
-                return Kijiku.estimate_cost(model, price_case=1)
-            
-            elif(model == "gpt-3.5-turbo-1106"):
-                return Kijiku.estimate_cost(model, price_case=2)
-            
-            elif(model == "gpt-3.5-turbo-0125"):
-                return Kijiku.estimate_cost(model, price_case=7)
-            
-            elif(model == "gpt-3.5-turbo-16k-0613"):
-                print("Warning: gpt-3.5-turbo-16k-0613 is considered depreciated by OpenAI as of November 6, 2023 and could be shutdown as early as June 13, 2024. Consider switching to gpt-3.5-turbo-1106.")
-                return Kijiku.estimate_cost(model, price_case=3)
-            
-            elif(model == "gpt-4-1106-preview"):
-                return Kijiku.estimate_cost(model, price_case=4)
-            
-            elif(model == "gpt-4-0125-preview"):
-                return Kijiku.estimate_cost(model, price_case=4)
-            
-            elif(model == "gpt-4-0314"):
-                print("Warning: gpt-4-0314 is considered depreciated by OpenAI as of June 13, 2023 and could be shutdown as early as June 13, 2024. Consider switching to gpt-4-0613.")
-                return Kijiku.estimate_cost(model, price_case=5)
-            
-            elif(model == "gpt-4-0613"):
-                return Kijiku.estimate_cost(model, price_case=5)
-            
-            elif(model == "gpt-4-32k-0314"):
-                print("Warning: gpt-4-32k-0314 is considered depreciated by OpenAI as of June 13, 2023 and could be shutdown as early as June 13, 2024. Consider switching to gpt-4-32k-0613.")
-                return Kijiku.estimate_cost(model, price_case=6)
-            
-            elif(model == "gpt-4-32k-0613"):
-                return Kijiku.estimate_cost(model, price_case=6)
-            
-            elif(model == "gemini-pro"):
-                print(f"Warning: gemini-pro may change over time. Returning num tokens assuming gemini-1.0-pro-001 as it is the most recent version of gemini-1.0-pro.")
-                return Kijiku.estimate_cost("gemini-1.0-pro-001", price_case=8)
-            
-            elif(model == "gemini-pro-vision"):
-                print("Warning: gemini-pro-vision may change over time. Returning num tokens assuming gemini-1.0-pro-vision-001 as it is the most recent version of gemini-1.0-pro-vision.")
-                return Kijiku.estimate_cost("gemini-1.0-pro-vision-001", price_case=8)
-            
-            elif(model == "gemini-ultra"):
-                return Kijiku.estimate_cost(model, price_case=8)
-            
-            elif(model == "gemini-1.0-pro"):
-                print(f"Warning: gemini-1.0-pro may change over time. Returning num tokens assuming gemini-1.0-pro-001 as it is the most recent version of gemini-1.0-pro.")
-                return Kijiku.estimate_cost(model, price_case=8)
-            
-            elif(model == "gemini-1.0-pro-vision"):
-                print("Warning: gemini-1.0-pro-vision may change over time. Returning num tokens assuming gemini-1.0-pro-vision-001 as it is the most recent version of gemini-1.0-pro-vision.")
-                return Kijiku.estimate_cost(model, price_case=8)
-            
-            elif(model == "gemini-1.0-pro-latest"):
-                print(f"Warning: gemini-1.0-pro-latest may change over time. Returning num tokens assuming gemini-1.0-pro-001 as it is the most recent version of gemini-1.0-pro.")
-                return Kijiku.estimate_cost("gemini-1.0-pro-001", price_case=8)
-            
-            elif(model == "gemini-1.0-pro-vision-latest"):
-                print("Warning: gemini-1.0-pro-vision-latest may change over time. Returning num tokens assuming gemini-1.0-pro-vision-001 as it is the most recent version of gemini-1.0-pro-vision.")
-                return Kijiku.estimate_cost("gemini-1.0-pro-vision-001", price_case=8)
-            
-            elif(model == "gemini-1.5-pro-latest"):
-                return Kijiku.estimate_cost(model, price_case=8)
-            
-            elif(model == "gemini-1.0-ultra-latest"):
-                return Kijiku.estimate_cost(model, price_case=8)
-            
-            elif(model == "gemini-1.0-pro-001"):
-                return Kijiku.estimate_cost(model, price_case=8)
-            
-            elif(model == "gemini-1.0-pro-vision-001"):
-                return Kijiku.estimate_cost(model, price_case=8)
-            
-        else:
-
-            cost_details = MODEL_COSTS.get(model)
-
-            if(not cost_details):
-                raise ValueError(f"Cost details not found for model: {model}.")
-
-            ## break down the text into a string than into tokens
-            text = ''.join(Kijiku.text_to_translate)
-
-            if(Kijiku.LLM_TYPE == "openai"):
-                encoding = tiktoken.encoding_for_model(model)
-                num_tokens = len(encoding.encode(text))
-
-            else:
-                num_tokens = GeminiService.count_tokens(text)
-
-            input_cost = cost_details["input_cost"]
-            output_cost = cost_details["output_cost"]
-
-            min_cost_for_input = (num_tokens / 1000) * input_cost
-            min_cost_for_output = (num_tokens / 1000) * output_cost
-            min_cost = min_cost_for_input + min_cost_for_output
-
-            return num_tokens, min_cost, model
-        
-        ## type checker doesn't like the chance of None being returned, so we raise an exception here if it gets to this point
-        raise Exception("An unknown error occurred while calculating the minimum cost of translation.")
-    
 ##-------------------start-of-handle_cost_estimate_prompt()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
     @staticmethod
@@ -819,17 +642,19 @@ class Kijiku:
         
         """ 
 
+        translation_instructions = Kijiku.openai_system_message if Kijiku.LLM_TYPE == "openai" else Kijiku.gemini_prompt
+
         ## get cost estimate and confirm
-        num_tokens, min_cost, model = Kijiku.estimate_cost(model)
+        num_tokens, min_cost, model = EasyTL.calculate_cost(text=Kijiku.text_to_translate, service=Kijiku.LLM_TYPE, model=model,translation_instructions=translation_instructions)
 
-        print("\nNote that the cost estimate is not always accurate, and may be higher than the actual cost. However cost calculation now includes output tokens.\n")
+        print("Note that the cost estimate is not always accurate, and may be higher than the actual cost. However cost calculation now includes output tokens.\n")
 
         Logger.log_barrier()
         Logger.log_action("Calculating cost")
         Logger.log_barrier()
 
         if(Kijiku.LLM_TYPE == "gemini"):
-            Logger.log_action(f"As of Kudasai {Toolkit.CURRENT_VERSION}, Gemini Pro 1.0 is free to use under 60 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.\nIt is currently unknown whether the ultra model parameter is connecting to the actual ultra model and not a pro one. As it works, but does not appear on any documentation.\n", output=True, omit_timestamp=True)
+            Logger.log_action(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 kijiku_settings.", output=True, omit_timestamp=True)
         
         Logger.log_action("Estimated number of tokens : " + str(num_tokens), output=True, omit_timestamp=True)
         Logger.log_action("Estimated minimum cost : " + str(min_cost) + " USD", output=True, omit_timestamp=True)
@@ -849,7 +674,7 @@ class Kijiku:
 ##-------------------start-of-handle_translation()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
     
     @staticmethod
-    async def handle_translation(model:str, index:int, length:int, translation_instructions:typing.Union[str, Message], translation_prompt:typing.Union[str, Message]) -> tuple[int, typing.Union[str, Message], str]:
+    async def handle_translation(model:str, index:int, length:int, translation_instructions:typing.Union[str, SystemTranslationMessage], translation_prompt:typing.Union[str, ModelTranslationMessage]) -> tuple[int, str, str]:
 
         """
 
@@ -885,19 +710,39 @@ class Kijiku:
                 try:
 
                     if(Kijiku.LLM_TYPE == "openai"):
-                        translated_message = await OpenAIService.translate_message(translation_instructions, translation_prompt) # type: ignore
+                        translated_message = await EasyTL.openai_translate_async(text=translation_prompt,
+                                                                                decorator=Kijiku.decorator_to_use,
+                                                                                translation_instructions=translation_instructions,
+                                                                                model=model,
+                                                                                temperature=Kijiku.openai_temperature,
+                                                                                top_p=Kijiku.openai_top_p,
+                                                                                stop=Kijiku.openai_stop,
+                                                                                max_tokens=Kijiku.openai_max_tokens,
+                                                                                presence_penalty=Kijiku.openai_presence_penalty,
+                                                                                frequency_penalty=Kijiku.openai_frequency_penalty)
 
                     else:
-                        translated_message = await GeminiService.translate_message(translation_instructions, translation_prompt) # type: ignore
+
+                        assert isinstance(translation_prompt, str)
+
+                        translated_message = await EasyTL.gemini_translate_async(text=translation_prompt,
+                                                                                 decorator=Kijiku.decorator_to_use,
+                                                                                 model=model,
+                                                                                 temperature=Kijiku.gemini_temperature,
+                                                                                 top_p=Kijiku.gemini_top_p,
+                                                                                 top_k=Kijiku.gemini_top_k,
+                                                                                 stop_sequences=Kijiku.gemini_stop_sequences,
+                                                                                 max_output_tokens=Kijiku.gemini_max_output_tokens)
 
                 ## will only occur if the max_batch_duration is exceeded, so we just return the untranslated text
                 except MaxBatchDurationExceededException:
-                    translated_message = translation_prompt.content if isinstance(translation_prompt, Message) else translation_prompt
+
                     Logger.log_error(f"Batch {message_number} of {length//2} was not translated due to exceeding the max request duration, returning the untranslated text...", output=True)
                     break
 
                 ## do not even bother if not a gpt 4 model, because gpt-3 seems unable to format properly
-                if("gpt-4" not in model):
+                ## since gemini is free, we can just try again if it's malformed
+                if("gpt-4" not in model and Kijiku.LLM_TYPE != "gemini"): 
                     break
 
                 if(await Kijiku.check_if_translation_is_good(translated_message, translation_prompt)):
@@ -913,12 +758,18 @@ class Kijiku:
                     Logger.log_error(f"Batch {message_number} of {length//2} was malformed, retrying...", output=True)
                     Kijiku.num_occurred_malformed_batches += 1
 
+            if(isinstance(translation_prompt, ModelTranslationMessage)):
+                translation_prompt = translation_prompt.content
+
+            if(isinstance(translated_message, typing.List)):
+                translated_message = ''.join(translated_message)
+
             return index, translation_prompt, translated_message
     
 ##-------------------start-of-check_if_translation_is_good()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
     @staticmethod
-    async def check_if_translation_is_good(translated_message:str, translation_prompt:typing.Union[Message, str]) -> bool:
+    async def check_if_translation_is_good(translated_message:typing.Union[typing.List[str], str], translation_prompt:typing.Union[ModelTranslationMessage, str]) -> bool:
 
         """
         
@@ -938,6 +789,9 @@ class Kijiku:
 
         else:
             prompt = translation_prompt
+
+        if(isinstance(translated_message, list)):
+            translated_message = ''.join(translated_message)
             
         is_valid = False
 

modules/common/exceptions.py

@@ -1,9 +1,8 @@
 ## third-party libraries
-
 ## for importing, other scripts will use from common.exceptions instead of from the third-party libraries themselves
-from openai import AuthenticationError, InternalServerError, RateLimitError, APITimeoutError
-from deepl.exceptions import AuthorizationException, QuotaExceededException
-from google.auth.exceptions import GoogleAuthError
+from easytl import AuthenticationError, InternalServerError, RateLimitError, APITimeoutError
+from easytl import AuthorizationException, QuotaExceededException
+from easytl import GoogleAuthError
 
 ##-------------------start-of-MaxBatchDurationExceededException--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
@@ -15,7 +14,16 @@ class MaxBatchDurationExceededException(Exception):
 
     """
 
-    pass
+    def __init__(self, message:str) -> None:
+
+        """
+
+        Parameters:
+        message (string) : The message to display.
+
+        """
+
+        self.message = message
 
 ##-------------------start-of-InvalidAPIKeyException--------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 

modules/common/file_ensurer.py

@@ -105,39 +105,6 @@ class FileEnsurer():
         "gemini_max_output_tokens": None
     }
 }
-
-
-    ALLOWED_OPENAI_MODELS  = [
-        "gpt-3.5-turbo",
-        "gpt-4",
-        "gpt-4-turbo-preview",
-        "gpt-3.5-turbo-0301",
-        "gpt-4-0314",
-        "gpt-4-32k-0314",
-        "gpt-3.5-turbo-0613",
-        "gpt-3.5-turbo-0125",
-        "gpt-3.5-turbo-16k-0613",
-        "gpt-3.5-turbo-1106",
-        "gpt-4-0613",
-        "gpt-4-32k-0613",
-        "gpt-4-1106-preview",
-        "gpt-4-0125-preview"
-    ]
-
-    ALLOWED_GEMINI_MODELS = [
-        "gemini-1.0-pro-001",
-        "gemini-1.0-pro-vision-001",
-        "gemini-1.0-pro",
-        "gemini-1.0-pro-vision",
-        "gemini-1.0-pro-latest",
-        "gemini-1.0-pro-vision-latest",
-        "gemini-1.5-pro-latest",
-        "gemini-1.0-ultra-latest",
-        "gemini-pro",
-        "gemini-pro-vision",
-        "gemini-ultra"
-    ]
-
     INVALID_KIJIKU_RULES_PLACEHOLDER = {
     "INVALID JSON": 
     {
@@ -262,6 +229,7 @@ class FileEnsurer():
                 else:
                     with open(thing, "w", encoding="utf-8") as file:
                         file.truncate()
+                        
 ##--------------------start-of-standard_create_directory()------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
     @staticmethod

modules/common/toolkit.py

@@ -14,7 +14,7 @@ class Toolkit():
 
     """
 
-    CURRENT_VERSION = "v3.4.1"
+    CURRENT_VERSION = "v3.4.3"
 
 ##-------------------start-of-clear_console()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 

requirements.txt

@@ -1,8 +1,5 @@
-deepl==1.16.1
-openai==1.13.3
 backoff==2.2.1
-tiktoken==0.6.0
 gradio==4.19.2
 kairyou==1.4.1
-google-generativeai==0.4.0
+easytl==0.1.0
 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

translation_services/deepl_service.py

@@ -1,85 +0,0 @@
-## built-in libraries
-import typing
-
-## third-party libraries
-from deepl.translator import Translator
-
-class DeepLService:
-
-    api_key:str
-    translator:Translator
-
-##-------------------start-of-translate()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-    
-    @staticmethod
-    def translate(text:str, target_lang:str, source_lang:str) -> str:
-
-        """
-
-        Translates the text to the target language.
-
-        Parameters:
-        text (string) : The text to translate.
-        target_lang (string) : The target language.
-        source_lang (string) : The source language.
-
-        Returns:
-        translation (string) : The translated text.
-
-        """
-
-        try:
-
-            translation = DeepLService.translator.translate_text(text, target_lang=target_lang, source_lang=source_lang)
-
-            return str(translation)
-        
-        except Exception as e:
-            raise e
-
-##-------------------start-of-set_api_key()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def set_api_key(api_key:str) -> None:
-
-        """
-
-        Sets the API key for the DeepL client.
-
-        Parameters:
-        api_key (string) : The API key to set.
-
-        """
-
-        DeepLService.api_key = api_key
-
-##-------------------start-of-test_api_key_validity()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-    
-    @staticmethod
-    def test_api_key_validity() -> typing.Tuple[bool, typing.Union[Exception, None]]:
-
-        """
-
-        Tests the validity of the API key.
-
-        Returns:
-        validity (bool) : True if the API key is valid, False if it is not.
-        e (Exception) : The exception that was raised, if any.
-
-        """
-
-        validity = False
-
-        try:
-
-            DeepLService.translator = Translator(DeepLService.api_key)
-
-            DeepLService.translator.translate_text("test", target_lang="JA")
-
-            validity = True
-
-            return validity, None
-
-        except Exception as e:
-
-            return validity, e

translation_services/gemini_service.py

@@ -1,215 +0,0 @@
-## built-in libraries
-import typing
-
-## third party libraries
-from google.generativeai import GenerationConfig
-import google.generativeai as genai
-
-class GeminiService:
-
-    model:str = "gemini-pro"
-    prompt:str = ""
-    temperature:float = 0.5
-    top_p:float = 0.9
-    top_k:int = 40
-    candidate_count:int = 1
-    stream:bool = False
-    stop_sequences:typing.List[str] | None = None
-    max_output_tokens:int | None = None
-
-    client:genai.GenerativeModel
-    generation_config:GenerationConfig
-
-    decorator_to_use:typing.Union[typing.Callable, None] = None
-
-    safety_settings = [
-        {
-            "category": "HARM_CATEGORY_DANGEROUS",
-            "threshold": "BLOCK_NONE",
-        },
-        {
-            "category": "HARM_CATEGORY_HARASSMENT",
-            "threshold": "BLOCK_NONE",
-        },
-        {
-            "category": "HARM_CATEGORY_HATE_SPEECH",
-            "threshold": "BLOCK_NONE",
-        },
-        {
-            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-            "threshold": "BLOCK_NONE",
-        },
-        {
-            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
-            "threshold": "BLOCK_NONE",
-        },
-    ]
-
-##-------------------start-of-set_api_key()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def set_api_key(api_key:str) -> None:
-
-        """
-
-        Sets the API key for the Gemini client.
-
-        Parameters:
-        api_key (string) : The API key to set.
-
-        """
-
-        genai.configure(api_key=api_key)
-
-##-------------------start-of-set_decorator()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def set_decorator(decorator:typing.Callable) -> None:
-
-        """
-
-        Sets the decorator to use for the Gemini service. Should be a callable that returns a decorator.
-
-        Parameters:
-        decorator (callable) : The decorator to use.
-
-        """
-
-        GeminiService.decorator_to_use = decorator
-
-##-------------------start-of-setup_client()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def redefine_client() -> None:
-
-        """
-
-        Redefines the Gemini client and generation config. This should be called before making any requests to the Gemini service, or after changing any of the service's settings.
-
-        """
-
-        GeminiService.client = genai.GenerativeModel(GeminiService.model)
-        GeminiService.generation_config = GenerationConfig(candidate_count=GeminiService.candidate_count,
-                                                           max_output_tokens=GeminiService.max_output_tokens,
-                                                           stop_sequences=GeminiService.stop_sequences,
-                                                            temperature=GeminiService.temperature,
-                                                            top_p=GeminiService.top_p,
-                                                            top_k=GeminiService.top_k)
-        
-##-------------------start-of-count_tokens()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def count_tokens(prompt:str) -> int:
-
-        """
-
-        Counts the number of tokens in a prompt.
-
-        Parameters:
-        prompt (string) : The prompt to count the tokens of.
-
-        Returns:
-        count (int) : The number of tokens in the prompt.
-
-        """
-
-        return genai.GenerativeModel(GeminiService.model).count_tokens(prompt).total_tokens
-
-##-------------------start-of-trans()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    async def translate_message(translation_instructions:str, translation_prompt:str) -> str:
-
-        """
-
-        Translates a prompt.
-
-        Parameters:
-        translation_prompt (object - ModelTranslationMessage) : The prompt to translate.
-
-        Returns:
-        output (string) : The translation.
-
-        """
-
-        if(GeminiService.decorator_to_use is None):
-            return await GeminiService._translate_message(translation_instructions, translation_prompt)
-
-        decorated_function = GeminiService.decorator_to_use(GeminiService._translate_message)
-        return await decorated_function(translation_instructions, translation_prompt)
-
-##-------------------start-of-_translate_message()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    async def _translate_message(translation_instructions:str, translation_prompt:str) -> str:
-
-        """
-
-        Translates a prompt.
-
-        Parameters:
-        translation_prompt (string) : The prompt to translate.
-
-        Returns:
-        output (string) a string that gpt gives to us also known as the translation.
-
-        """
-
-        response = await GeminiService.client.generate_content_async(
-            contents=translation_instructions + "\n" + translation_prompt,
-            generation_config=GeminiService.generation_config,
-            safety_settings=GeminiService.safety_settings,
-            stream=GeminiService.stream
-        )
-
-        return response.text
-    
-##-------------------start-of-test_api_key_validity()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-    
-    @staticmethod
-    async def test_api_key_validity() -> typing.Tuple[bool, typing.Union[Exception, None]]:
-
-        """
-
-        Tests the validity of the API key.
-
-        Returns:
-        validity (bool) : True if the API key is valid, False if it is not.
-        e (Exception) : The exception that was raised, if any.
-
-        """
-
-        validity = False
-
-        try:
-
-            generation_config = GenerationConfig(candidate_count=1, max_output_tokens=1)
-
-            await GeminiService.client.generate_content_async(
-                "Respond to this prompt with 1",generation_config=generation_config
-
-            )
-
-            validity = True
-
-            return validity, None
-
-        except Exception as e:
-
-            return validity, e
-        
-##-------------------start-of-get_decorator()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def get_decorator() -> typing.Union[typing.Callable, None]:
-
-        """
-
-        Returns the decorator to use for the Gemini service.
-
-        Returns:
-        decorator (callable) : The decorator to use.
-
-        """
-
-        return GeminiService.decorator_to_use

translation_services/openai_service.py

@@ -1,180 +0,0 @@
-## built-in libraries
-import typing
-
-## third-party libraries
-from openai import AsyncOpenAI
-
-## custom modules
-from modules.common.exceptions import InvalidAPIKeyException
-from custom_classes.messages import SystemTranslationMessage, Message
-
-class OpenAIService:
-
-    ## async client session
-    client = AsyncOpenAI(max_retries=0, api_key="DummyKey")
-
-    model:str
-    system_message:typing.Optional[typing.Union[SystemTranslationMessage, str]] = None
-    temperature:float
-    top_p:float
-    n:int
-    stream:bool
-    stop:typing.List[str] | None
-    logit_bias:typing.Dict[str, float] | None
-    max_tokens:int | None
-    presence_penalty:float
-    frequency_penalty:float
-
-    decorator_to_use:typing.Union[typing.Callable, None] = None
-
-##-------------------start-of-set_api_key()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def set_api_key(api_key:str) -> None:
-
-        """
-
-        Sets the API key for the OpenAI client.
-
-        Parameters:
-        api_key (string) : The API key to set.
-
-        """
-
-        OpenAIService.client.api_key = api_key
-
-##-------------------start-of-set_decorator()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def set_decorator(decorator:typing.Callable) -> None:
-
-        """
-
-        Sets the decorator to use for the OpenAI service. Should be a callable that returns a decorator.
-
-        Parameters:
-        decorator (callable) : The decorator to use.
-
-        """
-
-        OpenAIService.decorator_to_use = decorator
-
-##-------------------start-of-trans()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    async def translate_message(translation_instructions:Message, translation_prompt:Message) -> str:
-
-        """
-        
-        Translates a system and user message.
-
-        Parameters:
-        translation_instructions (object - SystemTranslationMessage | ModelTranslationMessage) : The system message also known as the instructions.
-        translation_prompt (object - ModelTranslationMessage) : The user message also known as the prompt.
-
-        Returns:
-        output (string) a string that gpt gives to us also known as the translation.
-
-        """
-
-        if(OpenAIService.decorator_to_use == None):
-            return await OpenAIService._translate_message(translation_instructions, translation_prompt)
-
-        decorated_function = OpenAIService.decorator_to_use(OpenAIService._translate_message)
-        return await decorated_function(translation_instructions, translation_prompt)
-
-##-------------------start-of-_translate_message()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    ## backoff wrapper for retrying on errors, As of OpenAI > 1.0.0, it comes with a built in backoff system, but I've grown accustomed to this one so I'm keeping it.
-    @staticmethod
-    async def _translate_message(translation_instructions:Message, translation_prompt:Message) -> str:
-
-        """
-
-        Translates a system and user message.
-
-        Parameters:
-        translation_instructions (object - SystemTranslationMessage | ModelTranslationMessage) : The system message also known as the instructions.
-        translation_prompt (object - ModelTranslationMessage) : The user message also known as the prompt.
-
-        Returns:
-        output (string) a string that gpt gives to us also known as the translation.
-
-        """
-
-        if(OpenAIService.client.api_key == "DummyKey"):
-            raise InvalidAPIKeyException("OpenAI")
-
-        ## logit bias is currently excluded due to a lack of need, and the fact that i am lazy
-
-        response = await OpenAIService.client.chat.completions.create(
-            model=OpenAIService.model,
-            messages=[
-                translation_instructions.to_dict(),
-                translation_prompt.to_dict()
-            ],  # type: ignore
-
-            temperature = OpenAIService.temperature,
-            top_p = OpenAIService.top_p,
-            n = OpenAIService.n,
-            stream = OpenAIService.stream,
-            stop = OpenAIService.stop,
-            presence_penalty = OpenAIService.presence_penalty,
-            frequency_penalty = OpenAIService.frequency_penalty,
-            max_tokens = OpenAIService.max_tokens       
-
-        )
-
-        ## if anyone knows how to type hint this please let me know
-        output = response.choices[0].message.content
-        
-        return output
-    
-##-------------------start-of-test_api_key_validity()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-    
-    @staticmethod
-    async def test_api_key_validity() -> typing.Tuple[bool, typing.Union[Exception, None]]:
-
-        """
-
-        Tests the validity of the API key.
-
-        Returns:
-        validity (bool) : True if the API key is valid, False if it is not.
-        e (Exception) : The exception that was raised, if any.
-
-        """
-
-        validity = False
-
-        try:
-
-            await OpenAIService.client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=[{"role":"user","content":"This is a test."}],
-                max_tokens=1
-            )
-
-            validity = True
-
-            return validity, None
-
-        except Exception as e:
-
-            return validity, e
-        
-##-------------------start-of-get_decorator()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    @staticmethod
-    def get_decorator() -> typing.Union[typing.Callable, None]:
-
-        """
-
-        Returns the decorator to use for the OpenAI service.
-
-        Returns:
-        decorator (callable) : The decorator to use.
-
-        """
-
-        return OpenAIService.decorator_to_use

util/token_counter.py

@@ -11,9 +11,11 @@ parent_dir = current_dir.parent
 ## Add the parent directory to sys.path so 'modules' can be found
 sys.path.append(str(parent_dir))
 
+## third-party libraries
+from easytl import EasyTL
+
 ## custom modules
 from modules.common.toolkit import Toolkit
-from models.kijiku import Kijiku
 
 class TokenCounter:
 
@@ -37,28 +39,6 @@ class TokenCounter:
 
         self.MODEL:str = ""
 
-##-------------------start-of-count_characters()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
-
-    def count_characters(self) -> int:
-
-        """
-
-        Counts the number of characters in a string.
-    
-        Parameters:
-        self (object - TokenCounter) : The TokenCounter object.
-
-        Returns:
-        num_characters (int) The number of characters in the text.
-
-        """
-
-        Toolkit.clear_console()
-
-        num_characters = len(self.text)
-
-        return num_characters
-
 ##-------------------start-of-estimate_cost()---------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
     def estimate_cost(self, text_file:str) -> None:
@@ -78,17 +58,19 @@ class TokenCounter:
             self.text = file.read()
 
         self.MODEL = input("Please enter model : ")
+        self.service = "openai" if "gpt" in self.MODEL else "gemini"
 
-        ## lazy workaround for now
-        Kijiku.text_to_translate = [line for line in self.text.splitlines()]
+        text_to_translate = [line for line in self.text.splitlines()]
 
-        num_tokens, min_cost, self.MODEL = Kijiku.estimate_cost(self.MODEL)
-        num_characters = self.count_characters()
+        num_tokens, min_cost, self.MODEL = EasyTL.calculate_cost(text=text_to_translate, service=self.service, model=self.MODEL)
 
-        print("This is an estimate of the cost of translating a text using Kudasai. The actual cost may be higher or lower depending on the model used and the number of tokens in the text.\n")
-        print("Estimated Number of Tokens in Text : " + str(num_tokens))
-        print("Estimated Minimum Cost of Translation : " + str(min_cost))
-        print("Number of Characters in Text : " + str(num_characters) + "\n")
+        print("\nNote that the cost estimate is not always accurate, and may be higher than the actual cost. However cost calculation now includes output tokens.\n")
+
+        if(self.service == "gemini"):
+            print(f"As of Kudasai {Toolkit.CURRENT_VERSION}, Gemini Pro 1.0 is free to use under 60 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.\nIt is currently unknown whether the ultra model parameter is connecting to the actual ultra model and not a pro one. As it works, but does not appear on any documentation.\n")
+        
+        print("Estimated number of tokens : " + str(num_tokens))
+        print("Estimated minimum cost : " + str(min_cost) + " USD")
 
         Toolkit.pause_console()
 

webgui.py

@@ -7,7 +7,9 @@ import gradio as gr
 
 from kairyou import Indexer
 from kairyou import Kairyou
-from kairyou.exceptions import InvalidReplacementJsonKeys
+from kairyou import InvalidReplacementJsonKeys
+
+from easytl import EasyTL, ALLOWED_GEMINI_MODELS, ALLOWED_OPENAI_MODELS
 
 ## custom modules
 from modules.common.toolkit import Toolkit
@@ -21,10 +23,6 @@ from handlers.json_handler import JsonHandler
 
 from models.kaiseki import Kaiseki
 from models.kijiku import Kijiku
-from translation_services.deepl_service import DeepLService
-
-from translation_services.openai_service import OpenAIService
-from translation_services.gemini_service import GeminiService
 
 from kudasai import Kudasai
 
@@ -165,15 +163,14 @@ class KudasaiGUI:
                 ## next api key
                 try:
                     if(Kijiku.LLM_TYPE == "openai"):
-                        OpenAIService.set_api_key(str(api_key))
-                        is_valid, e = await OpenAIService.test_api_key_validity()
+                        EasyTL.set_api_key(Kijiku.LLM_TYPE, str(api_key))
+                        is_valid, e = EasyTL.test_api_key_validity(Kijiku.LLM_TYPE)
 
 
                     else:
 
-                        GeminiService.redefine_client()
-                        GeminiService.set_api_key(str(api_key))
-                        is_valid, e = await GeminiService.test_api_key_validity()
+                        EasyTL.set_api_key(Kijiku.LLM_TYPE, str(api_key))
+                        is_valid, e = EasyTL.test_api_key_validity(Kijiku.LLM_TYPE)
 
                     if(is_valid == False and e is not None):
                         raise e
@@ -498,7 +495,7 @@ class KudasaiGUI:
 
                             self.openai_model_input_field = gr.Dropdown(label="OpenAI Model",
                                                                         value=str(GuiJsonUtil.fetch_kijiku_setting_key_values("openai settings","openai_model")),
-                                                                        choices=[model for model in FileEnsurer.ALLOWED_OPENAI_MODELS],
+                                                                        choices=[model for model in ALLOWED_OPENAI_MODELS],
                                                                         info="ID of the model to use. Kijiku only works with 'chat' models.",
                                                                         show_label=True,
                                                                         interactive=True,
@@ -600,7 +597,7 @@ class KudasaiGUI:
 
                             self.gemini_model_input_field = gr.Dropdown(label="Gemini Model",
                                                                         value=str(GuiJsonUtil.fetch_kijiku_setting_key_values("gemini settings","gemini_model")),
-                                                                        choices=[model for model in FileEnsurer.ALLOWED_GEMINI_MODELS],
+                                                                        choices=[model for model in ALLOWED_GEMINI_MODELS],
                                                                         info="The model to use. Currently only supports gemini-pro and gemini-pro-vision, the 1.0 model and it's aliases.",
                                                                         show_label=True,
                                                                         interactive=True,
@@ -905,9 +902,9 @@ class KudasaiGUI:
                     text_to_translate = input_text
 
                 try:
-                    DeepLService.set_api_key(str(api_key_input))
+                    EasyTL.set_api_key("deepl", str(api_key_input))
 
-                    is_valid, e = DeepLService.test_api_key_validity()
+                    is_valid, e = EasyTL.test_api_key_validity("deepl")
 
                     if(is_valid == False and e is not None):
                         raise e
@@ -1064,8 +1061,6 @@ class KudasaiGUI:
                 else:
                     Kijiku.LLM_TYPE = "gemini"
 
-                    ## normally done in Kijiku.commence_translation, but since we're not translating, we need to do it here
-                    GeminiService.redefine_client()
 
                 await set_kijiku_api_key(api_key)
 
@@ -1077,15 +1072,15 @@ class KudasaiGUI:
                 else:
                     text_to_translate = input_text
 
-                ## need to convert to list of strings
-                Kijiku.text_to_translate = [line for line in str(text_to_translate).splitlines()]
+                translation_instructions = GuiJsonUtil.fetch_kijiku_setting_key_values("openai settings","openai_system_message") if Kijiku.LLM_TYPE == "openai" else GuiJsonUtil.fetch_kijiku_setting_key_values("gemini settings","gemini_prompt")
 
-                num_tokens, estimated_cost, model = Kijiku.estimate_cost(model)
+                num_tokens, estimated_cost, model = EasyTL.calculate_cost(text=text_to_translate, service=Kijiku.LLM_TYPE, model=model, translation_instructions=translation_instructions)
 
                 if(Kijiku.LLM_TYPE == "gemini"):
-                    cost_estimation = f"As of Kudasai {Toolkit.CURRENT_VERSION}, Gemini Pro is Free to use\n"
+                    cost_estimation = f"As of Kudasai {Toolkit.CURRENT_VERSION}, Gemini Pro 1.0 is free to use under 60 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.\nIt is currently unknown whether the ultra model parameter is connecting to the actual ultra model and not a pro one. As it works, but does not appear on any documentation.\n"
 
                 cost_estimation += "Estimated number of tokens : " + str(num_tokens) + "\n" + "Estimated minimum cost : " + str(estimated_cost) + " USD"
+                cost_estimation += "\nThis is a rough estimate, please remember to check actual cost on the appropriate platform when needed"
                 
                 gr.Info(cost_estimation)
 
@@ -1401,7 +1396,7 @@ class KudasaiGUI:
                     gemini_max_output_tokens_value
                 ]
 
-                gr.Info("Kijiku Settings Reset to Default")
+                gr.Info("Kijiku Settings Reset to Default. Make sure to press the Apply button to apply the changes.")
 
                 return return_batch