app.py

import json
import os
from pathlib import Path
from huggingface_hub import InferenceClient
from rdflib import Graph
from pydantic import BaseModel
from fastapi import FastAPI, HTTPException
import logging

logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

API_KEY = os.getenv("HF_API_KEY")
client = InferenceClient(api_key=API_KEY)

RDF_FILE = "Ontologia.rdf"

# Funzione di validazione
def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
    g = Graph()
    try:
        g.parse(rdf_file_path, format="xml")
        g.query(query)  # Se c'è un 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"
def create_system_message(rdf_context: str) -> str:
    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}

Regole tassative:
1. La query DEV'ESSERE in una sola riga.
2. Usa SEMPRE il prefisso base: se l'ontologia è <http://example.org/onto#>, dovrai scrivere:
   PREFIX base: <http://example.org/onto#> SELECT ...
   TUTTO su un'unica riga, senza andare a capo.
3. Se vuoi filtrare per classe, usa: ?entity a base:NomeClasse .
4. Se vuoi usare una proprietà, usa: ?entity base:NomeProprieta ?altra .
5. NON usare URI lunghe senza parentesi angolate e non inventare prefissi.
6. Se la query non rispetta la sintassi SPARQL, verrà rifiutata.

OBIETTIVO:
- Genera una query SPARQL sintatticamente e semanticamente valida rispetto alle classi e proprietà riportate.
- Se non puoi rispondere, dì: "Non posso generare una query SPARQL per questa richiesta."
"""

# Prompt di sistema "correttivo" per la seconda iterazione
def create_correction_message(rdf_context: str, errore: str) -> str:
    return f"""
La query che hai fornito è risultata NON valida:
{errore}

Ricorda le regole tassative e ritenta la generazione di UNA SOLA query SPARQL valida in una riga.
Riproponila corretta, sempre rispettando il prefisso base: e la sintassi di SELECT/ASK.
"""

# Funzione per chiamare il modello su Hugging Face
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"]
        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."

app = FastAPI()
rdf_context = load_rdf_summary()

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 = [
        {"role": "system", "content": system_msg},
        {"role": "user", "content": user_msg},
    ]
    response1 = await call_model(messages, 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)."}
    
    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
        ]
        response2 = await call_model(messages2, 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)."}
        
        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 per generare query SPARQL"}