Update app.py

app.py

@@ -8,11 +8,11 @@ from typing import Optional
 
 # Configurazione logging
 logging.basicConfig(
-    level=logging.DEBUG,  # Livello di log aumentato per più dettagli
+    level=logging.DEBUG,  # Livello di log aumentato per maggiori dettagli
     format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[
-        logging.FileHandler("app.log"),
-        logging.StreamHandler()
+        logging.FileHandler("app.log"),  # Log su file
+        logging.StreamHandler()          # Log su console
     ]
 )
 logger = logging.getLogger(__name__)
@@ -31,7 +31,7 @@ RDF_FILE = "Ontologia.rdf"
 ####################################
 # Caricamento RDF (riassunto)
 ####################################
-def load_rdf_summary():
+def load_rdf_summary() -> str:
     """
     Carica un riassunto dell'ontologia dal file RDF.
     Estrae le classi e le proprietà presenti nell'ontologia.
@@ -40,21 +40,25 @@ def load_rdf_summary():
     if not os.path.exists(RDF_FILE):
         logger.error("Nessun file RDF trovato.")
         return "Nessun file RDF trovato."
+
     try:
         g = Graph()
         g.parse(RDF_FILE, format="xml")
-        
+
         # Estrazione semplificata di classi e proprietà
         classes = set()
         properties = set()
         for s, p, o in g.triples((None, None, None)):
+            # Se l'oggetto è 'Class', lo aggiungiamo a classes
             if "Class" in str(o):
                 classes.add(s)
+            # Se l'oggetto è 'Property', lo aggiungiamo a properties
             if "Property" in str(o):
                 properties.add(s)
 
         class_summary = "\n".join([f"- Classe: {cls}" for cls in classes])
         prop_summary  = "\n".join([f"- Proprietà: {prop}" for prop in properties])
+
         summary = f"Classi:\n{class_summary}\n\nProprietà:\n{prop_summary}"
         logger.info("Caricamento RDF completato con successo.")
         return summary
@@ -89,10 +93,14 @@ def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
 def create_system_message(rdf_context: str) -> str:
     """
     Crea il messaggio di sistema per il modello di linguaggio naturale.
+    NOTA: Cambiato il prefisso per riflettere la tua ontologia 'progettoMuseo#'.
     """
     return f"""
-Sei un'assistente esperta nella generazione di query SPARQL basate su un'ontologia RDF, nell'interpretazione dei risultati delle query SPARQL in risposte naturali, e nel fare chatting minimale con i visitatori in diverse lingue (ad esempio, italiano, francese, inglese). In base alla domanda dell'utente, devi decidere se:
-    
+Sei un'assistente esperta nella generazione di query SPARQL basate su un'ontologia RDF,
+nell'interpretazione dei risultati delle query SPARQL in risposte naturali, e
+nel fare chatting minimale con i visitatori in diverse lingue (ad esempio, italiano, francese, inglese).
+
+In base alla domanda dell'utente, devi decidere se:
 1. Generare una query SPARQL per interrogare la base di conoscenza.
 2. Fornire una risposta naturale basata sui risultati di una query SPARQL.
 3. Rispondere con una risposta di chat minimale nella stessa lingua dell'utente.
@@ -105,39 +113,43 @@ Regole TASSATIVE:
 2. Se la domanda richiede l'interpretazione di risultati SPARQL, restituisci una risposta naturale basata sui risultati.
 3. Se la domanda è una chat minimale, restituisci una risposta di chat nella stessa lingua dell'utente.
 4. DEVI usare ESCLUSIVAMENTE questo prefisso di base (e NON modificarlo in nessun modo):
-   PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/>
+   PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
 5. NON generare alcun altro prefisso o URI inventato.
-6. Se non puoi rispondere con una query SPARQL valida, interpretare i risultati o fare chatting, scrivi:
+6. Se non puoi rispondere con una query SPARQL valida, interpretare i risultati
+   o fare chatting, scrivi:
    "Non posso generare una query SPARQL, interpretare i risultati o fare una risposta di chat per questa richiesta."
 
 Esempi:
 - Domanda: "Quali sono le statue esposte del periodo medievale?"
   Risposta:
-  PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/> SELECT ?statua WHERE {{ ?statua a base:Statua . ?statua base:Periodo_Storico "Medioevo" . }}
-  
+  PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
+  SELECT ?statua WHERE {{ ?statua a base:Statua . ?statua base:periodoStoricoOpera "Medioevo" . }}
+
 - Domanda: "La query ha restituito 5 statue. Puoi descriverle?"
   Risposta:
   Ecco le 5 statue medievali trovate: Statua1, Statua2, Statua3, Statua4, Statua5.
-  
+
 - Domanda: "Ciao!"
   Risposta:
   Ciao! Benvenuto al nostro museo. Come posso aiutarti oggi?
-  
+
 - Domanda: "Bonjour! Comment ça va?"
   Risposta:
   Bonjour! Bienvenue dans notre musée. Comment puis-je vous aider aujourd'hui?
-  
+
 - Domanda: "Qual è la tua opinione sull'arte moderna?"
   Risposta:
   L'arte moderna è un'espressione affascinante e varia che riflette le dinamiche sociali e culturali contemporanee.
-  
+
 - Domanda: "How does this installation work?"
   Risposta:
-  This interactive installation allows you to explore various artworks through digital interactions. Simply approach and follow the on-screen instructions.
-  
+  This interactive installation allows you to explore various artworks through digital interactions.
+  Simply approach and follow the on-screen instructions.
+
 - Domanda: "Come funziona questa installazione?"
   Risposta:
-  Questa installazione interattiva ti permette di esplorare diverse opere d'arte attraverso interazioni digitali. Basta avvicinarti e seguire le istruzioni sullo schermo.
+  Questa installazione interattiva ti permette di esplorare diverse opere d'arte attraverso interazioni digitali.
+  Basta avvicinarti e seguire le istruzioni sullo schermo.
 
 RISPONDI ESCLUSIVAMENTE CON IL FORMATO SPECIFICATO.
 """
@@ -178,24 +190,27 @@ async def interpret_sparql_results(results):
     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])
+    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"""
 Mi hai fornito i seguenti risultati di una query SPARQL:
 {results_str}
 
-Per favore, interpreta questi risultati e fornisci una risposta naturale ed enfatica come farebbe una guida museale femminile.
+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}")
@@ -223,40 +238,48 @@ 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:
+                # Esegui la query su RDF
                 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."}
+                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."}
-    
+            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
+        # Presumiamo che sia una risposta naturale o di chat
         logger.info("La risposta è stata identificata come una risposta naturale o di chat.")
         return {"type": "NATURAL", "response": response_text}