Fixes1

src/utils/data_processor.py

@@ -86,10 +86,10 @@ class TranslationService:
     
     def __init__(self):
         self.api_token = self._get_hf_token()
-        # Using Helsinki-NLP model - better Inference API support for Hindi→English
-        self.translation_model = "Helsinki-NLP/opus-mt-hi-en"
+        # Using AI4Bharat IndicTrans2 - specialized for Indian languages
+        self.translation_model = "ai4bharat/indictrans2-en-indic-1.3B"
         self.base_url = "https://router.huggingface.co"
-        logger.info("Initialized HF Inference API for translation")
+        logger.info("Initialized HF Inference API for translation (IndicTrans2)")
     
     def _get_hf_token(self) -> Optional[str]:
         """Get HF token from environment or Streamlit secrets."""
@@ -109,31 +109,37 @@ class TranslationService:
     def _call_hf_translation_api(self, text: str, source_lang: str = "hi", target_lang: str = "en") -> str:
         """Call HF Translation API with fallback."""
         if not self.api_token:
-            logger.warning("No API token, skipping translation")
+            logger.debug("No API token, skipping translation")
             return text
         
         try:
             headers = {"Authorization": f"Bearer {self.api_token}"}
-            # New router API format: /models/{model_id}
-            url = f"{self.base_url}/models/{self.translation_model}"
+            # Try using serverless inference endpoint
+            url = f"https://api-inference.huggingface.co/models/{self.translation_model}"
             
-            # Simplified payload for Helsinki-NLP models
+            # IndicTrans2 requires simple input format
             payload = {"inputs": text}
             
-            response = requests.post(url, headers=headers, json=payload, timeout=30)
+            response = requests.post(url, headers=headers, json=payload, timeout=10)
             
             if response.status_code == 200:
                 result = response.json()
-                # Helsinki models return: [{"translation_text": "..."}]
+                # IndicTrans2 returns: [{"translation_text": "..."}] or {"generated_text": "..."}
                 if isinstance(result, list) and len(result) > 0:
-                    return result[0].get("translation_text", text)
+                    translated = result[0].get("translation_text", "") or result[0].get("generated_text", "")
+                    if translated:
+                        return translated
+                elif isinstance(result, dict):
+                    translated = result.get("generated_text", "") or result.get("translation_text", "")
+                    if translated:
+                        return translated
             
-            # Enhanced error logging
-            logger.warning(f"Translation API failed: {response.status_code} - {response.text[:200]}")
+            # Silently fallback to original text (translation is optional)
+            logger.debug(f"Translation unavailable, using original text (status: {response.status_code})")
             return text
             
         except Exception as e:
-            logger.error(f"Translation error: {str(e)}")
+            logger.debug(f"Translation skipped: {str(e)}")
             return text
     
     def detect_language(self, text: str) -> str: