Graph-Visualizer/main.py at main · camescopetech/Graph-Visualizer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
from flask import Flask, request, jsonify
uploaded_graph = None
import tempfile
import rdflib
import json
import os
from flask_cors import CORS

app = Flask(__name__)
CORS(app, resources={r"/*": {"origins": "*"}}, supports_credentials=True)

def rdf_to_json(rdf_file):
    g = rdflib.Graph()
    g.parse(rdf_file)

    merged_properties = {}
    resolved_nodes = {}

    for subj, pred, obj in g:
        if isinstance(subj, rdflib.BNode):
            if subj not in resolved_nodes:
                resolved_nodes[subj] = {}
            pred_str = str(pred)
            resolved_nodes[subj][pred_str] = str(obj)
        elif isinstance(obj, rdflib.BNode):
            if obj not in resolved_nodes:
                resolved_nodes[obj] = {}
            pred_str = str(pred)
            resolved_nodes[obj][pred_str] = str(subj)
        else:
            subj_str = str(subj)
            pred_str = str(pred)

            if subj_str not in merged_properties:
                merged_properties[subj_str] = {}

            # Ensure base list exists (back-compat)
            if pred_str not in merged_properties[subj_str]:
                merged_properties[subj_str][pred_str] = []

            # Literals: preserve value + language
            if isinstance(obj, rdflib.Literal):
                text = str(obj)
                lang = (obj.language or "")

                # 1) Backward compatible flat list (strings)
                merged_properties[subj_str][pred_str].append(text)

                # 2) Detailed list with language metadata
                det_key = f"{pred_str}__detailed"
                if det_key not in merged_properties[subj_str]:
                    merged_properties[subj_str][det_key] = []
                merged_properties[subj_str][det_key].append({
                    "text": text,
                    "lang": lang
                })

                # 3) Per-language map for fast filtering
                lang_key = f"{pred_str}__byLang"
                if lang_key not in merged_properties[subj_str]:
                    merged_properties[subj_str][lang_key] = {}
                if lang not in merged_properties[subj_str][lang_key]:
                    merged_properties[subj_str][lang_key][lang] = []
                merged_properties[subj_str][lang_key][lang].append(text)

            # Non-literals (IRIs): keep as strings
            else:
                merged_properties[subj_str][pred_str].append(str(obj))

    for blank_node, properties in resolved_nodes.items():
        source = properties.get("http://www.w3.org/2002/07/owl#sourceIndividual")
        if source:
            source_str = source
            properties.pop("http://www.w3.org/1999/02/22-rdf-syntax-ns#type", None)
            assertion_property = properties.get("http://www.w3.org/2002/07/owl#assertionProperty")
            target_value = properties.get("http://www.w3.org/2002/07/owl#targetValue")
            target_individual = properties.get("http://www.w3.org/2002/07/owl#targetIndividual")

            if source_str not in merged_properties:
                merged_properties[source_str] = {}
            if assertion_property and target_value:
                for prop, value in zip(assertion_property.split(), target_value.split()):
                    if prop not in merged_properties[source_str]:
                        merged_properties[source_str][prop] = []
                    merged_properties[source_str][prop].append(value)
            if assertion_property and target_individual:
                for prop, ind in zip(assertion_property.split(), target_individual.split()):
                    if prop not in merged_properties[source_str]:
                        merged_properties[source_str][prop] = []
                    merged_properties[source_str][prop].append(ind)

    return merged_properties

@app.route('/upload', methods=['POST'])
def upload_rdf():
    if 'file' not in request.files:
        return jsonify({'error': 'No file uploaded'}), 400

    file = request.files['file']
    if file.filename == '':
        return jsonify({'error': 'Empty filename'}), 400

    with tempfile.NamedTemporaryFile(delete=False, suffix=".rdf") as temp_rdf:
        file.save(temp_rdf.name)
        result = rdf_to_json(temp_rdf.name)
        # Sauvegarder le graphe RDF chargé dans la variable globale
        global uploaded_graph
        g = rdflib.Graph()
        g.parse(temp_rdf.name)
        uploaded_graph = g
        return jsonify(result)


# Nouvelle route /sparql pour exécuter une requête SPARQL sur le graphe RDF chargé
@app.route('/sparql', methods=['POST'])
def sparql_query():
    global uploaded_graph
    data = request.get_json()
    query = data.get('query')
    if not query:
        return jsonify({'error': 'No query provided'}), 400

    if uploaded_graph is None:
        return jsonify({'error': 'No RDF graph loaded'}), 400

    try:
        results = uploaded_graph.query(query)
        json_results = []
        for row in results:
            json_results.append([str(val) for val in row])
        return jsonify(json_results)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(port=5050)