REST-API für SPARQL in Django (Python)?

Einführung

Die Herausforderung, die ich Ihnen heute bringe, ist: Eine Real Rime REST API ( GET, POST, PUT, DELETE, etc) zu implementieren, um jeden SPARQL - Endpunkt mit dem Django REST Framework für eine Frontend-Anwendung (ich verwende React ) abzufragen und zu aktualisieren , um die anzufordern und zu verwenden serialisierte Daten, die von der REST-API bereitgestellt werden .

Bitte beachten Sie, dass ich Django verwende, weil ich in Zukunft Web- UND mobile Anwendungen implementieren möchte, aber im Moment werde ich es nur in einer React-Webanwendung implementieren .

Spezifikationen

Die REST-API sollte in der Lage sein:

• Durchführen (Lesen oder Aktualisieren) von Abfragen an einen SPARQL- Endpunkt über HTTP -Anforderungen.
• Serialisieren Sie die Antwort je nach HTTP -Antwort in eine standardisierte JSON -RDF-Tabelle oder in ein RDF-Diagramm .
• Speichern Sie die serialisierte Antwort in einem Python- Objekt.
• Stellen Sie einen Endpunkt mit der serialisierten Antwort für eine Frontend-Anwendung wie React bereit.
• Behandeln Sie eingehende Anfragen von der Frontend-Anwendung, "übersetzen" und führen Sie sie als SPARQL- Abfrage aus.
• Senden Sie die Antwort auf die Anfrage der Front-End-Anwendung zurück.

All dies , während alle Abfragen und Aktualisierungen in Echtzeit durchgeführt werden .

Was ich mit einer Echtzeit-API meine :

1. Eine SPARQL - Abfrage wird von der REST-API über eine HTTP - Anforderung an einen SPARQL -Endpunkt ausgeführt.
2. Die REST-API liest die aus der Anfrage generierte HTTP- Antwort.
3. Die REST-API serialisiert die Antwort in das entsprechende Format.
4. Diese serialisierte Antwort wird zur späteren Verwendung lokal in einem Python- Objekt gespeichert .

(Hinweis: Alle Tripel vom SPARQL- Endpunkt in der Abfrage existieren jetzt sowohl im SPARQL- Endpunkt als auch in einem Python- Objekt und sind sowohl lokal als auch remote konsistent.)

1. Die Tripel werden dann (hypothetisch) modifiziert oder aktualisiert (entweder lokal oder entfernt).
2. Jetzt sind die lokalen Tripel nicht mehr synchron mit den Remote- Tripeln.
3. Die REST-API wird nun auf dieses Update aufmerksam (vielleicht durch Listener/Observer- Objekte?).
4. Die REST-API synchronisiert dann automatisch die Tripel, entweder durch eine Aktualisierungsabfrageanforderung (wenn die Änderungen lokal vorgenommen wurden) oder durch Aktualisieren des Python - Objekts mit der Antwort einer Abfrageanforderung (wenn die Aktualisierung remote vorgenommen wurde).
5. Schließlich sollten beide (der SPARQL- Endpunkt und das Python- Objekt) die neuesten aktualisierten Tripel gemeinsam nutzen und daher synchron sein .

Frühere Versuche

Ich konnte derzeit einen SPARQL - Endpunkt mit dem SPARQLWrapperPaket (zum Ausführen der Abfragen) und den Paketen RDFLibund JSONzum Serialisieren und Instanziieren von Python - Objekten aus der Antwort wie folgt abfragen:

import json

from rdflib import RDFS, Graph

from SPARQLWrapper import GET, JSON, JSONLD, POST, TURTLE, SPARQLWrapper


class Store(object):
    def __init__(self, query_endpoint, update_endpoint=None):
        self.query_endpoint = query_endpoint
        self.update_endpoint = update_endpoint
        self.sparql = SPARQLWrapper(query_endpoint, update_endpoint)

    def graph_query(self, query: str, format=JSONLD, only_conneg=True):
        results = self.query(query, format, only_conneg) 
        results_bytes = results.serialize(format=format)
        results_json = results_bytes.decode('utf8').replace("'", '"')
        data = json.loads(results_json)
        return data

    def query(self, query: str, format=JSON, only_conneg=True):
        self.sparql.resetQuery()
        self.sparql.setMethod(GET)
        self.sparql.setOnlyConneg(only_conneg)
        self.sparql.setQuery(query)
        self.sparql.setReturnFormat(format)
        return self.sparql.queryAndConvert()

    def update_query(self, query: str, only_conneg=True):
        self.sparql.resetQuery()
        self.sparql.setMethod(POST)
        self.sparql.setOnlyConneg(only_conneg)
        self.sparql.setQuery(query)
        self.sparql.query()


store = Store('http://www.example.com/sparql/Example')
print(store.query("""SELECT ?s WHERE {?s ?p ?o} LIMIT 1"""))
print(store.graph_query("""DESCRIBE <http://www.example.com/sparql/Example/>"""))

Die Herausforderung

Der bisherige Code löst bereits:

• Durchführen (Lesen oder Aktualisieren) von Abfragen an einen SPARQL-Endpunkt über HTTP-Anforderungen
• Serialisieren Sie die Antwort je nach HTTP-Antwort in eine standardisierte JSON-RDF-Tabelle oder ein RDF-Diagramm
• Speichern Sie die serialisierte Antwort in einem Python-Objekt.

Diese anderen Aspekte werden jedoch immer noch nicht umgesetzt:

• Stellen Sie einen Endpunkt mit der serialisierten Antwort für eine Frontend-Anwendung wie React bereit. Eingehende Anfragen von der Frontend-Anwendung verarbeiten, „übersetzen“ und als SPARQL-Abfrage ausführen.**
• Senden Sie die Antwort auf die Anfrage der Front-End-Anwendung zurück.

Und nicht zuletzt scheitert es vollständig an der Umsetzung des Echtzeitaspekts dieser Herausforderung.

Die Fragen:

• Wie würden Sie das umsetzen?
• Ist das wirklich der beste Ansatz?
• Kann der bereits funktionierende Code optimiert werden?
• Gibt es etwas, das dies bereits tut?

Vielen Dank!

Tut mir leid, aber ich weiß nicht viel über Django, daher kann ich hier nicht mit Django-Besonderheiten antworten.

Ich kann jedoch Folgendes sagen: SPARQL hat eine Spezifikation für HTTP-Interaktionen (https://www.w3.org/TR/sparql11-protocol/) und es sagt Ihnen, dass Sie URIs im Stil von sparql?query=...& sparql?update...zum Abfragen eines Geschäfts verwenden sollen. Warum also eine neue Art definieren, Dinge mit store.query& store.graph_queryusw. zu tun?

Gibt es einen Django-spezifischen Grund?

Sie können bereits Fragen an einen SPARQL-Endpunkt stellen, indem Sie React verwenden oder was auch immer Sie jetzt gerade wollen, so wie es ist.

Sie sagten, was fehlt, ist "einen Endpunkt mit der serialisierten Antwort bereitzustellen", aber die SPARQL-Antworten sind diese! SPARQL-Antwortformate für Abfragen sind in der Spezifikation definiert (z. B. JSON:https://www.w3.org/TR/sparql11-results-json/) und SPARQLWrapper weiß, wie man sie in Python-Objekte parst. Andere Sprachbibliotheken, wie rdflib.js in JavaScript kennen das auch.

Siehe YASGUI (https://triply.cc/docs/yasgui) für einen eigenständigen JS SPARQL-Client.