Refactored; Updated call HKBU ChatGPT API

app/main.py

@@ -0,0 +1,13 @@
+import gradio as gr
+from app.routes.text_translator import text_translator
+from app.routes.document_translator import document_translator
+
+# Combine both interfaces into tabs
+demo = gr.TabbedInterface(
+    title="FloweryTranslator",
+    interface_list=[text_translator, document_translator],
+    tab_names=["Text", "Document"]
+)
+
+if __name__ == "__main__":
+    demo.launch(show_api=False)

app/routes/document_translator.py

@@ -0,0 +1,134 @@
+import gradio as gr
+from docx import Document
+import fitz  # PyMuPDF
+from datetime import datetime
+import os
+from dotenv import load_dotenv
+
+from app.routes.text_translator import translate_text
+
+load_dotenv()
+passcode_key = os.getenv("PASSCODE_KEY")
+
+
+def process_uploaded_file(file):
+    content = ""
+    # Detect the file type based on its extension
+    file_extension = file.name.split('.')[-1].lower()
+
+    # Process each file according to its type
+    if file_extension == 'docx':
+        doc = Document(file)
+        full_text = [para.text for para in doc.paragraphs]
+        content = '\n'.join(full_text)
+    elif file_extension == 'pdf':
+        # Open the PDF file
+        with fitz.open(file) as pdf:
+            full_text = []
+            for page in pdf:
+                full_text.append(page.get_text("text"))
+            content = '\n'.join(full_text)
+    else:
+        raise ValueError(f"Unsupported file type: {file_extension}")
+
+    return content
+
+
+def translate_document(source_language, target_language, original_doc, tone_of_voice, industry, model, passcode):
+    output_files = []
+
+    # Check if the passcode is correct
+    if passcode + "1" != passcode_key:
+        # Create a new .docx document
+        doc = Document()
+        doc.add_paragraph("The passcode is incorrect. Please try again.")
+
+        # Save the document
+        timestamp = datetime.now().strftime("%m%d%H%M")
+        output_filename = f"translated_text_{timestamp}.docx"
+        doc.save(output_filename)
+        output_files.append(output_filename)
+
+        # Return the list of output files
+        return output_files
+
+    # Generate translated text
+    # Process the uploaded files
+    original_doc_content = ""
+
+    if original_doc is not None:
+        original_doc_content = process_uploaded_file(original_doc)
+
+    # Translate the uploaded files
+    translated_text = translate_text(source_language, target_language, original_doc_content, tone_of_voice, industry,
+                                     model, passcode)
+
+    # Create a new .docx document
+    doc = Document()
+    doc.add_paragraph(f"{translated_text}")
+
+    # Save the document
+    timestamp = datetime.now().strftime("%m%d%H%M")
+    output_filename = f"translated_text_{timestamp}.docx"
+    doc.save(output_filename)
+    output_files.append(output_filename)
+
+    # Return the list of output files
+    return output_files
+
+
+# Interface for Document Translator
+document_translator = gr.Interface(
+    fn=translate_document,
+    inputs=[
+        gr.Dropdown(
+            label="Source Language",
+            choices=["Chinese", "English (UK)", "English (US)", "Vietnamese", "Japanese", "Korean", "French", "German",
+                     "Spanish", "Portuguese (Brazilian)", "Portuguese (European)", "Italian", "Dutch", "Polish",
+                     "Russian"],
+            value="Chinese"
+        ),
+        gr.Dropdown(
+            label="Target Language",
+            choices=["Chinese", "English (UK)", "English (US)", "Vietnamese", "Japanese", "Korean", "French", "German",
+                     "Spanish", "Portuguese (Brazilian)", "Portuguese (European)", "Italian", "Dutch", "Polish",
+                     "Russian"],
+            value="Vietnamese"
+        ),
+        gr.File(
+            label="Original Text Document",
+            file_types=[".docx", ".pdf"],
+            file_count="single"
+        ),
+        gr.Radio(
+            label="Tone of Voice",
+            choices=["Standard", "Formal", "Informal"],
+            value="Standard"
+        ),
+        gr.Dropdown(
+            label="Industry Sector",
+            choices=["General Fields", "Academic Papers", "Biomedicine", "Information Technology",
+                     "Finance and Economics", "News and Information", "Aerospace", "Mechanical Manufacturing",
+                     "Laws and Regulations", "Humanities and Social Sciences"],
+            value="General Fields"
+        ),
+        gr.Dropdown(
+            label="Model Provider (Model Name)",
+            choices=["DeepL", "Volcengine", "HKBU ChatGPT (gpt-35-turbo-16k)", "HKBU ChatGPT (gpt-4-turbo)",
+                     "OpenAI (gpt-3.5-turbo-1106)", "OpenAI (gpt-4-0125-preview)", "Google Gemini (gemini-pro)",
+                     "Baichuan AI (Baichuan2)", "Zhipu AI (glm-3-turbo)", "Zhipu AI (glm-4)"],
+            value="OpenAI (gpt-3.5-turbo-1106)"
+        ),
+        gr.Textbox(
+            label="Passcode",
+            placeholder="Enter the passcode here",
+            type="password",
+            lines=1,
+            max_lines=1
+        )
+    ],
+    outputs=[
+        gr.File(label="Translated Text Document", file_count="single", type="filepath")
+    ],
+    title="FloweryTranslator - Document Translator"
+)

