Update app.py

app.py

@@ -4,56 +4,115 @@ import langdetect
 import logging
 import os
 
+# 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
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Peta model untuk setiap bahasa yang didukung
 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",
-    "zh": "Helsinki-NLP/opus-mt-zh-en",  # Satu entri untuk Mandarin (Sederhana dan Tradisional)
+    # Entri tunggal untuk Mandarin, kita akan normalisasi deteksi bahasanya
+    "zh": "Helsinki-NLP/opus-mt-zh-en",
     "vi": "Helsinki-NLP/opus-mt-vi-en",
 }
 
 translators = {}
 try:
+    # Inisialisasi semua model saat aplikasi dimulai
     for lang, model_name in MODEL_MAP.items():
-        logger.info(f"Loading model for {lang}...")
+        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")
+        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)}")
 
+---
+
+## Fungsi Deteksi Bahasa yang Ditingkatkan
+
+Ini adalah bagian kunci perbaikannya. Kita akan **normalisasi kode bahasa Mandarin** yang mungkin dideteksi oleh `langdetect`.
+
+```python
 def detect_language(text: str) -> str:
     try:
-        lang = langdetect.detect(text)
-        return lang if lang in MODEL_MAP else "en"
+        detected_lang = langdetect.detect(text)
+        logger.info(f"langdetect detected: '{detected_lang}' for text: '{text[:50]}...'") # Log deteksi awal
+
+        # 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'):
+            return 'zh'
+
+        # Jika bahasa terdeteksi ada di MODEL_MAP, gunakan itu.
+        # Jika tidak, default ke 'en' (bahasa Inggris).
+        return detected_lang if detected_lang in MODEL_MAP else "en"
     except Exception as e:
-        logger.warning(f"Language detection failed: {str(e)}, defaulting to English")
+        logger.warning(f"Language detection failed for text: '{text[:50]}...' Error: {str(e)}. Defaulting to English.")
         return "en"
 
+---
+
+## Endpoint API untuk Terjemahan
+
+```python
 @app.post("/translate")
 async def translate(text: str):
+    """
+    Menerima teks dan mengembalikannya dalam bahasa Inggris.
+    Secara otomatis mendeteksi bahasa sumber.
+    """
     if not text:
-        raise HTTPException(status_code=400, detail="Text input is required")
+        raise HTTPException(status_code=400, detail="Text input is required.")
+
     try:
+        # Deteksi bahasa sumber dari teks
         source_lang = detect_language(text)
-        logger.info(f"Detected source language: {source_lang}")
+        logger.info(f"Determined source language: '{source_lang}' for translation.")
+
+        # Jika bahasa sumber sudah Bahasa Inggris, kembalikan teks aslinya
         if source_lang == "en":
+            logger.info("Source language is English, returning original text.")
             return {"translated_text": text}
+
+        # Dapatkan translator yang sesuai dari kamus translators
         translator = translators.get(source_lang)
+
+        # Jika tidak ada translator yang mendukung bahasa yang terdeteksi
         if not translator:
-            raise HTTPException(status_code=400, detail=f"Translation not supported for language: {source_lang}")
+            logger.error(f"No translator found for language: '{source_lang}'.")
+            raise HTTPException(
+                status_code=400,
+                detail=f"Translation not supported for language: {source_lang}."
+            )
+
+        # Lakukan terjemahan
+        logger.info(f"Translating from {source_lang}...")
         result = translator(text)
-        return {"translated_text": result[0]["translation_text"]}
+        translated_text = result[0]["translation_text"]
+        logger.info(f"Translation successful. Original: '{text[:50]}...', Translated: '{translated_text[:50]}...'")
+
+        return {"translated_text": translated_text}
+    except HTTPException as e:
+        # Tangani HTTPExceptions yang sudah kita definisikan sebelumnya
+        raise e
     except Exception as e:
-        logger.error(f"Processing failed: {str(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)}")