Update app.py

app.py

@@ -1,36 +1,81 @@
-import json
 import os
-from pathlib import Path
-from huggingface_hub import InferenceClient
+import logging
 from rdflib import Graph
 from pydantic import BaseModel
 from fastapi import FastAPI, HTTPException
-import logging
+from huggingface_hub import InferenceClient
 
+# Configurazione logging
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
+# Configurazione API Hugging Face
 API_KEY = os.getenv("HF_API_KEY")
 client = InferenceClient(api_key=API_KEY)
 
+# File RDF
 RDF_FILE = "Ontologia.rdf"
 
-# Funzione di validazione
+####################################
+# Caricamento RDF (riassunto)
+####################################
+def load_rdf_summary():
+    """
+    Carica un riassunto dell'ontologia dal file RDF (se necessario).
+    Qui puoi usare parse e scansionare classi e proprietà reali.
+    """
+    if not os.path.exists(RDF_FILE):
+        return "Nessun file RDF trovato."
+    try:
+        g = Graph()
+        g.parse(RDF_FILE, format="xml")
+        
+        # Esempio di estrazione semplificata di classi e proprietà
+        classes = set()
+        properties = set()
+        for s, p, o in g.triples((None, None, None)):
+            if "Class" in str(o):
+                classes.add(s)
+            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])
+        return f"Classi:\n{class_summary}\n\nProprietà:\n{prop_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)
+
+####################################
+# Validazione SPARQL
+####################################
 def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
+    """
+    Esegue il parsing e l'esecuzione di test della query su RDF,
+    per verificare che sia sintatticamente e semanticamente corretta.
+    """
     g = Graph()
     try:
         g.parse(rdf_file_path, format="xml")
-        g.query(query)  # Se c'è un errore di sintassi o referenza, solleva eccezione
+        g.query(query)  # Se c'è errore di sintassi o referenza, solleva eccezione
         return True
     except Exception as e:
         logger.error(f"Errore durante la validazione della query SPARQL: {e}")
         return False
 
-# Prompt di sistema "stringente"
+####################################
+# Prompt di Sistema molto stringente
+####################################
 def create_system_message(rdf_context: str) -> str:
     """
-    Prompt di sistema estremamente rigido, che forza il modello
-    a usare solo il prefisso definito e a generare la query in un'unica riga.
+    Prompt di sistema estremo:
+    - impone l'uso di un SOLO prefisso
+    - vieta righe multiple
+    - vieta di inventare prefissi
+    - obbliga a iniziare con `PREFIX base: ... SELECT` o `ASK`
     """
     return f"""
 Sei un assistente esperto nella generazione di query SPARQL basate su un'ontologia RDF.
@@ -53,13 +98,32 @@ DI SEGUITO LE REGOLE TASSATIVE:
    "Non posso generare una query SPARQL per questa richiesta."
 
 Esempio di query corretta (fittizia) in una sola riga:
-PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/> SELECT ?stanza WHERE { ?stanza a base:Stanza . } LIMIT 10
+PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/> SELECT ?stanza WHERE {{ ?stanza a base:Stanza . }} LIMIT 10
 
-RISPONDI ESCLUSIVAMENTE CON LA QUERY O IL MESSAGGIO DI IMPOSSIBILITA'. 
-NON SCRIVERE NESSUN COMMENTO AGGIUNTIVO.
+RISPONDI ESCLUSIVAMENTE CON LA QUERY O IL MESSAGGIO DI IMPOSSIBILITA'.
 """
-    
-# Funzione per chiamare il modello su Hugging Face
+
+####################################
+# Prompt di "correzione"
+####################################
+def create_correction_message(rdf_context: str, errore: str) -> str:
+    """
+    Questo prompt serve per la seconda iterazione se la query non è valida.
+    Invita a correggere la query e a rispettare le regole.
+    """
+    return f"""
+La query che hai fornito è risultata NON valida per il seguente motivo:
+{errore}
+
+RICORDA LE REGOLE TASSATIVE, in particolare l'uso ESATTO del prefisso:
+PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/>
+Riscrivi la query in UNA SOLA RIGA, rispettando la sintassi SPARQL e usando solo classi e proprietà presenti nell'ontologia.
+Se non riesci, dì: "Non posso generare una query SPARQL per questa richiesta."
+"""
+
+####################################
+# Funzione per chiamare il modello
+####################################
 async def call_model(messages, temperature=0.7, max_tokens=2048):
     try:
         response = client.chat.completions.create(
@@ -71,18 +135,16 @@ async def call_model(messages, temperature=0.7, max_tokens=2048):
             stream=False
         )
         raw_text = response["choices"][0]["message"]["content"]