main.py → app/routes/text_translator.py

@@ -1,17 +1,12 @@
-import gradio as gr
-from docx import Document
-import fitz  # PyMuPDF
-from datetime import datetime
 import os
-import tempfile
-from zipfile import ZipFile
-from utils import translate_by_deepl_api
-from utils import translate_by_volcengine_api
-from utils import translate_by_openai_api
-from utils import translate_by_baichuan_api
-from utils import translate_by_hkbu_chatgpt_api
-from utils import translate_by_google_api
-from utils import translate_by_zhipuai_api
+import gradio as gr
+from utils.translate.translate_deepl import translate_by_deepl_api
+from utils.translate.translate_volcengine import translate_by_volcengine_api
+from utils.translate.translate_hkbu_chatgpt import translate_by_hkbu_chatgpt_api
+from utils.translate.translate_openai import translate_by_openai_api
+from utils.translate.translate_google import translate_by_google_api
+from utils.translate.translate_baichuan import translate_by_baichuan_api
+from utils.translate.translate_zhipuai import translate_by_zhipuai_api
 from dotenv import load_dotenv
 
 load_dotenv()
@@ -42,9 +37,9 @@ def translate_text(source_language, target_language, original_text, tone_of_voic
         translation_sample, translated_text = translate_by_hkbu_chatgpt_api(
             source_language, target_language, original_text, tone_of_voice, industry, "gpt-35-turbo-16k"
         )
-    elif model == "HKBU ChatGPT (gpt-4)":
+    elif model == "HKBU ChatGPT (gpt-4-turbo)":
         translation_sample, translated_text = translate_by_hkbu_chatgpt_api(
-            source_language, target_language, original_text, tone_of_voice, industry, "gpt-4"
+            source_language, target_language, original_text, tone_of_voice, industry, "gpt-4-turbo"
         )
     elif model == "OpenAI (gpt-3.5-turbo-1106)":
         translation_sample, translated_text = translate_by_openai_api(
@@ -74,72 +69,6 @@ def translate_text(source_language, target_language, original_text, tone_of_voic
     return translated_text
 
 
-def process_uploaded_file(file):
-    content = ""
-    # Detect the file type based on its extension
-    file_extension = file.name.split('.')[-1].lower()
-
-    # Process each file according to its type
-    if file_extension == 'docx':
-        doc = Document(file)
-        full_text = [para.text for para in doc.paragraphs]
-        content = '\n'.join(full_text)
-    elif file_extension == 'pdf':
-        # Open the PDF file
-        with fitz.open(file) as pdf:
-            full_text = []
-            for page in pdf:
-                full_text.append(page.get_text("text"))
-            content = '\n'.join(full_text)
-    else:
-        raise ValueError(f"Unsupported file type: {file_extension}")
-
-    return content
-
-
-def translate_document(source_language, target_language, original_doc, tone_of_voice, industry, model, passcode):
-    output_files = []
-
-    # Check if the passcode is correct
-    if passcode + "1" != passcode_key:
-        # Create a new .docx document
-        doc = Document()
-        doc.add_paragraph("The passcode is incorrect. Please try again.")
-
-        # Save the document
-        timestamp = datetime.now().strftime("%m%d%H%M")
-        output_filename = f"translated_text_{timestamp}.docx"
-        doc.save(output_filename)
-        output_files.append(output_filename)
-
-        # Return the list of output files
-        return output_files
-
-    # Generate translated text
-    # Process the uploaded files
-    original_doc_content = ""
-
-    if original_doc is not None:
-        original_doc_content = process_uploaded_file(original_doc)
-
-    # Translate the uploaded files
-    translated_text = translate_text(source_language, target_language, original_doc_content, tone_of_voice, industry,
-                                     model, passcode)
-
-    # Create a new .docx document
-    doc = Document()
-    doc.add_paragraph(f"{translated_text}")
-
-    # Save the document
-    timestamp = datetime.now().strftime("%m%d%H%M")
-    output_filename = f"translated_text_{timestamp}.docx"
-    doc.save(output_filename)
-    output_files.append(output_filename)
-
-    # Return the list of output files
-    return output_files
-
-
 # Interface for Text Translator
 text_translator = gr.Interface(
     fn=translate_text,
@@ -178,7 +107,7 @@ text_translator = gr.Interface(
         ),
         gr.Dropdown(
             label="Model Provider (Model Name)",
-            choices=["DeepL", "Volcengine", "HKBU ChatGPT (gpt-35-turbo-16k)", "HKBU ChatGPT (gpt-4)",
+            choices=["DeepL", "Volcengine", "HKBU ChatGPT (gpt-35-turbo-16k)", "HKBU ChatGPT (gpt-4-turbo)",
                      "OpenAI (gpt-3.5-turbo-1106)", "OpenAI (gpt-4-0125-preview)", "Google Gemini (gemini-pro)",
                      "Baichuan AI (Baichuan2)", "Zhipu AI (glm-3-turbo)", "Zhipu AI (glm-4)"],
             value="OpenAI (gpt-3.5-turbo-1106)"
@@ -196,69 +125,3 @@ text_translator = gr.Interface(
     ],
     title="FloweryTranslator - Text Translator"
 )
-
-# Interface for Document Translator
-document_translator = gr.Interface(
-    fn=translate_document,
-    inputs=[
-        gr.Dropdown(
-            label="Source Language",
-            choices=["Chinese", "English (UK)", "English (US)", "Vietnamese", "Japanese", "Korean", "French", "German",
-                     "Spanish", "Portuguese (Brazilian)", "Portuguese (European)", "Italian", "Dutch", "Polish",
-                     "Russian"],
-            value="Chinese"
-        ),
-        gr.Dropdown(
-            label="Target Language",
-            choices=["Chinese", "English (UK)", "English (US)", "Vietnamese", "Japanese", "Korean", "French", "German",
-                     "Spanish", "Portuguese (Brazilian)", "Portuguese (European)", "Italian", "Dutch", "Polish",
-                     "Russian"],
-            value="Vietnamese"
-        ),
-        gr.File(
-            label="Original Text Document",
-            file_types=[".docx", ".pdf"],
-            file_count="single"
-        ),
-        gr.Radio(
-            label="Tone of Voice",
-            choices=["Standard", "Formal", "Informal"],
-            value="Standard"
-        ),
-        gr.Dropdown(
-            label="Industry Sector",
-            choices=["General Fields", "Academic Papers", "Biomedicine", "Information Technology",
-                     "Finance and Economics", "News and Information", "Aerospace", "Mechanical Manufacturing",
-                     "Laws and Regulations", "Humanities and Social Sciences"],
-            value="General Fields"
-        ),
-        gr.Dropdown(
-            label="Model Provider (Model Name)",
-            choices=["DeepL", "Volcengine", "HKBU ChatGPT (gpt-35-turbo-16k)", "HKBU ChatGPT (gpt-4)",
-                     "OpenAI (gpt-3.5-turbo-1106)", "OpenAI (gpt-4-0125-preview)", "Google Gemini (gemini-pro)",
-                     "Baichuan AI (Baichuan2)", "Zhipu AI (glm-3-turbo)", "Zhipu AI (glm-4)"],
-            value="OpenAI (gpt-3.5-turbo-1106)"
-        ),
-        gr.Textbox(
-            label="Passcode",
-            placeholder="Enter the passcode here",
-            type="password",
-            lines=1,
-            max_lines=1
-        )
-    ],
-    outputs=[
-        gr.File(label="Translated Text Document", file_count="single", type="filepath")
-    ],
-    title="FloweryTranslator - Document Translator"
-)
-
-# Combine both interfaces into tabs
-demo = gr.TabbedInterface(
-    title="FloweryTranslator",
-    interface_list=[text_translator, document_translator],
-    tab_names=["Text", "Document"]
-)
-
-if __name__ == "__main__":
-    demo.launch(show_api=False)

utils/prompts/translation_prompt.py

@@ -0,0 +1,43 @@
+from utils.translate.translate_deepl import translate_by_deepl_api
+from utils.translate.translate_volcengine import translate_by_volcengine_api
+from utils.utils.other_utils import get_language_code
+
+
+# Translation prompt
+def generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry):
+    languages_should_use_deepl = ["Chinese", "English (UK)", "English (US)", "French", "German", "Spanish",
+                                  "Portuguese (Brazilian)", "Portuguese (European)", "Italian", "Dutch", "Polish",
+                                  "Russian"]
+    # Print the source language, target language
+    print(f"Source language: {source_language}, Language code: {get_language_code(source_language)}, Should use DeepL: {source_language in languages_should_use_deepl}")
+    print(f"Target language: {target_language}, Language code: {get_language_code(target_language)}, Should use DeepL: {target_language in languages_should_use_deepl}")
+    # Generate the translation sample
+    if source_language in languages_should_use_deepl and target_language in languages_should_use_deepl:
+        print("Using DeepL API")
+        translation_sample = translate_by_deepl_api(source_language, target_language, original_text)
+    else:
+        print("Using Volcengine API")
+        translation_sample = translate_by_volcengine_api(source_language, target_language, original_text)
+
+    # Generate the translation prompt
+    translation_prompt = f"""{source_language}:
+```
+{original_text}
+```
+
+{target_language} translation sample:
+```
+{translation_sample}
+```
+
+As a bilingual {source_language}-{target_language} native speaker and seasoned translator, your task is to proofread the {target_language} translation sample for errors based on the {source_language} text above. The translated text should be in the tone of voice of {tone_of_voice.lower()}, and should be suitable for the {industry.lower()} industry. Before providing a proofread version, please provide suggestions for corrections (if any) to the above translation sample.
+
+Your response should be formatted as follows:
+```
+Rationale:
+{target_language} translation (proofread):
+```"""
+
+    print(translation_prompt)
+
+    return translation_sample, translation_prompt

utils/translate/translate_baichuan.py

@@ -0,0 +1,28 @@
+import os
+from langchain_community.chat_models import ChatBaichuan
+from langchain.schema import HumanMessage
+from dotenv import load_dotenv
+
+from utils.prompts.translation_prompt import generate_translation_prompt
+from utils.utils.other_utils import extract_content_from_response
+
+load_dotenv()
+baichuan_api_key = os.environ.get("BAICHUAN_API_KEY")
+baichuan_secret_key = os.environ.get("BAICHUAN_SECRET_KEY")
+
+
+def translate_by_baichuan_api(source_language, target_language, original_text, tone_of_voice, industry):
+    # Prompt to provide translation
+    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
+    # Translate by accessing Baichuan API
+    chat = ChatBaichuan(temperature=0.7, baichuan_api_key=baichuan_api_key, baichuan_secret_key=baichuan_secret_key, model='Baichuan2')
+    res = chat(
+        [
+            HumanMessage(content=translation_prompt)
+        ]
+    )
+    res_content = res.content
+    print(res_content)
+    rationale, translated_text = extract_content_from_response(target_language, res_content)
+
+    return translation_sample, translated_text

utils/translate/translate_deepl.py

@@ -0,0 +1,16 @@
+import os
+import deepl
+from dotenv import load_dotenv
+
+from utils.utils.other_utils import get_language_code
+
+load_dotenv()
+deepl_api_key = os.environ.get("DEEPL_API_KEY")
+
+
+def translate_by_deepl_api(source_language, target_language, original_text):
+    target_language_code = get_language_code(target_language).upper()
+    deepl_client = deepl.Translator(deepl_api_key)
+    translated_text = deepl_client.translate_text(original_text, target_lang=target_language_code)
+
+    return translated_text.text

utils/translate/translate_google.py

@@ -0,0 +1,22 @@
+import os
+from langchain_google_genai import ChatGoogleGenerativeAI
+from dotenv import load_dotenv
+
+from utils.prompts.translation_prompt import generate_translation_prompt
+from utils.utils.other_utils import extract_content_from_response
+
+load_dotenv()
+google_api_key = os.environ.get("GOOGLE_API_KEY")
+
+
+def translate_by_google_api(source_language, target_language, original_text, tone_of_voice, industry):
+    # Prompt to provide translation
+    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
+    # Translate by accessing Google API
+    chat = ChatGoogleGenerativeAI(temperature=0.7, model="gemini-pro")
+    res = chat.invoke(translation_prompt)
+    res_content = res.content
+    print(res_content)
+    rationale, translated_text = extract_content_from_response(target_language, res_content)
+
+    return translation_sample, translated_text

utils/translate/translate_hkbu_chatgpt.py

@@ -0,0 +1,52 @@
+import os
+from dotenv import load_dotenv
+import requests
+
+from utils.prompts.translation_prompt import generate_translation_prompt
+from utils.utils.other_utils import extract_content_from_response
+
+load_dotenv()
+hkbu_chatgpt_api_key = os.environ.get("HKBU_CHATGPT_API_KEY")
+
+
+def call_hkbu_chatgpt_api(conversation_list, model_name="gpt-35-turbo-16k", temperature=0.7):
+    basic_url = "https://chatgpt.hkbu.edu.hk/general/rest"
+    api_version = "2024-02-15-preview"
+    url = basic_url + "/deployments/" + model_name + "/chat/completions/?api-version=" + api_version
+    headers = {'Content-Type': 'application/json', 'api-key': hkbu_chatgpt_api_key}
+    payload = {'messages': conversation_list, 'temperature': temperature}
+
+    try:
+        response = requests.post(url, json=payload, headers=headers)
+
+        if response.status_code == 200:
+            data = response.json()
+            return data
+        else:
+            return 'Error', response.status_code, response.text
+    except requests.RequestException as e:
+        return 'Error:', e
+
+
+def translate_by_hkbu_chatgpt_api(source_language, target_language, original_text, tone_of_voice, industry, model_name="gpt-35-turbo-16k"):
+    # Prompt to provide translation
+    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
+    res = ""
+    try:
+        # Translate by accessing HKBU ChatGPT API
+        res = call_hkbu_chatgpt_api(
+            conversation_list=[
+                {"role": "user", "content": translation_prompt}
+            ],
+            model_name=model_name,
+            temperature=0.7
+        )
+        res_content = res["choices"][0]["message"]["content"]
+    except Exception as e:
+        res_content = 'Error:', e, res
+        return res_content
+
+    print(res_content)
+    rationale, translated_text = extract_content_from_response(target_language, res_content)
+
+    return translation_sample, translated_text

utils/translate/translate_openai.py

@@ -0,0 +1,27 @@
+import os
+from langchain_community.chat_models import ChatOpenAI
+from langchain.schema import HumanMessage
+from dotenv import load_dotenv
+
+from utils.prompts.translation_prompt import generate_translation_prompt
+from utils.utils.other_utils import extract_content_from_response
+
+load_dotenv()
+openai_api_key = os.environ.get("OPENAI_API_KEY")
+
+
+def translate_by_openai_api(source_language, target_language, original_text, tone_of_voice, industry, model_name="gpt-3.5-turbo-1106"):
+    # Prompt to provide translation
+    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
+    # Translate by accessing OpenAI API
+    chat = ChatOpenAI(temperature=0.7, openai_api_key=openai_api_key, model_name=model_name)
+    res = chat(
+        [
+            HumanMessage(content=translation_prompt)
+        ]
+    )
+    res_content = res.content
+    print(res_content)
+    rationale, translated_text = extract_content_from_response(target_language, res_content)
+
+    return translation_sample, translated_text

utils/translate/translate_volcengine.py

@@ -0,0 +1,44 @@
+import os
+import json
+from volcengine.ApiInfo import ApiInfo
+from volcengine.Credentials import Credentials
+from volcengine.ServiceInfo import ServiceInfo
+from volcengine.base.Service import Service
+from dotenv import load_dotenv
+
+from utils.utils.other_utils import get_language_code
+
+load_dotenv()
+k_access_key = os.environ.get("K_ACCESS_KEY")
+k_secret_key = os.environ.get("K_SECRET_KEY")
+
+
+def translate_by_volcengine_api(source_language, target_language, original_text):
+    source_language_code = get_language_code(source_language)
+    target_language_code = get_language_code(target_language)
+
+    k_service_info = ServiceInfo(
+        'translate.volcengineapi.com',
+        {'Content-Type': 'application/json'},
+        Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'),
+        5,
+        5
+    )
+    k_query = {
+        'Action': 'TranslateText',
+        'Version': '2020-06-01'
+    }
+    k_api_info = {
+        'translate': ApiInfo('POST', '/', k_query, {}, {})
+    }
+    service = Service(k_service_info, k_api_info)
+    body = {
+        'TargetLanguage': target_language_code,
+        'TextList': [original_text],
+    }
+    res = service.json('translate', {}, json.dumps(body))
+    print(res)
+    translated_dict = json.loads(res)
+    translated_text = translated_dict["TranslationList"][0]["Translation"]
+
+    return translated_text

utils/translate/translate_zhipuai.py

@@ -0,0 +1,33 @@
+import os
+from zhipuai import ZhipuAI
+from dotenv import load_dotenv
+
+from utils.prompts.translation_prompt import generate_translation_prompt
+from utils.utils.other_utils import extract_content_from_response
+
+load_dotenv()
+openai_api_key = os.environ.get("OPENAI_API_KEY")
+baichuan_api_key = os.environ.get("BAICHUAN_API_KEY")
+baichuan_secret_key = os.environ.get("BAICHUAN_SECRET_KEY")
+hkbu_chatgpt_api_key = os.environ.get("HKBU_CHATGPT_API_KEY")
+google_api_key = os.environ.get("GOOGLE_API_KEY")
+zhipuai_api_key = os.environ.get("ZHIPUAI_API_KEY")
+
+
+def translate_by_zhipuai_api(source_language, target_language, original_text, tone_of_voice, industry, model_name="glm-3-turbo"):
+    # Prompt to provide translation
+    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
+    # Translate by accessing ZhipuAI API
+    chat = ZhipuAI(api_key=zhipuai_api_key)
+    res = chat.chat.completions.create(
+        model=model_name,
+        messages=[
+            {"role": "user", "content": translation_prompt}
+        ],
+        temperature=0.7
+    )
+    res_content = res.choices[0].message.content
+    print(res_content)
+    rationale, translated_text = extract_content_from_response(target_language, res_content)
+
+    return translation_sample, translated_text

utils.py → utils/utils/other_utils.py

@@ -1,31 +1,7 @@
-# utils.py
-import os
-import json
 import re
-import deepl
-from volcengine.ApiInfo import ApiInfo
-from volcengine.Credentials import Credentials
-from volcengine.ServiceInfo import ServiceInfo
-from volcengine.base.Service import Service
-from langchain_community.chat_models import ChatOpenAI, ChatBaichuan
-from langchain.schema import HumanMessage, SystemMessage
-from langchain_google_genai import ChatGoogleGenerativeAI
-from zhipuai import ZhipuAI
-from dotenv import load_dotenv
-import requests
-
-load_dotenv()
-deepl_api_key = os.environ.get("DEEPL_API_KEY")
-k_access_key = os.environ.get("K_ACCESS_KEY")
-k_secret_key = os.environ.get("K_SECRET_KEY")
-openai_api_key = os.environ.get("OPENAI_API_KEY")
-baichuan_api_key = os.environ.get("BAICHUAN_API_KEY")
-baichuan_secret_key = os.environ.get("BAICHUAN_SECRET_KEY")
-hkbu_chatgpt_api_key = os.environ.get("HKBU_CHATGPT_API_KEY")
-google_api_key = os.environ.get("GOOGLE_API_KEY")
-zhipuai_api_key = os.environ.get("ZHIPUAI_API_KEY")
 
 
+# Get the language code from the language name
 def get_language_code(language_name):
     language_mapping = {
         "Chinese": "zh",
@@ -167,85 +143,7 @@ def get_language_code(language_name):
     return language_mapping.get(language_name, "Unknown Language Code")
 
 
-def translate_by_deepl_api(source_language, target_language, original_text):
-    target_language_code = get_language_code(target_language).upper()
-    deepl_client = deepl.Translator(deepl_api_key)
-    translated_text = deepl_client.translate_text(original_text, target_lang=target_language_code)
-
-    return translated_text.text
-
-
-def translate_by_volcengine_api(source_language, target_language, original_text):
-    source_language_code = get_language_code(source_language)
-    target_language_code = get_language_code(target_language)
-
-    k_service_info = ServiceInfo(
-        'translate.volcengineapi.com',
-        {'Content-Type': 'application/json'},
-        Credentials(k_access_key, k_secret_key, 'translate', 'cn-north-1'),
-        5,
-        5
-    )
-    k_query = {
-        'Action': 'TranslateText',
-        'Version': '2020-06-01'
-    }
-    k_api_info = {
-        'translate': ApiInfo('POST', '/', k_query, {}, {})
-    }
-    service = Service(k_service_info, k_api_info)
-    body = {
-        'TargetLanguage': target_language_code,
-        'TextList': [original_text],
-    }
-    res = service.json('translate', {}, json.dumps(body))
-    print(res)
-    translated_dict = json.loads(res)
-    translated_text = translated_dict["TranslationList"][0]["Translation"]
-
-    return translated_text
-
-
-# Translation prompt
-def generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry):
-    languages_should_use_deepl = ["Chinese", "English (UK)", "English (US)", "French", "German", "Spanish",
-                                  "Portuguese (Brazilian)", "Portuguese (European)", "Italian", "Dutch", "Polish",
-                                  "Russian"]
-    # Print the source language, target language
-    print(f"Source language: {source_language}, Language code: {get_language_code(source_language)}, Should use DeepL: {source_language in languages_should_use_deepl}")
-    print(f"Target language: {target_language}, Language code: {get_language_code(target_language)}, Should use DeepL: {target_language in languages_should_use_deepl}")
-    # Generate the translation sample
-    if source_language in languages_should_use_deepl and target_language in languages_should_use_deepl:
-        print("Using DeepL API")
-        translation_sample = translate_by_deepl_api(source_language, target_language, original_text)
-    else:
-        print("Using Volcengine API")
-        translation_sample = translate_by_volcengine_api(source_language, target_language, original_text)
-
-    # Generate the translation prompt
-    translation_prompt = f"""{source_language}:
-```
-{original_text}
-```
-
-{target_language} translation sample:
-```
-{translation_sample}
-```
-
-As a bilingual {source_language}-{target_language} native speaker and seasoned translator, your task is to proofread the {target_language} translation sample for errors based on the {source_language} text above. The translated text should be in the tone of voice of {tone_of_voice.lower()}, and should be suitable for the {industry.lower()} industry. Before providing a proofread version, please provide suggestions for corrections (if any) to the above translation sample.
-
-Your response should be formatted as follows:
-```
-Rationale:
-{target_language} translation (proofread):
-```"""
-
-    print(translation_prompt)
-
-    return translation_sample, translation_prompt
-
-
+# Extract the rationale and translation from the response
 def extract_content_from_response(target_language, response):
     if "(" in target_language and ")" in target_language:
         target_language = target_language.replace("(", "\(")
@@ -263,116 +161,3 @@ def extract_content_from_response(target_language, response):
     translation = translation_match.group(1).strip().strip("```").strip() if translation_match else None
 
     return rationale, translation
-
-
-def translate_by_openai_api(source_language, target_language, original_text, tone_of_voice, industry, model_name="gpt-3.5-turbo-1106"):
-    # Prompt to provide translation
-    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
-    # Translate by accessing OpenAI API
-    chat = ChatOpenAI(temperature=0.7, openai_api_key=openai_api_key, model_name=model_name)
-    res = chat(
-        [
-            HumanMessage(content=translation_prompt)
-        ]
-    )
-    res_content = res.content
-    print(res_content)
-    rationale, translated_text = extract_content_from_response(target_language, res_content)
-
-    return translation_sample, translated_text
-
-
-def translate_by_baichuan_api(source_language, target_language, original_text, tone_of_voice, industry):
-    # Prompt to provide translation
-    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
-    # Translate by accessing Baichuan API
-    chat = ChatBaichuan(temperature=0.7, baichuan_api_key=baichuan_api_key, baichuan_secret_key=baichuan_secret_key, model='Baichuan2')
-    res = chat(
-        [
-            HumanMessage(content=translation_prompt)
-        ]
-    )
-    res_content = res.content
-    print(res_content)
-    rationale, translated_text = extract_content_from_response(target_language, res_content)
-
-    return translation_sample, translated_text
-
-
-def call_hkbu_chatgpt_api(conversation_list, model_name="gpt-35-turbo-16k", temperature=0.7):
-    basic_url = "https://chatgpt.hkbu.edu.hk/general/rest"
-    api_version = "2023-08-01-preview"
-    if model_name == "gpt-35-turbo-16k":
-        api_version = "2023-08-01-preview"
-    elif model_name == "gpt-4-turbo":
-        api_version = "2023-12-01-preview"
-    url = basic_url + "/deployments/" + model_name + "/chat/completions/?api-version=" + api_version
-    headers = {'Content-Type': 'application/json', 'api-key': hkbu_chatgpt_api_key}
-    payload = {'messages': conversation_list, 'temperature': temperature}
-
-    try:
-        response = requests.post(url, json=payload, headers=headers)
-
-        if response.status_code == 200:
-            data = response.json()
-            return data
-        else:
-            return 'Error', response.status_code, response.text
-    except requests.RequestException as e:
-        return 'Error:', e
-
-
-def translate_by_hkbu_chatgpt_api(source_language, target_language, original_text, tone_of_voice, industry, model_name="gpt-35-turbo-16k"):
-    # Prompt to provide translation
-    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
-    res = ""
-    try:
-        # Translate by accessing HKBU ChatGPT API
-        res = call_hkbu_chatgpt_api(
-            conversation_list=[
-                {"role": "user", "content": translation_prompt}
-            ],
-            model_name=model_name,
-            temperature=0.7
-        )
-        res_content = res["choices"][0]["message"]["content"]
-    except Exception as e:
-        res_content = 'Error:', e, res
-        return res_content
-
-    print(res_content)
-    rationale, translated_text = extract_content_from_response(target_language, res_content)
-
-    return translation_sample, translated_text
-
-
-def translate_by_google_api(source_language, target_language, original_text, tone_of_voice, industry):
-    # Prompt to provide translation
-    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
-    # Translate by accessing Google API
-    chat = ChatGoogleGenerativeAI(temperature=0.7, model="gemini-pro")
-    res = chat.invoke(translation_prompt)
-    res_content = res.content
-    print(res_content)
-    rationale, translated_text = extract_content_from_response(target_language, res_content)
-
-    return translation_sample, translated_text
-
-
-def translate_by_zhipuai_api(source_language, target_language, original_text, tone_of_voice, industry, model_name="glm-3-turbo"):
-    # Prompt to provide translation
-    translation_sample, translation_prompt = generate_translation_prompt(source_language, target_language, original_text, tone_of_voice, industry)
-    # Translate by accessing ZhipuAI API
-    chat = ZhipuAI(api_key=zhipuai_api_key)
-    res = chat.chat.completions.create(
-        model=model_name,
-        messages=[
-            {"role": "user", "content": translation_prompt}
-        ],
-        temperature=0.7
-    )
-    res_content = res.choices[0].message.content
-    print(res_content)
-    rationale, translated_text = extract_content_from_response(target_language, res_content)
-
-    return translation_sample, translated_text