Skip to content

# Plugins

Many parts of RDFLib are extensible with plugins, see setuptools’ ‘Creating and discovering plugins’. These pages list the plugins included in RDFLib core.

- `Parser Plugins`
- `Serializer Plugins`
- `Store Plugins`
- `Query Results Plugins`

## Plugin stores

### Built In

The following Stores are contained within the rdflib core package:

Name | Class
--- | ---
Auditable | `AuditableStore`
Concurrent | `ConcurrentStore`
SimpleMemory | `SimpleMemory`
Memory | `Memory`
SPARQLStore | `SPARQLStore`
SPARQLUpdateStore | `SPARQLUpdateStore`
BerkeleyDB | `BerkeleyDB`
default | `Memory`

### External

The following Stores are defined externally to rdflib’s core package, so look to their documentation elsewhere for specific details of use.

Name | Repository | Notes
--- | --- | ---
SQLAlchemy | github.com/RDFLib/rdflib-sqlalchemy | An SQLAlchemy-backed, formula-aware RDFLib Store. Tested dialects are: SQLite, MySQL & PostgreSQL
leveldb | github.com/RDFLib/rdflib-leveldb | An adaptation of RDFLib BerkeleyDB Store’s key-value approach, using LevelDB as a back-end
Kyoto Cabinet | github.com/RDFLib/rdflib-kyotocabinet | An adaptation of RDFLib BerkeleyDB Store’s key-value approach, using Kyoto Cabinet as a back-end
HDT | github.com/RDFLib/rdflib-hdt | A Store back-end for rdflib to allow for reading and querying HDT documents
Oxigraph | github.com/oxigraph/oxrdflib | Works with the Pyoxigraph Python graph database library
pycottas | github.com/arenas-guerrero-julian/pycottas | A Store backend for querying compressed COTTAS files

If you have, or know of a Store implementation and would like it listed here, please submit a Pull Request!

### Use

You can use these stores like this:

    from rdflib import Graph

    # use the default memory Store
    graph = Graph()

    # use the BerkeleyDB Store
    graph = Graph(store="BerkeleyDB")

In some cases, you must explicitly open and close a store, for example:

    from rdflib import Graph

    # use the BerkeleyDB Store
    graph = Graph(store="BerkeleyDB")
    graph.open("/some/folder/location")
    # do things ...
    graph.close()

## Plugin parsers

These serializers are available in default RDFLib, you can use them by passing the name to graph’s `parse()` method:

    graph.parse(my_url, format='n3')

The `html` parser will auto-detect RDFa, HTurtle or Microdata.

It is also possible to pass a mime-type for the `format` parameter:

    graph.parse(my_url, format='application/rdf+xml')

If you are not sure what format your file will be, you can use `guess_format()` which will guess based on the file extension.

Name | Class
--- | ---
json-ld | `JsonLDParser`
hext | `HextuplesParser`
n3 | `N3Parser`
nquads | `NQuadsParser`
patch | `RDFPatchParser`
nt | `NTParser`
trix | `TriXParser`
turtle | `TurtleParser`
xml | `RDFXMLParser`

### Multi-graph IDs

Note that for correct parsing of multi-graph data, e.g. TriG, HexTuple, etc., into a `Dataset`, as opposed to a context-unaware `Graph`, you will need to set the `publicID` of the `Dataset` to the identifier of the `default_context` (default graph), for example:

    d = Dataset()
    d.parse(
        data=""" ... """,
        format="trig",
        publicID=d.default_context.identifier
    )

(from the file tests/test_serializer_hext.py)

## Plugin serializers

These serializers are available in default RDFLib, you can use them by passing the name to a graph’s `serialize()` method:

    print graph.serialize(format='n3')

It is also possible to pass a mime-type for the `format` parameter:

    graph.serialize(my_url, format='application/rdf+xml')

Name | Class
--- | ---
json-ld | `JsonLDSerializer`
n3 | `N3Serializer`
nquads | `NQuadsSerializer`
nt | `NTSerializer`
hext | `HextuplesSerializer`
patch | `PatchSerializer`
pretty-xml | `PrettyXMLSerializer`
trig | `TrigSerializer`
trix | `TriXSerializer`
turtle | `TurtleSerializer`
longturtle | `LongTurtleSerializer`
xml | `XMLSerializer`

### JSON-LD

JSON-LD - ‘json-ld’ - has been incorporated into RDFLib since v6.0.0.

### RDF Patch

The RDF Patch Serializer - ‘patch’ - uses the RDF Patch format defined at https://afs.github.io/rdf-patch/. It supports serializing context aware stores as either addition or deletion patches; and also supports serializing the difference between two context aware stores as a Patch of additions and deletions.

### HexTuples

The HexTuples Serializer - ‘hext’ - uses the HexTuples format defined at https://github.com/ontola/hextuples.

For serialization of non-context-aware data sources, e.g. a single `Graph`, the ‘graph’ field (6th variable in the Hextuple) will be an empty string.

For context-aware (multi-graph) serialization, the ‘graph’ field of the default graph will be an empty string and the values for other graphs will be Blank Node IDs or IRIs.

### Longturtle

Longturtle is just the turtle format with newlines preferred over compactness - multiple nodes on the same line to enhance the format’s text file version control (think Git) friendliness - and more modern forms of prefix markers - PREFIX instead of @prefix - to make it as similar to SPARQL as possible.

Longturtle is Turtle 1.1 compliant and will work wherever ordinary turtle works, however some very old parsers don’t understand PREFIX, only @prefix…

## Plugin query results

Plugins for reading and writing of (SPARQL) `Result` - pass `name` to either `parse()` or `serialize()`

### Parsers

Name | Class
--- | ---
csv | `CSVResultParser`
json | `JSONResultParser`
tsv | `TSVResultParser`
xml | `XMLResultParser`

### Serializers

Name | Class
--- | ---
csv | `CSVResultSerializer`
json | `JSONResultSerializer`
txt | `TXTResultSerializer`
xml | `XMLResultSerializer`