AshenClock commited on
Commit
1e0b53f
·
verified ·
1 Parent(s): 93230f4

Update app.py

Browse files
Files changed (1) hide show
  1. app.py +59 -31
app.py CHANGED
@@ -487,6 +487,7 @@ def assistant_endpoint(req: AssistantRequest):
487
  # STEP 2: Esecuzione della query, se disponibile
488
  # -----------------------------------------------------------------------
489
  results = []
 
490
  if generated_query:
491
  logger.debug(f"[assistant_endpoint] Esecuzione della query SPARQL:\n{generated_query}")
492
  explanation_dict['sparql_execution'] = "Esecuzione query SPARQL."
@@ -513,6 +514,16 @@ def assistant_endpoint(req: AssistantRequest):
513
  f"{idx+1}) " + ", ".join(f"{var}={row[var]}" for var in row.labels)
514
  for idx, row in enumerate(results)
515
  )
 
 
 
 
 
 
 
 
 
 
516
  second_prompt = (
517
  f"{system_prompt_guide}\n\n"
518
  f"Domanda utente: {user_message}\n"
@@ -550,8 +561,8 @@ def assistant_endpoint(req: AssistantRequest):
550
  {"role": "system", "content": second_prompt},
551
  {"role": "user", "content": "Fornisci la risposta finale."}
552
  ],
553
- max_tokens=1024,
554
- temperature=0.8
555
  )
556
  final_answer = final_output["choices"][0]["message"]["content"].strip()
557
  logger.info(f"[assistant_endpoint] Risposta finale generata: {final_answer}")
@@ -574,7 +585,8 @@ def assistant_endpoint(req: AssistantRequest):
574
  return {
575
  "query": generated_query,
576
  "response": final_ans,
577
- "explanation": explanation_dict
 
578
  }
579
  # ---------------------------------------------------------------------------
580
  # ENDPOINT DI TEST / HOME
@@ -595,19 +607,29 @@ def home():
595
  def query_stanze_endpoint():
596
  """
597
  Endpoint per restituire le stanze con le opere esposte e relativi punti.
598
- La query restituisce, per ogni triple, la stanza, l'opera e il valore della proprietà
599
- progettoMuseo:posizioneOpera (facoltativo). Successivamente, in Python, si raggruppa
600
- per stanza in un dizionario. Per ogni stanza, viene creata una lista di dizionari,
601
- dove ogni dizionario rappresenta un'opera e contiene:
602
- - "nome": il localName dell'opera (la parte dopo il simbolo "#")
603
- - "punto": il valore della proprietà progettoMuseo:posizioneOpera (se presente, altrimenti una stringa vuota)
604
 
605
- Query usata (in una riga):
606
- PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
607
- SELECT ?stanza ?opera ?p
608
- WHERE {
609
- ?opera progettoMuseo:èEsposto ?stanza.
610
- OPTIONAL { ?opera progettoMuseo:posizioneOpera ?p. }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
611
  }
612
  """
613
  # Definiamo la query in una singola riga
@@ -621,7 +643,7 @@ def query_stanze_endpoint():
621
  corrected_query = correct_sparql_syntax_advanced(query_str)
622
  logger.debug(f"[query_stanze_endpoint] Query corretta:\n{corrected_query}")
623
 
624
- # Verifichiamo la validità della query utilizzando il parser di rdflib
625
  if not is_sparql_query_valid(corrected_query):
626
  logger.error("[query_stanze_endpoint] Query SPARQL non valida.")
627
  raise HTTPException(status_code=400, detail="Query SPARQL non valida.")
@@ -629,37 +651,44 @@ def query_stanze_endpoint():
629
  try:
630
  query_result = ontology_graph.query(corrected_query)
631
 
632
- # Costruiamo un dizionario: per ogni stanza (localName), una lista di dizionari
633
- # con chiavi "nome" (localName dell'opera) e "punto" (valore di progettoMuseo:posizioneOpera)
634
- dict_stanze = {}
635
  for row in query_result:
