Delete prova.py

prova.py

@@ -1,211 +0,0 @@
-import os
-import logging
-from rdflib import Graph
-from pydantic import BaseModel
-from fastapi import FastAPI, HTTPException
-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"
-
-####################################
-# 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'è 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 molto stringente
-####################################
-def create_system_message(rdf_context: str) -> str:
-    """
-    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.
-Ecco un riassunto dell'ontologia su cui devi lavorare:
-{rdf_context}
-
-DI SEGUITO LE REGOLE TASSATIVE:
-1. 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/>
-2. La query deve stare in UNA SOLA RIGA, senza andare a capo.
-3. La query deve INIZIARE con:
-   PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/> SELECT
-   oppure
-   PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/> ASK
-4. Se devi indicare una classe, usa: ?qualcosa a base:NomeClasse .
-5. Se devi indicare una proprietà, usa: ?s base:NomeProprieta ?o .
-6. NON generare alcun altro prefisso.
-7. NON utilizzare URI lunghe senza < > e NON inventare prefissi o risorse inesistenti.
-8. Se non puoi rispondere con una query SPARQL valida secondo questi criteri, scrivi:
-   "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
-
-RISPONDI ESCLUSIVAMENTE CON LA QUERY O IL MESSAGGIO DI IMPOSSIBILITA'.
-"""
-
-####################################
-# 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(
-            model="Qwen/Qwen2.5-72B-Instruct",
-            messages=messages,
-            temperature=temperature,
-            max_tokens=max_tokens,
-            top_p=0.7,
-            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))
-
-####################################
-# FastAPI
-####################################
-app = FastAPI()
-
-class QueryRequest(BaseModel):
-    message: str
-    max_tokens: int = 2048
-    temperature: float = 0.7
-
-@app.post("/generate-query/")
-async def generate_query(request: QueryRequest):
-    # 1) Prima iterazione
-    system_msg = create_system_message(rdf_context)
-    user_msg = request.message
-    
-    messages_first = [
-        {"role": "system", "content": system_msg},
-        {"role": "user", "content": user_msg}
-    ]
-    response1 = await call_model(messages_first, request.temperature, request.max_tokens)
-    logger.info(f"[Prima iterazione] Risposta generata dal modello: {response1}")
-
-    # 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):
-        return {"query": response1, "explanation": "Query valida alla prima iterazione."}
-    else:
-        # 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(messages_second, request.temperature, request.max_tokens)
-        logger.info(f"[Seconda iterazione] Risposta generata dal modello: {response2}")
-
-        # 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:
-            return {
-                "query": None,
-                "explanation": "Anche la seconda iterazione ha prodotto una query non valida. Interrompo."
-            }
-
-@app.get("/")
-async def root():
-    return {"message": "Server attivo e pronto a generare query SPARQL!"}