Update app.py

app.py

@@ -16,7 +16,7 @@ logging.basicConfig(
     handlers=[logging.FileHandler("app.log"), logging.StreamHandler()]
 )
 logger = logging.getLogger(__name__)
-explanation_dict = {}
+
 # ---------------------------------------------------------------------------
 # COSTANTI / CHIAVI / MODELLI
 # ---------------------------------------------------------------------------
@@ -214,27 +214,22 @@ def classify_and_translate(question_text: str, model_answer_text: str):
     try:
         question_lang_result = lang_detect_client.text_classification(text=question_text)
         question_lang = question_lang_result[0]['label']
-        explanation_dict['language_detection'] = f"Domanda in: {question_lang}."
         logger.info(f"[LangDetect] Lingua della domanda: {question_lang}")
     except Exception as e:
         logger.error(f"Errore nel rilevamento della lingua della domanda: {e}")
         question_lang = "en"  # Fallback se non riusciamo a rilevare la lingua
-        explanation_dict['language_detection'] = "Lingua domanda non rilevata, impostata a 'en'."
     # Rileva la lingua della risposta
     try:
         answer_lang_result = lang_detect_client.text_classification(text=model_answer_text)
         answer_lang = answer_lang_result[0]['label']
-        explanation_dict['language_detection'] += f" Risposta in: {answer_lang}."
         logger.info(f"[LangDetect] Lingua della risposta: {answer_lang}")
     except Exception as e:
         logger.error(f"Errore nel rilevamento della lingua della risposta: {e}")
         answer_lang = "it"  # Fallback se non riusciamo a rilevare la lingua
-        explanation_dict['language_detection'] += " Lingua risposta non rilevata, impostata a 'it'."
 
     # Se domanda e risposta sono nella stessa lingua, non traduciamo
     if question_lang == answer_lang:
         logger.info("[Translate] Nessuna traduzione necessaria: stessa lingua.")
-        explanation_dict['translation'] = "Nessuna traduzione necessaria."
         return model_answer_text
 
     # Altrimenti, costruiamo "al volo" il modello di traduzione appropriato 
@@ -244,17 +239,13 @@ def classify_and_translate(question_text: str, model_answer_text: str):
         token=HF_API_KEY,
         model=translator_model
     )
-    explanation_dict['translation'] = f"Usato modello: {translator_model}."
     # Traduzione della risposta
     try:
         translation_result = translator_client.translation(text=model_answer_text)
         translated_answer = translation_result["translation_text"]
-        explanation_dict['translation'] += " Traduzione riuscita."
     except Exception as e:
         logger.error(f"Errore nella traduzione {answer_lang} -> {question_lang}: {e}")
-        explanation_dict['translation'] += " Traduzione fallita, risposta originale usata."
         # Se fallisce, restituiamo la risposta originale come fallback
-        explanation_dict['translation'] = "Errore inizializzazione traduttore."
         translated_answer = model_answer_text
 
     return translated_answer
@@ -357,7 +348,6 @@ def is_sparql_query_valid(query: str) -> bool:
 # ---------------------------------------------------------------------------
 @app.post("/assistant")
 def assistant_endpoint(req: AssistantRequest):
