New design

.gitignore

@@ -0,0 +1 @@
+.venv

app.py

@@ -2,34 +2,35 @@ import os
 import json
 
 import spaces
-import gradio as gr
-import torch
+import gradio
+
+import numpy
+import pandas
+
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
 import pyparseit
 
+import SPARQLWrapper
 
-#model_name = "daniel-dona/sparql-model-era-lora-128-qwen3-4b"
-model_name = "daniel-dona/sparql-model-era-lora-128-qwen3-0.6b"
+MODEL_NAME = os.getenv("MODEL_NAME", "daniel-dona/sparql-model-era-lora-128-qwen3-0.6b")
+SPARQL_ENDPOINT = os.getenv("SPARQL_ENDPOINT", "http://192.168.10.174:8890/sparql")
 
+prompt_valid = open("./templates/prompt_valid.txt").read()
+prompt_sparql = open("./templates/prompt_sparql.txt").read()
 
-print(os.environ)
+system =  open("./templates/system1.txt").read()
 
-print("Cuda?", torch.cuda.is_available())
+examples_data = [[e["query"]] for e in json.loads(open("./examples.json").read())]
 
-prompt_valid = open("/home/user/app/templates/prompt_valid.txt").read()
-prompt_sparql = open("/home/user/app/templates/prompt_sparql.txt").read()
-
-system =  open("/home/user/app/templates/system1.txt").read()
 
 @spaces.GPU
-def generate(messages):
-
+def model_completion(messages):
 
     # load the tokenizer and the model
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
     model = AutoModelForCausalLM.from_pretrained(
-        model_name,
+        MODEL_NAME,
         torch_dtype="auto",
         device_map="auto"
     )
@@ -54,7 +55,53 @@ def generate(messages):
 
     return content
 
-def is_valid(message):
+
+def sparql_json_to_df(sparql_json):
+
+    if 'results' not in sparql_json or 'bindings' not in sparql_json['results']:
+        return pandas.DataFrame()
+
+    cols = []
+
+    for i, var in enumerate(sparql_json['head']['vars']):
+        cols.append(var)
+
+    bindings = sparql_json['results']['bindings']
+
+    if not bindings:
+        return pandas.DataFrame(columns=cols)
+
+    data_rows = [
+        [row.get(col, {}).get('value') for col in sparql_json['head']['vars']]
+        for row in bindings
+    ]
+
+    df = pandas.DataFrame(data_rows, columns=cols)
+
+    df.fillna(value=numpy.nan, inplace=True)
+    df = df.convert_dtypes()
+
+    return df
+
+def execute_sparql(sparql, timeout=60):
+
+    agent = SPARQLWrapper.SPARQLWrapper(endpoint=SPARQL_ENDPOINT)
+            
+    try:
+        agent.setTimeout(timeout)
+        agent.addExtraURITag("timeout",str((timeout-1)*1000))
+        agent.setQuery(sparql)
+        agent.setReturnFormat(SPARQLWrapper.JSON)
+        results = agent.queryAndConvert()
+
+        return sparql_json_to_df(results)
+
+    except Exception as e:
+        print(e)
+        print("Error during SPARQL execution")
+
+
+def check_valid_nlq(message):
 
     valid = False
 
@@ -68,7 +115,7 @@ def is_valid(message):
 
     messages.append({"role": "user", "content": prompt})
 
-    generation = generate(messages)
+    generation = model_completion(messages)
 
     print("Generated:", generation)
 
@@ -84,7 +131,7 @@ def is_valid(message):
     
     return valid
 
-def gen_sparql(message):
+def generate_sparql(message):
 
     sparql = "```sparql\n[code]```"
 
@@ -98,7 +145,7 @@ def gen_sparql(message):
 
     messages.append({"role": "user", "content": prompt})
 
-    generation = generate(messages)
+    generation = model_completion(messages)
 
     print("Generated:", generation)
 
@@ -107,33 +154,65 @@ def gen_sparql(message):
     if len(blocks) >= 1:
 
         try:
-            sparql = f"```sparql\n{blocks[-1].content}\n```" # Último bloque
+            sparql = blocks[-1].content
 
         except Exception as e:
             print(e)
     
     return sparql
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-):
 
-    if is_valid(message):
+def process_query(message):
+
+    if check_valid_nlq(message):
 
-        return gen_sparql(message)
+        return generate_sparql(message)
     
     else:
     
-        return "Unable to generate SPARQL with your request, try to rephrase it."
+        return "Your request cannot be answered by generating a SPARQL query, try a different one that apply to the ERA Knowledge Graph."
+
+def clear_query():
+
+    return None, None
+
+with gradio.Blocks() as demo:
+    
+    query = gradio.Textbox(render=False, label="Query", placeholder="Write a query or select an example above", submit_btn="Send query", show_copy_button=True)
+   
+    sparql_block = gradio.Code(render=False, label="Generated SPARQL", interactive=False, language="sql")
+
+    sparql_results = gradio.DataFrame(render=False, label="Data result", value=None, headers=None, interactive=False, wrap=True, show_row_numbers=True, show_copy_button=True)
+        
+    with gradio.Row():
+        
+        with gradio.Accordion(label="Examples", open=False):
+            
+            gradio.Examples(label="Query examples", examples=examples_data, example_labels=[e[0] for e in examples_data], cache_examples=False, inputs=[query],examples_per_page=10)
+    
+    with gradio.Row():
+        query.render()
+
+    with gradio.Row():
+        
+        with gradio.Accordion(label="Options", open=False):
+
+            gradio.Dropdown(
+                ["ran", "swam", "ate", "slept"], multiselect=False, label="Model"
+            )
+                   
+    with gradio.Row():
+        sparql_block.render()
 
+    with gradio.Row():
+        sparql_results.render()
+        
+         
+    query.submit(process_query,  inputs=[query], outputs=[sparql_block])
+    query.change(clear_query, inputs=[], outputs=[sparql_block, sparql_results])
+    sparql_block.change(execute_sparql, inputs=[sparql_block], outputs=[sparql_results])
 
-demo = gr.ChatInterface(
-    respond,
-    type="messages",
-    title="SPARQL generator"
-)
 
 
 if __name__ == "__main__":
-    demo.queue().launch()
+    demo.launch()

examples.json

@@ -0,0 +1,13 @@
+[
+    {"query": "find tracks without any rules or restrictions documents"},
+    {"query": "Get the top 100 net elements, showing their labels and lengths in descending order."},
+    {"query": "Retrieve system separation info where length >100"},
+    {"query": "List all LineReference entities along with their labels and kilometer values."},
+    {"query": "Siding labels where era:notApplicable is http://data.europa.eu/949/verificationINF"},
+
+    {"query": "hat's the total number of PhaseInfo entries that include a phaseInfoKm?"},
+    {"query": "Sections and their OP start and end"},
+    {"query": "How many tracks exist?"},
+    {"query": "Show document named T_3_020322_1.pdf"},
+    {"query": "Fetch the entities of type era:VehicleType and their labels, skipping the first five results."}
+]

requirements.txt

@@ -1,4 +1,6 @@
 huggingface_hub
 transformers
 accelerate
-pyparseit
+pyparseit
+SPARQLWrapper
+rdflib

requirements_local.txt

@@ -0,0 +1 @@
+gradio==5.34.2