+        # 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}")
         raise HTTPException(status_code=500, detail=str(e))
 
-# Caricamento di un riassunto dell'ontologia (semplificato per brevità)
-def load_rdf_summary() -> str:
-    # Qui un caricamento minimo o un testo statico
-    return "Classi e proprietà dell'ontologia: base:Stanza, base:Contiene, base:Opera, ecc."
-
+####################################
+# FastAPI
+####################################
 app = FastAPI()
-rdf_context = load_rdf_summary()
 
 class QueryRequest(BaseModel):
     message: str
@@ -94,35 +156,48 @@ async def generate_query(request: QueryRequest):
     # 1) Prima iterazione
     system_msg = create_system_message(rdf_context)
     user_msg = request.message
-    messages = [
+    
+    messages_first = [
         {"role": "system", "content": system_msg},
-        {"role": "user", "content": user_msg},
+        {"role": "user", "content": user_msg}
     ]
-    response1 = await call_model(messages, request.temperature, request.max_tokens)
+    response1 = await call_model(messages_first, request.temperature, request.max_tokens)
     logger.info(f"[Prima iterazione] Risposta generata dal modello: {response1}")
 
-    # 2) Validazione
-    if not (response1.startswith("PREFIX") and ("SELECT" in response1 or "ASK" in response1)):
-        # Fallimento immediato
-        return {"query": None, "explanation": "La query non rispetta le regole base (PREFIX + SELECT/ASK)."}
-    
+    # Controllo se comincia con il prefisso esatto
+    mandated_prefix = "PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/>"
+    if not (response1.startswith(mandated_prefix + " SELECT") or response1.startswith(mandated_prefix + " ASK")):
+        return {
+            "query": None,
+            "explanation": "Il modello non ha usato il prefisso obbligatorio o non ha usato SELECT/ASK."
+        }
+
+    # Verifichiamo se la query è valida
     if validate_sparql_query(response1, RDF_FILE):
-        # Query valida! Restituisco la prima
         return {"query": response1, "explanation": "Query valida alla prima iterazione."}
     else:
-        # 3) Seconda iterazione “correttiva”
-        correction_msg = create_correction_message(rdf_context, "Errore di validazione (prima iterazione).")
-        messages2 = [
-            {"role": "system", "content": system_msg},  # Sistema invariato
-            {"role": "assistant", "content": response1}, # Metti la risposta errata in contesto
-            {"role": "system", "content": correction_msg}, # Istruzione di correzione
+        # 2) Seconda iterazione (correzione)
+        correction_msg = create_correction_message(rdf_context, "Query non valida alla prima iterazione.")
+        # Comunichiamo al modello la query precedente come contesto e chiediamo la correzione
+        messages_second = [
+            {"role": "system", "content": system_msg},          # Prompt di sistema invariato
+            {"role": "assistant", "content": response1},        # La risposta 'errata'
+            {"role": "system", "content": correction_msg}       # Istruzione di correzione
         ]
-        response2 = await call_model(messages2, request.temperature, request.max_tokens)
+        response2 = await call_model(messages_second, request.temperature, request.max_tokens)
         logger.info(f"[Seconda iterazione] Risposta generata dal modello: {response2}")
 
-        if not (response2.startswith("PREFIX") and ("SELECT" in response2 or "ASK" in response2)):
-            return {"query": None, "explanation": "Anche la seconda query non rispetta le regole (PREFIX + SELECT/ASK)."}
-        
+        # Ricontrollo se comincia con il prefisso esatto
+        if not (response2.startswith(mandated_prefix + " SELECT") and not response2.startswith(mandated_prefix + " ASK")):
+            # O se manca la SELECT e l'ASK
+            # Con un piccolo fix: potresti voler controllare sia SELECT che ASK qui
+            if not (response2.startswith(mandated_prefix + " SELECT") or response2.startswith(mandated_prefix + " ASK")):
+                return {
+                    "query": None,
+                    "explanation": "Anche la seconda iterazione non ha usato il prefisso e SELECT/ASK corretti."
+                }
+
+        # Validazione della seconda risposta
         if validate_sparql_query(response2, RDF_FILE):
             return {"query": response2, "explanation": "Query valida alla seconda iterazione (corretta)."}
         else:
@@ -133,5 +208,4 @@ async def generate_query(request: QueryRequest):
 
 @app.get("/")
 async def root():
-    return {"message": "Server attivo per generare query SPARQL"}
-
+    return {"message": "Server attivo e pronto a generare query SPARQL!"}