-    explanation_dict = {}
     """
     Endpoint che gestisce l'intera pipeline:
      1) Genera una query SPARQL dal messaggio dell'utente (prompt dedicato).
@@ -391,19 +381,15 @@ def assistant_endpoint(req: AssistantRequest):
         # Serializziamo l'ontologia in XML per fornirla al prompt (anche se si chiama 'turtle' va bene così).
         ontology_turtle = ontology_graph.serialize(format="xml")
         logger.debug("Ontologia serializzata con successo (XML).")
-        explanation_dict['ontology'] = "Ontologia serializzata."
     except Exception as e:
         logger.warning(f"Impossibile serializzare l'ontologia in formato XML: {e}")
-        explanation_dict['ontology'] = f"Errore serializzazione: {e}."
         ontology_turtle = ""
 
     # Creiamo il prompt di sistema per la generazione SPARQL
     system_prompt_sparql = create_system_prompt_for_sparql(ontology_turtle)
-    explanation_dict['sparql_prompt'] = "Prompt SPARQL creato."
     # Chiamata al modello per generare la query SPARQL
     try:
         logger.debug("[assistant_endpoint] Chiamata HF per generare la query SPARQL...")
-        explanation_dict['sparql_generation'] = "Generazione query SPARQL iniziata."
         gen_sparql_output = hf_generation_client.chat.completions.create(
             messages=[
                 {"role": "system", "content": system_prompt_sparql},
@@ -414,10 +400,8 @@ def assistant_endpoint(req: AssistantRequest):
         )
         possible_query = gen_sparql_output["choices"][0]["message"]["content"].strip()
         logger.info(f"[assistant_endpoint] Query generata dal modello: {possible_query}")
-        explanation_dict['sparql_generation'] += f" Query: {possible_query}."
     except Exception as ex:
         logger.error(f"Errore nella generazione della query SPARQL: {ex}")
-        explanation_dict['sparql_generation'] = f"Errore generazione SPARQL: {ex}."
         # Se fallisce la generazione, consideriamo la query come "NO_SPARQL"
         possible_query = "NO_SPARQL"
 
@@ -428,15 +412,12 @@ def assistant_endpoint(req: AssistantRequest):
     else:
         # Applichiamo la correzione avanzata
         advanced_corrected = correct_sparql_syntax_advanced(possible_query)
-        explanation_dict['sparql_correction'] = "Sintassi SPARQL corretta."
         # Verifichiamo la validità della query
         if is_sparql_query_valid(advanced_corrected):
             generated_query = advanced_corrected
             logger.debug(f"[assistant_endpoint] Query SPARQL valida dopo correzione avanzata: {generated_query}")
-            explanation_dict['sparql_validation'] = "Query SPARQL valida."
         else:
             logger.debug("[assistant_endpoint] Query SPARQL non valida. Verrà ignorata.")
-            explanation_dict['sparql_validation'] = "Query SPARQL non valida."
             generated_query = None
 
     # -----------------------------------------------------------------------
@@ -446,23 +427,17 @@ def assistant_endpoint(req: AssistantRequest):
     point = ""  # variabile per contenere il punto (inizialmente nessuno)
     if generated_query:
         logger.debug(f"[assistant_endpoint] Esecuzione della query SPARQL:\n{generated_query}")
-        explanation_dict['sparql_execution'] = "Esecuzione query SPARQL."
         try:
             query_result = ontology_graph.query(generated_query)
             results = list(query_result)
             logger.info(f"[assistant_endpoint] Query eseguita con successo. Numero risultati = {len(results)}")
-            explanation_dict['sparql_execution'] += f" Risultati: {len(results)}."
         except Exception as ex:
             logger.error(f"[assistant_endpoint] Errore nell'esecuzione della query: {ex}")
-            explanation_dict['sparql_execution'] = f"Errore esecuzione: {ex}."
             results = []
-    else:
-        explanation_dict['sparql_execution'] = "Nessuna query eseguita."
     # -----------------------------------------------------------------------
     # STEP 3: Generazione della risposta finale stile "guida museale"
     # -----------------------------------------------------------------------
     system_prompt_guide = create_system_prompt_for_guide()
-    explanation_dict['guide_prompt'] = "Prompt guida museale creato."
     if generated_query and results:
         # Caso: query generata + risultati SPARQL
         # Convertiamo i risultati in una stringa più leggibile
@@ -488,7 +463,6 @@ def assistant_endpoint(req: AssistantRequest):
             "Rispondi in modo breve (max ~50 parole)."
         )
         logger.debug("[assistant_endpoint] Prompt di risposta con risultati SPARQL.")
-        explanation_dict['guide_prompt'] += " Inclusi risultati SPARQL."
     elif generated_query and not results:
         # Caso: query valida ma 0 risultati
         second_prompt = (
@@ -498,7 +472,6 @@ def assistant_endpoint(req: AssistantRequest):
             "Nessun risultato dalla query. Prova comunque a rispondere con le tue conoscenze."
         )
         logger.debug("[assistant_endpoint] Prompt di risposta: query valida ma senza risultati.")
-        explanation_dict['guide_prompt'] += " Query valida senza risultati."
     else:
         # Caso: nessuna query generata
         second_prompt = (
@@ -507,11 +480,9 @@ def assistant_endpoint(req: AssistantRequest):
             "Nessuna query SPARQL generata. Rispondi come puoi, riarrangiando le tue conoscenze."
         )
         logger.debug("[assistant_endpoint] Prompt di risposta: nessuna query generata.")
-        explanation_dict['guide_prompt'] += " Nessuna query generata."
     # Chiamata finale al modello per la risposta "guida museale"
     try:
         logger.debug("[assistant_endpoint] Chiamata HF per generare la risposta finale...")
-        explanation_dict['response_generation'] = "Generazione risposta finale iniziata."
         final_output = hf_generation_client.chat.completions.create(
             messages=[
                 {"role": "system", "content": second_prompt},
@@ -522,10 +493,8 @@ def assistant_endpoint(req: AssistantRequest):
         )
         final_answer = final_output["choices"][0]["message"]["content"].strip()
         logger.info(f"[assistant_endpoint] Risposta finale generata: {final_answer}")
-        explanation_dict['response_generation'] += " Risposta generata."
     except Exception as ex:
         logger.error(f"Errore nella generazione della risposta finale: {ex}")
-        explanation_dict['response_generation'] = f"Errore generazione risposta finale: {ex}."
         raise HTTPException(status_code=500, detail="Errore nella generazione della risposta in linguaggio naturale.")
 
     # -----------------------------------------------------------------------
@@ -533,7 +502,6 @@ def assistant_endpoint(req: AssistantRequest):
     # -----------------------------------------------------------------------
     final_ans = classify_and_translate(user_message, final_answer)
     final_ans = final_ans.replace('\\"', "").replace('\"', "")
-    explanation_dict['translation_completion'] = "Traduzione completata."
     # -----------------------------------------------------------------------
     # Restituzione in formato JSON
     # -----------------------------------------------------------------------
@@ -541,7 +509,6 @@ def assistant_endpoint(req: AssistantRequest):
     return {
         "query": generated_query,
         "response": final_ans,
-        "explanation": explanation_dict,
         "point": point
     }
 # ---------------------------------------------------------------------------