Update app.py

Update protected Terms

app.py

@@ -3,62 +3,49 @@ from transformers import pipeline
 import langdetect
 import logging
 import os
-from typing import Optional # Import Optional untuk parameter di FastAPI
+from typing import Optional
 
 # Set environment variables for Hugging Face cache
-# Ini penting agar model di-cache di lokasi yang benar di dalam container Hugging Face Space
 os.environ["HF_HOME"] = "/app/cache"
 os.environ["TRANSFORMERS_CACHE"] = "/app/cache"
 
 app = FastAPI()
 
-# Konfigurasi logging untuk melihat pesan debug di log Space kamu
+# Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Peta model untuk setiap bahasa yang didukung
+# Map of supported language models
 MODEL_MAP = {
     "id": "Helsinki-NLP/opus-mt-id-en",
     "th": "Helsinki-NLP/opus-mt-th-en",
     "fr": "Helsinki-NLP/opus-mt-fr-en",
     "es": "Helsinki-NLP/opus-mt-es-en",
     "ja": "Helsinki-NLP/opus-mt-ja-en",
-    # Entri tunggal untuk Mandarin, kita akan normalisasi deteksi bahasanya
     "zh": "Helsinki-NLP/opus-mt-zh-en",
     "vi": "Helsinki-NLP/opus-mt-vi-en",
 }
 
+# List of terms to protect from translation
+PROTECTED_TERMS = ["2030 Aspirations"]
+
 translators = {}
 try:
-    # Inisialisasi semua model saat aplikasi dimulai
     for lang, model_name in MODEL_MAP.items():
         logger.info(f"Loading model for {lang} from {model_name}...")
-        # Pastikan kita menggunakan device="cpu" atau "cuda" jika GPU tersedia
-        # Untuk Hugging Face Space gratis biasanya CPU, jadi lebih aman tidak specify device
         translators[lang] = pipeline("translation", model=model_name)
         logger.info(f"Model for {lang} loaded successfully.")
 except Exception as e:
-    # Tangani kegagalan inisialisasi model
     logger.error(f"Model initialization failed: {str(e)}")
-    # Hentikan aplikasi jika model gagal dimuat, karena aplikasi tidak akan berfungsi
     raise Exception(f"Model initialization failed: {str(e)}")
 
-
 def detect_language(text: str) -> str:
     try:
         detected_lang = langdetect.detect(text)
-        # Log ini SANGAT PENTING untuk debugging! Ini menunjukkan hasil mentah dari langdetect.
         logger.info(f"langdetect raw result: '{detected_lang}' for text: '{text[:50]}...'")
-
-        # Normalisasi untuk bahasa Mandarin:
-        # Jika langdetect mengembalikan 'zh-cn', 'zh-tw', 'zh-hk', dll.,
-        # kita paksa menjadi 'zh' agar sesuai dengan kunci di MODEL_MAP.
         if detected_lang.startswith('zh'):
             logger.info(f"Normalizing '{detected_lang}' to 'zh' for Mandarin.")
             return 'zh'
-
-        # Jika bahasa terdeteksi ada di MODEL_MAP, gunakan itu.
-        # Jika tidak, default ke 'en' (bahasa Inggris).
         final_lang = detected_lang if detected_lang in MODEL_MAP else "en"
         logger.info(f"Final determined language: '{final_lang}'. (Based on raw detected: '{detected_lang}')")
         return final_lang
@@ -66,18 +53,39 @@ def detect_language(text: str) -> str:
         logger.warning(f"Language detection FAILED for text: '{text[:50]}...'. Error: {str(e)}. Defaulting to English.")
         return "en"
 
+def protect_terms(text: str, protected_terms: list) -> tuple[str, dict]:
+    """
+    Replace protected terms with placeholders to prevent translation.
+    Returns the modified text and a dictionary mapping placeholders to original terms.
+    """
+    modified_text = text
+    replacements = {}
+    for i, term in enumerate(protected_terms):
+        placeholder = f"__PROTECTED_{i}__"
+        replacements[placeholder] = term
+        modified_text = modified_text.replace(term, placeholder)
+    return modified_text, replacements
+
+def restore_terms(text: str, replacements: dict) -> str:
+    """
+    Restore protected terms in the translated text using the replacements dictionary.
+    """
+    restored_text = text
+    for placeholder, term in replacements.items():
+        restored_text = restored_text.replace(placeholder, term)
+    return restored_text
 
 @app.post("/translate")
 async def translate(text: str, source_lang_override: Optional[str] = None):
     """
-    Menerima teks dan mengembalikannya dalam bahasa Inggris.
-    Secara otomatis mendeteksi bahasa sumber, atau bisa di-override oleh pengguna.
+    Translate text to English, preserving protected terms like '2030 Aspirations'.
+    Automatically detects source language or uses override.
     """
     if not text:
         raise HTTPException(status_code=400, detail="Text input is required.")
 
     try:
-        # Tentukan bahasa sumber: gunakan override jika diberikan dan valid, kalau tidak, deteksi otomatis.
+        # Determine source language
         if source_lang_override and source_lang_override in MODEL_MAP:
             source_lang = source_lang_override
             logger.info(f"Source language overridden by user to: '{source_lang_override}'.")
@@ -85,15 +93,13 @@ async def translate(text: str, source_lang_override: Optional[str] = None):
             source_lang = detect_language(text)
             logger.info(f"Determined source language for translation: '{source_lang}'.")
 
-        # Jika bahasa sumber sudah Bahasa Inggris, kembalikan teks aslinya
+        # If source language is English, return original text
         if source_lang == "en":
             logger.info("Source language is English or unrecognized, returning original text.")
             return {"translated_text": text}
 
-        # Dapatkan translator yang sesuai dari kamus translators
+        # Get translator
         translator = translators.get(source_lang)
-
-        # Jika tidak ada translator yang mendukung bahasa yang terdeteksi/di-override
         if not translator:
             logger.error(f"No translator found for language: '{source_lang}'.")
             raise HTTPException(
@@ -101,17 +107,23 @@ async def translate(text: str, source_lang_override: Optional[str] = None):
                 detail=f"Translation not supported for language: {source_lang}."
             )
 
-        # Lakukan terjemahan
+        # Protect terms before translation
+        modified_text, replacements = protect_terms(text, PROTECTED_TERMS)
+        logger.info(f"Text after protecting terms: '{modified_text[:50]}...'")
+
+        # Perform translation
         logger.info(f"Translating text from '{source_lang}' to English...")
-        result = translator(text)
+        result = translator(modified_text)
         translated_text = result[0]["translation_text"]
-        logger.info(f"Translation successful. Original: '{text[:50]}...', Translated: '{translated_text[:50]}...'")
+        logger.info(f"Translation successful. Original: '{modified_text[:50]}...', Translated: '{translated_text[:50]}...'")
+
+        # Restore protected terms
+        final_text = restore_terms(translated_text, replacements)
+        logger.info(f"Final translated text with restored terms: '{final_text[:50]}...'")
 
-        return {"translated_text": translated_text}
+        return {"translated_text": final_text}
     except HTTPException as e:
-        # Tangani HTTPExceptions yang sudah kita definisikan sebelumnya
         raise e
     except Exception as e:
-        # Tangani error tak terduga lainnya
         logger.error(f"An unexpected error occurred during processing: {str(e)}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Processing failed: {str(e)}")