636
- # Estraiamo il localName della stanza
637
  stanza_uri = str(row["stanza"])
638
  stanza_local = stanza_uri.split("#")[-1].strip() if "#" in stanza_uri else stanza_uri
639
 
640
- # Estraiamo il localName dell'opera
641
  opera_uri = str(row["opera"])
642
  opera_local = opera_uri.split("#")[-1].strip() if "#" in opera_uri else opera_uri
643
 
644
- # Estraiamo il punto (se presente)
645
  punto = str(row["p"]) if row["p"] is not None else ""
646
 
647
- # Costruiamo il dizionario per l'opera
648
  opera_dict = {"nome": opera_local, "punto": punto}
649
 
650
- # Raggruppiamo per stanza
651
- if stanza_local not in dict_stanze:
652
- dict_stanze[stanza_local] = []
653
- dict_stanze[stanza_local].append(opera_dict)
 
 
 
 
 
 
654
 
655
- logger.info(f"[query_stanze_endpoint] Trovate {len(dict_stanze)} stanze.")
656
  except Exception as ex:
657
  logger.error(f"[query_stanze_endpoint] Errore nell'esecuzione della query: {ex}")
658
  raise HTTPException(status_code=500, detail="Errore nell'esecuzione della query SPARQL.")
659
 
 
660
  return {
661
- "stanze": dict_stanze
662
  }
 
663
  # ---------------------------------------------------------------------------
664
  # MAIN
665
  # ---------------------------------------------------------------------------
@@ -668,5 +697,4 @@ if __name__ == "__main__":
668
  Avvio dell'applicazione FastAPI sulla porta 8000,
669
  utile se eseguito come script principale.
670
  """
671
- logger.info("Avvio dell'applicazione FastAPI.")
672
- uvicorn.run(app, host="0.0.0.0", port=8000)
 
487
  # STEP 2: Esecuzione della query, se disponibile
488
  # -----------------------------------------------------------------------
489
  results = []
490
+ point = "" # variabile per contenere il punto (inizialmente nessuno)
491
  if generated_query:
492
  logger.debug(f"[assistant_endpoint] Esecuzione della query SPARQL:\n{generated_query}")
493
  explanation_dict['sparql_execution'] = "Esecuzione query SPARQL."
 
514
  f"{idx+1}) " + ", ".join(f"{var}={row[var]}" for var in row.labels)
515
  for idx, row in enumerate(results)
516
  )
517
+ # Estraiamo il primo punto valido (se presente)
518
+ for row in results:
519
+ # Verifica se la riga contiene la variabile "p" e ha un valore non vuoto
520
+ if "p" in row.labels and row["p"] is not None and str(row["p"]).strip() != "":
521
+ point = str(row["p"]).strip()
522
+ break # Esci dal ciclo non appena trovi il primo punto valido
523
+ # Se "p" non è presente, controlla la variabile "posizione"
524
+ elif "posizione" in row.labels and row["posizione"] is not None and str(row["posizione"]).strip() != "":
525
+ point = str(row["posizione"]).strip()
526
+ break # Esci dal ciclo se trovi il primo punto valido
527
  second_prompt = (
528
  f"{system_prompt_guide}\n\n"
529
  f"Domanda utente: {user_message}\n"
 
561
  {"role": "system", "content": second_prompt},
562
  {"role": "user", "content": "Fornisci la risposta finale."}
563
  ],
564
+ max_tokens=512,
565
+ temperature=0.5
566
  )
567
  final_answer = final_output["choices"][0]["message"]["content"].strip()
568
  logger.info(f"[assistant_endpoint] Risposta finale generata: {final_answer}")
 
585
  return {
586
  "query": generated_query,
587
  "response": final_ans,
588
+ "explanation": explanation_dict,
589
+ "point": point
590
  }
591
  # ---------------------------------------------------------------------------
592
  # ENDPOINT DI TEST / HOME
 
607
  def query_stanze_endpoint():
608
  """
