oxilite for Python

An Oxigraph-compatible SPARQL 1.1 store for Python, on SQLite. It has the API of pyoxigraph and keeps the whole dataset in one SQLite file. The same data can also be queried with openCypher and Datalog, reasoned over with RDFS / OWL, described by SHACL shapes, filled from JSON-LD documents and Verifiable Credentials, and read at any past version.

Website · Python reference · Tutorial · Source · Issues

pip install oxilite

Quick start

from oxilite import Store, NamedNode, Literal, Quad, RdfFormat

store = Store("data.sqlite")                     # Store() for an in-memory store
store.load("""
    @prefix ex: <http://example.com/> .
    ex:ada a ex:Person ; ex:name "Ada" ; ex:knows ex:alan .
""", RdfFormat.TURTLE)
store.add(Quad(NamedNode("http://example.com/alan"), NamedNode("http://example.com/name"), Literal("Alan")))

for solution in store.query("SELECT ?name WHERE { ?p <http://example.com/name> ?name }"):
    print(solution["name"].value)

store.update("DELETE WHERE { ?s <http://example.com/knows> ?o }")
print(len(store))

query returns what pyoxigraph returns: QuerySolutions for SELECT, QueryBoolean for ASK, and QueryTriples for CONSTRUCT and DESCRIBE. Each can be serialized to JSON, XML, CSV or TSV (RDF for triples).

Coming from pyoxigraph

import oxilite as pyoxigraph

Terms, formats, results, parse, serialize, parse_query_results and every Store method keep their names, arguments and results. pyoxigraph's own test suite runs against this package on every build. Two kinds of test fail, and they are allow-listed:

• custom Python functions inside SPARQL: a query is one SQL statement, so SQLite cannot call Python for each row
• LOAD of a remote URL: the core does no network I/O

Store(path) opens a SQLite file. Given an existing directory, as pyoxigraph's paths are, it uses oxilite.sqlite inside it.

Cypher and Datalog over the same data

opts = {"base": "http://example.com/"}
store.cypher("CREATE (:Person {name: 'Grace'})-[:KNOWS {since: 1950}]->(:Person {name: 'Ada'})", **opts)
r = store.cypher("MATCH (a:Person {name: $name})-[:KNOWS]->(b) RETURN b.name AS friend", {"name": "Grace"}, **opts)
print(r.records)                          # [{'friend': 'Ada'}]

program = """
@prefix ex: <http://example.com/> .
reach(?x, ?y) :- ex:KNOWS(?x, ?y).
reach(?x, ?z) :- ex:KNOWS(?x, ?y), reach(?y, ?z).
?- reach(?a, ?b).
"""
print(store.datalog(program).records)     # [{'a': <NamedNode …>, 'b': <NamedNode …>}]

Nodes are IRIs, labels are rdf:type, properties are literal triples, and relationships are triples, with an RDF 1.2 reifier when they carry properties. So SPARQL sees everything Cypher writes. A Datalog program whose recursion is linear runs as one recursive SQL statement.

Synalog, the Datalog-family language for AI agents, runs over the same data, reading triples as tables:

r = store.synalog("""
# @table knows <http://example.com/KNOWS>
@Recursive(Reach, 10);
Reach(a:, b:) distinct :- knows(subject: a, object: b);
Reach(a:, b:) distinct :- Reach(a:, b: m), knows(subject: m, object: b);
""", "Reach")
print(r.records)                          # [{'a': 'http://example.com/…', 'b': '…'}]

Reasoning, schemas, documents, history

from datetime import datetime, timezone
from oxilite import DefaultGraph, NamedNode, RdfFormat, Store

store = Store()
store.load("@prefix ex: <http://example.com/> . ex:rex a ex:Dog .", RdfFormat.TURTLE)
onto = NamedNode("http://example.com/onto")
store.load("@prefix ex: <http://example.com/> . @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n"
           "ex:Dog rdfs:subClassOf ex:Animal .", RdfFormat.TURTLE, to_graph=onto)
store.register_schema_graph(onto, "ontology", applies_to=[DefaultGraph()])   # the schema registry

assert store.query("ASK { ex:rex a ex:Animal }", reasoning="rdfs", prefixes={"ex": "http://example.com/"})
store.materialize(engine="reasonable")            # OWL 2 RL closure; query it with include_inferred=True

docs = store.jsonld()                             # JSON-LD stored byte for byte, RDF in a named graph
docs.put('{"@context": {"name": "http://schema.org/name"}, "@id": "urn:uuid:1", "name": "Ada"}')
vcs = store.credentials()                         # Verifiable Credentials 1.1 and 2.0, indexed by
vcs.find(issuer="did:example:academy", valid_at=datetime.now(timezone.utc))  # issuer, subject, validity

versioned = Store(versioning="log")               # an immutable change log
with versioned.commit(author="ada", message="import"):
    versioned.update('INSERT DATA { <urn:t1> <urn:status> "open" }')
with versioned.commit(author="grace", message="close"):
    versioned.update('DELETE DATA { <urn:t1> <urn:status> "open" } ; INSERT DATA { <urn:t1> <urn:status> "done" }')
print([s["s"].value for s in versioned.query("SELECT ?s { <urn:t1> <urn:status> ?s }", as_of="HEAD~1")])  # ['open']

Examples

Each example is a short script that runs top to bottom, prints what it does and asserts its output. CI runs all of them against every build.

API at a glance

Every result is typed: the package ships py.typed and passes mypy --strict. Store calls release the GIL. The full reference is docs/python.md.

Platforms

Wheels use the stable ABI, so each one serves CPython 3.9 and every later version:

• Linux: glibc x86_64 and aarch64, musl x86_64
• macOS: x86_64 and arm64
• Windows: x64

On other platforms, pip builds the package from the source distribution, which needs a Rust toolchain. To build it yourself, see building and publishing the package.

The oxilite family

oxilite is an Oxigraph-compatible RDF database and SPARQL 1.1 engine that stores its data in SQLite. It runs anywhere SQLite runs: in-process, on a system or vendor libsqlite3, and on Cloudflare D1 and in Durable Objects.

License

Dual-licensed under MIT or Apache-2.0, at your option, like Oxigraph.