Update app.py

app.py

@@ -5,8 +5,7 @@ import torch
 import spaces
 import json
 import re
-from langdetect import detect, LangDetectException
-from googletrans import Translator
+import deepl
 
 # Load the processor and model
 processor = AutoProcessor.from_pretrained(
@@ -96,52 +95,76 @@ def decode_unicode_sequences(unicode_seq):
 
 def is_mandarin(text):
     """
-    Detects if the given text is in Mandarin.
+    Detects if the given text is in Mandarin using Unicode ranges.
 
     Args:
         text (str): The text to check.
 
     Returns:
-        bool: True if the text is detected as Mandarin, False otherwise.
+        bool: True if the text contains Chinese characters, False otherwise.
     """
-    try:
-        lang = detect(text)
-        return lang == 'zh-cn' or lang == 'zh-tw' or lang == 'zh'
-    except LangDetectException:
-        return False
+    # Chinese Unicode ranges
+    for char in text:
+        if '\u4e00' <= char <= '\u9fff':
+            return True
+    return False
 
-def translate_to_english(text, translator):
+def translate_to_english_deepl(text, api_key):
     """
-    Translates the given Mandarin text to English.
+    Translates Mandarin text to English using DeepL API.
 
     Args:
         text (str): The Mandarin text to translate.
-        translator (Translator): An instance of googletrans Translator.
+        api_key (str): Your DeepL API authentication key.
 
     Returns:
         str: The translated English text.
     """
+    url = "https://api.deepl.com/v2/translate"
+    params = {
+        "auth_key": api_key,
+        "text": text,
+        "source_lang": "ZH",
+        "target_lang": "EN"
+    }
+    
+    # try:
+    #     response = requests.post(url, data=params)
+    #     response.raise_for_status()
+    #     result = response.json()
+    #     return result['translations'][0]['text']
+    # except requests.exceptions.RequestException as e:
+    #     print(f"DeepL Translation error: {e}")
+    #     return text  # Return the original text if translation fails
+
+    # auth_key = api_key  # Replace with your key
+    # translator = deepl.Translator(auth_key)
+
+    # result = translator.translate_text("Hello, world!", target_lang="FR")
+    # print(result.text)  # "Bonjour, le monde !"
+
     try:
-        translation = translator.translate(text, src='zh-cn', dest='en')
-        return translation.text
-    except Exception as e:
-        print(f"Translation error: {e}")
+        auth_key = api_key  # Replace with your key
+        translator = deepl.Translator(auth_key)
+        result = translator.translate_text(text, source_lang="ZH", target_lang="EN-US")
+        # print(result.text)
+        return result.text
+    except requests.exceptions.RequestException as e:
+        print(f"DeepL Translation error: {e}")
         return text  # Return the original text if translation fails
 
-def process_text_for_mandarin_unicode(input_string):
+def process_text_deepl(input_string, api_key):
     """
     Processes the input string to find Unicode escape sequences representing Mandarin words,
-    translates them to English, and replaces them accordingly.
+    translates them to English using DeepL, and replaces them accordingly.
 
     Args:
         input_string (str): The original string containing Unicode escape sequences.
+        api_key (str): Your DeepL API authentication key.
 
     Returns:
         str: The processed string with translations where applicable.
     """
-    # Initialize the translator
-    translator = Translator()
-    
     # Regular expression to find groups of consecutive \uXXXX sequences
     unicode_word_pattern = re.compile(r'(?:\\u[0-9a-fA-F]{4})+')
     
@@ -151,7 +174,7 @@ def process_text_for_mandarin_unicode(input_string):
         decoded_word = decode_unicode_sequences(unicode_seq)
         
         if is_mandarin(decoded_word):
-            translated = translate_to_english(decoded_word, translator)
+            translated = translate_to_english_deepl(decoded_word, api_key)
             return f"{translated} ({decoded_word})"
         else:
             # If not Mandarin, return the original sequence
@@ -183,7 +206,7 @@ def process_image_and_text(image, text):
     generated_tokens = output[0, inputs['input_ids'].size(1):]
     generated_text = processor.tokenizer.decode(generated_tokens, skip_special_tokens=True)
     generated_text_w_json_wrapper = wrap_json_in_markdown(generated_text)
-    generated_text_w_unicode_mdn = process_text_for_mandarin_unicode(generated_text_w_json_wrapper)
+    generated_text_w_unicode_mdn = process_text_deepl(generated_text_w_json_wrapper, "a5b1749b-7112-4c2d-81a3-33ea18478bb4:fx")
     
     return generated_text_w_unicode_mdn