app.py

# Atualização do Gradio no início
import subprocess
import sys

# Atualiza o Gradio uma única vez, silenciosamente
try:
    subprocess.check_call([sys.executable, '-m', 'pip', 'install', '--upgrade', 'gradio'],
                         stdout=subprocess.DEVNULL,
                         stderr=subprocess.DEVNULL)
except Exception as e:
    print(f"Aviso: {e}")

# Verifica a versão atual
try:
    import pkg_resources
    current_version = pkg_resources.get_distribution('gradio').version
    print(f"Versão do Gradio: {current_version}")
except:
    print("Não foi possível verificar a versão do Gradio")

import gradio as gr
import rdflib
import requests
import matplotlib.pyplot as plt
import networkx as nx
from io import BytesIO
import base64

# Função para carregar e extrair os nomes do arquivo JSON-LD a partir de uma URL
def load_names_from_url(jsonld_url):
    response = requests.get(jsonld_url)
    data = response.json()
    
    names = []
    for item in data:
        if 'name' in item:
            names.append(item['name'])
    
    return names

# Carregar nomes do arquivo JSON-LD
jsonld_url = 'https://huggingface.co/spaces/histlearn/ShowGraph/raw/main/datafile.jsonld'
names = load_names_from_url(jsonld_url)

def build_graph_from_jsonld(jsonld_url, selected_name):
    response = requests.get(jsonld_url)
    data = response.json()
    
    # Filtrar o local selecionado
    selected_data = next((item for item in data if item['name'] == selected_name), None)
    
    if not selected_data:
        return "Local não encontrado."
    
    G = nx.DiGraph()
    
    # Adicionar nó do Place
    place_id = selected_data['@id']
    place_label = f"schema:Place\nName: {selected_data['name']}\nDescription: {selected_data['description'][:30]}..."
    G.add_node(place_id, label=place_label)
    
    # Adicionar nó de GeoCoordinates
    geo_data = selected_data['geo']
    geo_id = geo_data['@id']
    geo_label = f"geo:SpatialThing\nLat: {geo_data['lat']}\nLong: {geo_data['long']}\nFeatureCode: {geo_data['gn:featureCode']}\nFeatureCodeName: {geo_data['gn:featureCodeName']}\nName: {geo_data['gn:name']}"
    G.add_node(geo_id, label=geo_label)
    G.add_edge(place_id, geo_id, label="schema:geo")
    
    # Adicionar nós de CreativeWork
    for work in selected_data.get('subjectOf', []):
        work_id = work['@id']
        work_label = f"schema:CreativeWork\nHeadline: {work['headline']}\nGenre: {work['genre']}\nDatePublished: {work['datePublished']}\nText: {work['text'][:30]}...\nLanguage: {work['inLanguage']}"
        G.add_node(work_id, label=work_label)
        G.add_edge(place_id, work_id, label="schema:subjectOf")
    
    return G

def run_query_and_visualize(selected_location, jsonld_url):
    G = build_graph_from_jsonld(jsonld_url, selected_location)

    if isinstance(G, str):  # Caso de erro
        return G
    
    # Define posições específicas para os nós importantes
    pos = nx.spring_layout(G)
    
    # Desenha o gráfico usando NetworkX e Matplotlib
    plt.figure(figsize=(15, 10))
    nx.draw_networkx_nodes(G, pos, node_size=3000, node_color="skyblue", alpha=0.9)
    nx.draw_networkx_edges(G, pos, width=2, alpha=0.5, edge_color='gray')
    nx.draw_networkx_labels(G, pos, labels=nx.get_node_attributes(G, 'label'), font_size=9, font_color="black")
    nx.draw_networkx_edge_labels(G, pos, edge_labels=nx.get_edge_attributes(G, 'label'), font_size=9, font_color="red")

    plt.title("Resultado da Consulta", size=15)
    plt.axis('off')
    
    # Salva o gráfico em um arquivo
    buf = BytesIO()
    plt.savefig(buf, format='png')
    buf.seek(0)
    img_str = base64.b64encode(buf.read()).decode()
    graph_html = f'<img src="data:image/png;base64,{img_str}"/>'
    
    plt.close()

    print("Gráfico gerado com sucesso.")
    return graph_html

with gr.Blocks() as demo:
    gr.Markdown("# Visualização de Query SPARQL")

    with gr.Column():
        selected_location = gr.Dropdown(choices=names, label="Selecione o Local")
        run_button = gr.Button("Visualizar Grafo")

    graph_output = gr.HTML()

    def on_run_button_click(selected_location):
        return run_query_and_visualize(selected_location, jsonld_url)

    run_button.click(fn=on_run_button_click, inputs=[selected_location], outputs=graph_output)

if __name__ == "__main__":
    demo.launch()