609
  Endpoint per restituire le stanze con le opere esposte e relativi punti.
 
 
 
 
 
 
610
 
611
+ La query utilizza la seguente struttura di output:
612
+
613
+ {
614
+ "stanze": [
615
+ {
616
+ "roomName": "stanzaGrecia",
617
+ "entries": [
618
+ { "nome": "AfroditeDiMilo", "punto": "(-1.171, 0, -0.004)" },
619
+ { "nome": "Discobolo", "punto": "(0, 0, 0.77)" },
620
+ ...
621
+ ]
622
+ },
623
+ {
624
+ "roomName": "stanzaItalia",
625
+ "entries": [
626
+ { "nome": "AmoreEPsiche", "punto": "(0.677, 0, 0)" },
627
+ { "nome": "David", "punto": "(0.586, 0, -0.1)" },
628
+ ...
629
+ ]
630
+ },
631
+ ...
632
+ ]
633
  }
634
  """
635
  # Definiamo la query in una singola riga
 
643
  corrected_query = correct_sparql_syntax_advanced(query_str)
644
  logger.debug(f"[query_stanze_endpoint] Query corretta:\n{corrected_query}")
645
 
646
+ # Verifica che la query sia sintatticamente corretta
647
  if not is_sparql_query_valid(corrected_query):
648
  logger.error("[query_stanze_endpoint] Query SPARQL non valida.")
649
  raise HTTPException(status_code=400, detail="Query SPARQL non valida.")
 
651
  try:
652
  query_result = ontology_graph.query(corrected_query)
653
 
654
+ # Costruiamo un dizionario temporaneo per raggruppare le entry per stanza
655
+ temp_dict = {}
 
656
  for row in query_result:
657
+ # Estrazione del localName della stanza
658
  stanza_uri = str(row["stanza"])
659
  stanza_local = stanza_uri.split("#")[-1].strip() if "#" in stanza_uri else stanza_uri
660
 
661
+ # Estrazione del localName dell'opera
662
  opera_uri = str(row["opera"])
663
  opera_local = opera_uri.split("#")[-1].strip() if "#" in opera_uri else opera_uri
664
 
665
+ # Estrazione del punto (se presente)
666
  punto = str(row["p"]) if row["p"] is not None else ""
667
 
668
+ # Crea il dizionario per l'opera
669
  opera_dict = {"nome": opera_local, "punto": punto}
670
 
671
+ # Raggruppa le entry per stanza
672
+ if stanza_local not in temp_dict:
673
+ temp_dict[stanza_local] = []
674
+ temp_dict[stanza_local].append(opera_dict)
675
+
676
+ # Trasforma il dizionario in un array che segue la struttura richiesta:
677
+ # ogni elemento dell'array è un oggetto con i campi "roomName" e "entries"
678
+ stanze_list = []
679
+ for room_name, entries in temp_dict.items():
680
+ stanze_list.append({"roomName": room_name, "entries": entries})
681
 
682
+ logger.info(f"[query_stanze_endpoint] Trovate {len(stanze_list)} stanze.")
683
  except Exception as ex:
684
  logger.error(f"[query_stanze_endpoint] Errore nell'esecuzione della query: {ex}")
685
  raise HTTPException(status_code=500, detail="Errore nell'esecuzione della query SPARQL.")
686
 
687
+ # Restituisce il JSON seguendo la struttura attesa dal modello C#
688
  return {
689
+ "stanze": stanze_list
690
  }
691
+
692
  # ---------------------------------------------------------------------------
693
  # MAIN
694
  # ---------------------------------------------------------------------------
 
697
  Avvio dell'applicazione FastAPI sulla porta 8000,
698
  utile se eseguito come script principale.
699
  """
700
+ logger.info("Avvio dell'applicazione FastAPI.")