Update app.py

app.py

@@ -203,10 +203,11 @@ FINE ONTOLOGIA.
 
 def classify_and_translate(question_text: str, model_answer_text: str):
     """
-    Classifica la lingua della domanda e della risposta, quindi traduce la risposta
-    se la lingua è diversa da quella della domanda. L'idea è di restituire una 
-    risposta nella stessa lingua dell'utente.
+    Classifica la lingua della domanda e della risposta, poi traduce la risposta
+    solo se la lingua della risposta è diversa da quella della domanda.
+    Tutta la logica (helper, provider check, fallback) è contenuta qui dentro.
     """
+    # --- Helper interni -----------------------------------------------------
     def _extract_label(res):
         # Compat: [ {label,score} ] | [ [ {label,score}, ... ] ] | oggetti con .label
         try:
@@ -219,51 +220,74 @@ def classify_and_translate(question_text: str, model_answer_text: str):
         except Exception:
             return None
 
-    # Rilevamento lingua domanda
+    def _ensure_lang_client():
+        """
+        Restituisce un client di language detection con provider garantito.
+        Usa il globale lang_detect_client se ha il provider, altrimenti ne crea uno locale.
+        Richiede che HF_API_KEY e LANG_DETECT_MODEL siano definiti globalmente.
+        """
+        try:
+            prov = getattr(lang_detect_client, "provider", None)
+            if prov:
+                return lang_detect_client
+        except NameError:
+            # lang_detect_client non definito: creo un client locale
+            pass
+        # Creo un client locale con provider forzato
+        local_client = InferenceClient(
+            token=HF_API_KEY,
+            model=LANG_DETECT_MODEL,
+            provider="hf-inference",
+        )
+        return local_client
+
+    # --- Rilevamento lingua -------------------------------------------------
+    ld_client = _ensure_lang_client()
+
     try:
-        question_lang_result = lang_detect_client.text_classification(question_text)  # posizionale
-        question_lang = _extract_label(question_lang_result)
-        logger.info(f"[LangDetect] Lingua della domanda: {question_lang}")
+        q_res = ld_client.text_classification(question_text)  # argomento posizionale
+        question_lang = _extract_label(q_res)
+        logger.info(f"[LangDetect] Domanda: {question_lang}")
     except Exception:
         logger.exception("Errore nel rilevamento della lingua della domanda")
         question_lang = None  # fallback prudente
 
-    # Rilevamento lingua risposta
     try:
-        answer_lang_result = lang_detect_client.text_classification(model_answer_text)  # posizionale
-        answer_lang = _extract_label(answer_lang_result)
-        logger.info(f"[LangDetect] Lingua della risposta: {answer_lang}")
+        a_res = ld_client.text_classification(model_answer_text)  # argomento posizionale
+        answer_lang = _extract_label(a_res)
+        logger.info(f"[LangDetect] Risposta: {answer_lang}")
     except Exception:
         logger.exception("Errore nel rilevamento della lingua della risposta")
         answer_lang = None  # fallback prudente
 
-    # Se detection fallisce o le lingue coincidono: non tradurre
+    # --- Policy di traduzione (fallback prudente) ---------------------------
     if not question_lang or not answer_lang or question_lang == answer_lang:
         logger.info("[Translate] Niente traduzione (lingue uguali o detection fallita).")
         return model_answer_text
 
-    # Traduzione (provider esplicito)
+    # --- Traduzione ---------------------------------------------------------
     translator_model = f"{TRANSLATOR_MODEL_PREFIX}-{answer_lang}-{question_lang}"
-    translator_client = InferenceClient(
+    tr_client = InferenceClient(
         token=HF_API_KEY,
         model=translator_model,
         provider="hf-inference",
     )
     try:
-        translation_result = translator_client.translation(model_answer_text)  # posizionale
-        if isinstance(translation_result, dict):
-            translated_answer = translation_result.get("translation_text") or model_answer_text
-        elif hasattr(translation_result, "translation_text"):
-            translated_answer = translation_result.translation_text or model_answer_text
-        elif isinstance(translation_result, str):
-            translated_answer = translation_result
+        t_res = tr_client.translation(model_answer_text)  # argomento posizionale
+        if isinstance(t_res, dict):
+            translated = t_res.get("translation_text") or model_answer_text
+        elif hasattr(t_res, "translation_text"):
+            translated = getattr(t_res, "translation_text") or model_answer_text
+        elif isinstance(t_res, str):
+            translated = t_res
         else:
-            translated_answer = model_answer_text
+            translated = model_answer_text
     except Exception:
         logger.exception(f"Errore nella traduzione {answer_lang} -> {question_lang}")
-        translated_answer = model_answer_text
+        translated = model_answer_text
+
+    return translated
 
-    return translated_answer