Update app.py

app.py

@@ -3,6 +3,11 @@ from fastapi import FastAPI, HTTPException
 from huggingface_hub import InferenceClient
 from rdflib import Graph
 from pydantic import BaseModel
+import logging
+
+# 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")
@@ -14,36 +19,39 @@ RDF_FILE = "Ontologia.rdf"
 # Carica un riassunto del file RDF
 def load_rdf_summary():
     if os.path.exists(RDF_FILE):
-        g = Graph()
-        g.parse(RDF_FILE, format="xml")
-
-        classes = set()
-        properties = set()
-
-        for s, _, o in g.triples((None, None, None)):
-            if "Class" in str(o) or "rdfs:Class" in str(o):
-                classes.add(s)
-            if "Property" in str(o):
-                properties.add(s)
-
-        classes_summary = "\n".join([f"- Classe: {cls}" for cls in classes])
-        properties_summary = "\n".join([f"- Proprietà: {prop}" for prop in properties])
-        return f"Classi:\n{classes_summary}\n\nProprietà:\n{properties_summary}"
+        try:
+            g = Graph()
+            g.parse(RDF_FILE, format="xml")
+
+            classes = set()
+            properties = set()
+
+            for s, _, o in g.triples((None, None, None)):
+                if "Class" in str(o) or "rdfs:Class" in str(o):
+                    classes.add(s)
+                if "Property" in str(o):
+                    properties.add(s)
+
+            classes_summary = "\n".join([f"- Classe: {cls}" for cls in classes])
+            properties_summary = "\n".join([f"- Proprietà: {prop}" for prop in properties])
+            return f"Classi:\n{classes_summary}\n\nProprietà:\n{properties_summary}"
+        except Exception as e:
+            logger.error(f"Errore durante il parsing del file RDF: {e}")
+            return "Errore nel caricamento del file RDF."
     return "Nessun dato RDF trovato."
 
 rdf_context = load_rdf_summary()
-print("RDF Summary:", rdf_context)  # Debug
+logger.info("RDF Summary: %s", rdf_context)
 
 # Valida le query SPARQL
 def validate_sparql_query(query, rdf_file_path):
     try:
         g = Graph()
-        # Caricamento del file RDF dal percorso
         g.parse(rdf_file_path, format="xml")
         g.query(query)  # Prova ad eseguire la query
         return True
     except Exception as e:
-        print(f"Errore durante la validazione della query SPARQL: {e}")
+        logger.error(f"Errore durante la validazione della query SPARQL: {e}")
         return False
 
 # FastAPI app
@@ -70,8 +78,8 @@ Il tuo compito:
 
 async def generate_response(message, max_tokens, temperature):
     system_message = create_system_message(rdf_context)
-    print("System Message:", system_message)  # Debug
-    print("User Message:", message)  # Debug
+    logger.debug("System Message: %s", system_message)
+    logger.info("User Message: %s", message)
 
     messages = [
         {"role": "system", "content": system_message},
@@ -85,20 +93,21 @@ async def generate_response(message, max_tokens, temperature):
             temperature=temperature,
             max_tokens=max_tokens,
             top_p=0.7,
-            stream=False
+            stream=False,
+            timeout=60  # Aumenta il timeout
         )
-        print("Raw Response:", response)  # Debug risposta grezza
+        logger.info("Raw Response: %s", response)
         return response['choices'][0]['message']['content'].replace("\n", " ").strip()
     except Exception as e:
-        print(f"Errore nell'elaborazione: {str(e)}")
+        logger.error(f"Errore nell'elaborazione: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Errore nell'elaborazione: {str(e)}")
 
 # Endpoint per generare query SPARQL
 @app.post("/generate-query/")
 async def generate_query(request: QueryRequest):
     response = await generate_response(request.message, request.max_tokens, request.temperature)
-    print("Risposta generata dal modello:", response)  # Debug
-    
+    logger.info("Risposta generata dal modello: %s", response)
+
     if not (response.startswith("SELECT") or response.startswith("ASK")):
         return {
             "query": None,
@@ -116,4 +125,4 @@ async def generate_query(request: QueryRequest):
 # Endpoint di test
 @app.get("/")
 async def root():
-    return {"message": "Il server è attivo e pronto a generare query SPARQL!"}
+    return {"message": "Il server è attivo e pronto a generare query SPARQL!"}