Django'da (Python) SPARQL için REST API?

giriiş

Bugün size sunduğum zorluk şudur: Bir ön uç uygulaması için Django REST Çerçevesini kullanarak herhangi bir SPARQL uç noktasını sorgulamak ve güncellemek üzere bir Real Rime REST API ( GET, POST, PUT, DELETE, vb.) uygulamak ( React kullanıyorum ) REST API tarafından sağlanan seri hale getirilmiş veriler .

Gelecekte Web AND Mobil uygulamalarını uygulamak istediğim için Django kullandığımı lütfen unutmayın , ancak şimdilik onu yalnızca bir React Web uygulamasında uygulayacağım.

Özellikler

REST API şunları yapabilmelidir:

• HTTP istekleri aracılığıyla bir SPARQL uç noktasında sorgular gerçekleştirin (okuma veya güncelleme) .
• Yanıtı, HTTP yanıtına bağlı olarak bir JSON RDF standartlaştırılmış tablosuna veya bir RDF Graph'a seri hale getirin.
• Serileştirilmiş yanıtı bir Python nesnesinde saklayın.
• React gibi bir ön uç uygulamasına seri hale getirilmiş yanıtla bir uç nokta sağlayın).
• Ön uç uygulamasından gelen istekleri işleyin, "çevirin" ve bir SPARQL sorgusu olarak yürütün .
• Ön uç uygulamasının isteğine yanıtı geri gönderin.

BUNLARIN TÜMÜ , tüm sorguları ve güncellemeleri Gerçek Zamanlı olarak gerçekleştirirken .

Gerçek Zamanlı API ile ne demek istiyorum :

1. REST API'sinden bir SPARQL uç noktasına bir HTTP isteği aracılığıyla bir SPARQL sorgusu yürütülür .
2. REST API , istekten oluşturulan HTTP yanıtını okur .
3. REST API , yanıtı karşılık gelen biçime göre seri hale getirir.
4. Bu seri hale getirilmiş yanıt, ileride kullanılmak üzere yerel olarak bir Python nesnesinde depolanır .

(Not: Sorgudaki SPARQL uç noktasındaki tüm üçlüler artık hem SPARQL uç noktasında hem de bir Python nesnesinde mevcuttur ve hem yerel hem de uzaktan tutarlıdır.)

1. Üçlüler daha sonra (varsayımsal olarak) değiştirilir veya güncellenir (Yerel olarak veya uzaktan).
2. Artık yerel üçlüler uzak üçlülerle senkronize değil .
3. REST API artık bu güncellemeden haberdar olur ( belki Listener/Observer nesneleri aracılığıyla ? ) .
4. REST API daha sonra , bir güncelleme sorgu talebi aracılığıyla (eğer değişiklikler yerel olarak yapıldıysa) veya Python nesnesini bir sorgu talebinin yanıtıyla güncelleyerek (güncelleme uzaktan yapıldıysa) üçlüleri otomatik olarak senkronize eder.
5. Son olarak, her ikisi de ( SPARQL uç noktası ve Python nesnesi) en son güncellenen üçlüleri paylaşmalı ve bu nedenle, synch içinde olmalıdır .

Önceki Denemeler

Şu anda paketi (sorguları yürütmek için) ve Python nesnelerini yanıttan seri hale getirmek ve örneklendirmek için ve paketlerini kullanarak bir SPARQL uç noktasını sorgulayabildim, bunun gibi:SPARQLWrapperRDFLibJSON

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/>"""))

Meydan okuma

Önceki kod çözebilir zaten:

• HTTP istekleri yoluyla bir SPARQL uç noktasına sorgular gerçekleştirin (okuma veya güncelleme)
• HTTP yanıtına bağlı olarak yanıtı bir JSON RDF standartlaştırılmış tablosuna veya bir RDF Grafiğine göre seri hale getirin
• Serileştirilmiş yanıtı bir Python nesnesinde saklayın.

Ancak yine de bu diğer yönleri uygulamada başarısız oluyor:

• React gibi bir ön uç uygulamasına seri hale getirilmiş yanıtla bir uç nokta sağlayın). Ön uç uygulamasından gelen istekleri işleyin, "çevirin" ve bir SPARQL sorgusu olarak yürütün.**
• Ön uç uygulamasının isteğine yanıtı geri gönderin.

Ve son olarak, ama en az değil, bu zorluğun gerçek zamanlı yönünü uygulamakta tamamen başarısız oluyor.

Sorular:

• Bunu nasıl uygularsınız?
• Bu gerçekten en iyi yaklaşım mı?
• Halihazırda çalışan kod optimize edilebilir mi?
• Bunu zaten yapan bir şey var mı?

Çok teşekkür ederim!

Üzgünüm ama Django hakkında fazla bir şey bilmiyorum, bu yüzden burada Django'nun ayrıntılarıyla yanıt veremem.

Ancak şunu söyleyebilirim: SPARQL'in HTTP etkileşimleri için bir özelliği vardır (https://www.w3.org/TR/sparql11-protocol/sparql?query=...) ve bir mağazayı sorgulamak için & stil URI'lerini kullanmanızı söyler , öyleyse neden & etc sparql?update...ile bir şeyler yapmanın yeni bir yolunu tanımlayasınız ?store.querystore.graph_query

Django'ya özgü bir sebep var mı?

Bir SPARQL Endpoint'e React'i kullanarak veya şu anda ne isterseniz onu olduğu gibi soru sorabilirsiniz.

Eksik olanın "Serileştirilmiş yanıtla bir uç nokta sağlayın" olduğunu söylediniz, ancak SPARQL yanıtları bu! SPARQL sorgu yanıt biçimleri teknik özelliklerde tanımlanmıştır (örn. JSON:https://www.w3.org/TR/sparql11-results-json/) ve SPARQLWrapper bunları Python nesnelerine nasıl ayrıştıracağını bilir. JavaScript'teki rdflib.js gibi diğer dil kitaplıklarını da bilir.

YASGUI'ye bakın (https://triply.cc/docs/yasgui) bağımsız bir JS SPARQL istemcisi için.