Update app.py

app.py

@@ -7,7 +7,14 @@ from huggingface_hub import InferenceClient
 from typing import Optional
 
 # Configurazione logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("app.log"),
+        logging.StreamHandler()
+    ]
+)
 logger = logging.getLogger(__name__)
 
 # Configurazione API Hugging Face
@@ -29,6 +36,7 @@ def load_rdf_summary():
     Carica un riassunto dell'ontologia dal file RDF.
     Estrae le classi e le proprietà presenti nell'ontologia.
     """
+    logger.info("Inizio caricamento del file RDF.")
     if not os.path.exists(RDF_FILE):
         logger.error("Nessun file RDF trovato.")
         return "Nessun file RDF trovato."
@@ -47,13 +55,15 @@ def load_rdf_summary():
 
         class_summary = "\n".join([f"- Classe: {cls}" for cls in classes])
         prop_summary  = "\n".join([f"- Proprietà: {prop}" for prop in properties])
-        return f"Classi:\n{class_summary}\n\nProprietà:\n{prop_summary}"
+        summary = f"Classi:\n{class_summary}\n\nProprietà:\n{prop_summary}"
+        logger.info("Caricamento RDF completato con successo.")
+        return summary
     except Exception as e:
         logger.error(f"Errore durante il parsing del file RDF: {e}")
         return "Errore nel caricamento del file RDF."
 
 rdf_context = load_rdf_summary()
-logger.info("RDF Summary: %s", rdf_context)
+logger.info(f"RDF Summary:\n{rdf_context}")
 
 ####################################
 # Validazione SPARQL
@@ -62,10 +72,12 @@ def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
     """
     Verifica la validità della query SPARQL.
     """
+    logger.info("Inizio validazione della query SPARQL.")
     g = Graph()
     try:
         g.parse(rdf_file_path, format="xml")
         g.query(query)  # Solleva un'eccezione se la query non è valida
+        logger.info("Validazione della query SPARQL riuscita.")
         return True
     except Exception as e:
         logger.error(f"Errore durante la validazione della query SPARQL: {e}")
@@ -121,6 +133,7 @@ async def call_model(messages, temperature=0.7, max_tokens=2048):
     """
     Chiama il modello di linguaggio naturale con i messaggi forniti.
     """
+    logger.info("Chiamata al modello iniziata.")
     try:
         response = client.chat.completions.create(
             model="Qwen/Qwen2.5-72B-Instruct",
@@ -131,10 +144,11 @@ async def call_model(messages, temperature=0.7, max_tokens=2048):
             stream=False
         )
         raw_text = response["choices"][0]["message"]["content"]
+        logger.info(f"Risposta del modello ricevuta: {raw_text}")
         # Rimuoviamo eventuali newline per forzare la singola riga
         return raw_text.replace("\n", " ").strip()
     except Exception as e:
-        logger.error(f"Errore nel modello: {e}")
+        logger.error(f"Errore durante la chiamata al modello: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 ####################################
@@ -144,11 +158,14 @@ async def interpret_sparql_results(results):
     """
     Invia i risultati delle query SPARQL al modello per ottenere una risposta naturale.
     """
+    logger.info("Inizio interpretazione dei risultati SPARQL.")
     if not results:
+        logger.info("Nessun risultato trovato per la query SPARQL.")
         return "Mi dispiace, non sono riuscita a trovare le informazioni che stavi cercando."
     
     # Converti i risultati in una stringa leggibile
     results_str = "\n".join([", ".join([f"{k}: {v}" for k, v in row.asdict().items()]) for row in results])
+    logger.debug(f"Risultati SPARQL:\n{results_str}")
     
     # Crea un prompt per il modello per interpretare i risultati
     interpret_prompt = f"""
@@ -157,13 +174,15 @@ Mi hai fornito i seguenti risultati di una query SPARQL:
 
 Per favore, interpreta questi risultati e fornisci una risposta naturale ed enfatica come farebbe una guida museale femminile.
 """
-
+    
     messages = [
         {"role": "system", "content": interpret_prompt},
         {"role": "user", "content": ""}
     ]
     
+    logger.info("Invio dei risultati SPARQL al modello per l'interpretazione.")
     natural_response = await call_model(messages, temperature=0.7, max_tokens=2048)
+    logger.info(f"Risposta interpretata ricevuta dal modello: {natural_response}")
     return natural_response
 
 ####################################
@@ -179,7 +198,8 @@ class QueryRequest(BaseModel):
 @app.post("/generate-response/")
 async def generate_response(request: QueryRequest):
     user_msg = request.message
-
+    logger.info(f"Ricevuta richiesta: {user_msg}")
+    
     # 1) Generazione della risposta (SPARQL, INTERPRET o CHAT)
     system_msg = create_system_message(rdf_context)
     messages = [
@@ -187,35 +207,43 @@ async def generate_response(request: QueryRequest):
         {"role": "user", "content": user_msg}
     ]
     response_text = await call_model(messages, request.temperature, request.max_tokens)
+    
     logger.info(f"Risposta generata dal modello: {response_text}")
-
+    
     # 2) Determinazione se la risposta è una query SPARQL
     if response_text.startswith("PREFIX base:"):
         sparql_query = response_text
+        logger.info("La risposta è stata identificata come una query SPARQL.")
         # Validazione della query SPARQL
         if validate_sparql_query(sparql_query, RDF_FILE):
+            logger.info("La query SPARQL è valida. Inizio esecuzione della query.")
             # Esegui la query su GraphDB
             try:
                 g = Graph()
                 g.parse(RDF_FILE, format="xml")
                 results = g.query(sparql_query)
+                logger.info(f"Query SPARQL eseguita con successo. Numero di risultati: {len(results)}")
                 # Interpreta i risultati in una risposta naturale tramite il modello
                 interpreted_response = await interpret_sparql_results(results)
+                logger.info(f"Risposta naturale interpretata: {interpreted_response}")
                 return {"type": "NATURAL", "response": interpreted_response}
             except Exception as e:
                 logger.error(f"Errore durante l'esecuzione della query SPARQL: {e}")
                 return {"type": "ERROR", "response": "Mi dispiace, c'è stato un errore nell'esecuzione della tua richiesta."}
         else:
+            logger.warning("La query SPARQL generata non è valida.")
             return {"type": "ERROR", "response": "La query SPARQL generata non è valida. Per favore, riprova con una domanda diversa."}
     
     elif "Non posso generare una query SPARQL" in response_text:
         # Risposta di errore dal modello
+        logger.warning("Il modello ha risposto con un messaggio di errore.")
         return {"type": "ERROR", "response": response_text}
     
     else:
         # Presumiamo che sia una risposta naturale o una chat
+        logger.info("La risposta è stata identificata come una risposta naturale o di chat.")
         return {"type": "NATURAL", "response": response_text}
 
 @app.get("/")
 async def root():
-    return {"message": "Server attivo e pronto a generare risposte!"}
+    return {"message": "Server attivo e pronto a generare risposte!"}