pyoxigraph

https://pyoxigraph.readthedocs.io/en/stable/
Admin
Pyoxigraph is a Python graph database library implementing the SPARQL standard. It provides...
Tokens:14,304
Snippets:149
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Serialize Literal values

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Examples of serializing various types of literals, including those with language tags and datatypes.

```python
>>> str(Literal('example'))
'"example"'
>>> str(Literal('example', language='en'))
'"example"@en'
>>> str(Literal('11', datatype=NamedNode('http://www.w3.org/2001/XMLSchema#integer')))
'"11"^^<http://www.w3.org/2001/XMLSchema#integer>'
>>> str(Literal(11))
'"11"^^<http://www.w3.org/2001/XMLSchema#integer>'
```

--------------------------------

### Parse RDF data with pyoxigraph

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Example of parsing a Turtle-formatted string into an iterator of quads using a base IRI.

```python
>>> list(parse(input=b'<foo> <p> "1" .', format=RdfFormat.TURTLE, base_iri="http://example.com/"))
[<Quad subject=<NamedNode value=http://example.com/foo> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<DefaultGraph>>]
```

--------------------------------

### Query and iterate SELECT solutions

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Shows how to execute a SELECT query and iterate over the resulting QuerySolutions.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
>>> list(store.query('SELECT ?s WHERE { ?s ?p ?o }'))
[<QuerySolution s=<NamedNode value=http://example.com>>]
```

--------------------------------

### Execute SPARQL CONSTRUCT Query

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Demonstrates executing a CONSTRUCT query against a Store and retrieving the resulting triples.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
>>> list(store.query('CONSTRUCT WHERE { ?s ?p ?o }'))
[<Triple subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>>>]
```

--------------------------------

### Store.backup(target_directory)

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Creates a backup of the database in the specified directory.

```APIDOC
## Store.backup(target_directory)

### Description
Creates a database backup into the target_directory. This is only supported for on-disk databases.

### Parameters
- **target_directory** (str or os.PathLike) - The directory path where the backup will be saved.
```

--------------------------------

### pyoxigraph.Store(path=None)

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Initializes a new RDF store. If a path is provided, it uses that directory for storage; otherwise, it creates a temporary in-memory store.

```APIDOC
## pyoxigraph.Store(path=None)

### Description
Initializes a new RDF store instance. The store encodes an RDF dataset and allows SPARQL queries.

### Parameters
- **path** (str or os.PathLike, optional) - The directory path for the store. If omitted, an in-memory store is created.
```

--------------------------------

### Execute SPARQL ASK Query

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Demonstrates executing an ASK query against a store and casting the result to a boolean.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
>>> bool(store.query('ASK { ?s ?p ?o }'))
True
```

--------------------------------

### Store.load

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Loads RDF serialization into the store.

```APIDOC
## Store.load

### Description
Loads RDF data from an input source into the store. The operation is transactional.

### Parameters
- **input** (optional) - The input source.
- **format** (RdfFormat or None) - Optional - The format of the RDF data.
- **path** (optional) - File path to load from.
- **base_iri** (str or None) - Optional - Base IRI for the data.
- **to_graph** (optional) - Target graph for the loaded data.
- **lenient** (bool) - Optional - Whether to be lenient during parsing.
```

--------------------------------

### Bulk load store content after migration

Source: https://pyoxigraph.readthedocs.io/en/stable/migration.html

Use this code with pyoxigraph 0.3 to import the previously dumped data into the new Store.

```python
from pyoxigraph import Store
store = Store('MY_NEW_STORAGE_PATH')
with open('temp_file.nq', 'rb') as fp:
    store.bulk_load(fp, "application/n-quads")
```

--------------------------------

### Access QuerySolution data

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Demonstrates indexing and unpacking a QuerySolution object.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
>>> solution = next(store.query('SELECT ?s ?p ?o WHERE { ?s ?p ?o }'))
>>> solution[Variable('s')]
<NamedNode value=http://example.com>
>>> solution['s']
<NamedNode value=http://example.com>
>>> solution[0]
<NamedNode value=http://example.com>
>>> s, p, o = solution
>>> s
<NamedNode value=http://example.com>
```

--------------------------------

### Execute a SELECT query

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Retrieves query solutions from the store using a SELECT SPARQL query.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
>>> [solution['s'] for solution in store.query('SELECT ?s WHERE { ?s ?p ?o }')]
[<NamedNode value=http://example.com>]
```

--------------------------------

### Insert and Query RDF Data with Pyoxigraph

Source: https://pyoxigraph.readthedocs.io/en/stable/index.html

Demonstrates adding a quad to a store and executing a SPARQL query to retrieve the value.

```python
from pyoxigraph import *

store = Store()
ex = NamedNode('http://example/')
schema_name = NamedNode('http://schema.org/name')
store.add(Quad(ex, schema_name, Literal('example')))
for binding in store.query('SELECT ?name WHERE { <http://example/> <http://schema.org/name> ?name }'):
    print(binding['name'].value)
```

--------------------------------

### Load RDF data into the store

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Demonstrates loading Turtle-formatted RDF data into a specific named graph within the store.

```python
>>> store = Store()
>>> store.load(input='<foo> <p> "1" .', format=RdfFormat.TURTLE, base_iri="http://example.com/", to_graph=NamedNode("http://example.com/g"))
>>> list(store)
[<Quad subject=<NamedNode value=http://example.com/foo> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### Serialize and access SPARQL variables

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Demonstrates how to create a SPARQL variable and access its underlying name.

```python
>>> str(Variable('foo'))
'?foo'
```

```python
>>> Variable("foo").value
'foo'
```

--------------------------------

### Dump store content for migration

Source: https://pyoxigraph.readthedocs.io/en/stable/migration.html

Use this code with pyoxigraph 0.2 to export the existing store content to a file.

```python
from pyoxigraph import SledStore
store = SledStore('MY_STORAGE_PATH')
with open('temp_file.nq', 'wb') as fp:
    store.dump(fp, "application/n-quads")
```

--------------------------------

### Store.dump

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Serializes the store content to a file or returns it as bytes.

```APIDOC
## Store.dump

### Description
Serializes the store content to a specified output or returns it as a bytes object. Supports various RDF formats and graph filtering.

### Parameters
- **output** (IO[bytes] or str or os.PathLike or None) - Optional - The binary I/O object or file path to write to.
- **format** (RdfFormat or None) - Optional - The format of the RDF serialization.
- **from_graph** (NamedNode or BlankNode or DefaultGraph or None) - Optional - The store graph from which to dump triples.
- **prefixes** (dict[str, str] or None) - Optional - Prefixes used in the serialization.
- **base_iri** (str or None) - Optional - The base IRI used in the serialization.

### Returns
- **bytes or None** - Returns bytes if output is None, otherwise None.
```

--------------------------------

### Store.extend

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Adds a set of quads to the store in a transactional manner.

```APIDOC
## Store.extend

### Description
Adds a collection of quads to the store. The operation is transactional, ensuring either all quads are added or none are.

### Parameters
- **quads** (collections.abc.Iterable[Quad]) - Required - The quads to add to the store.
```

--------------------------------

### Serialize query results

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Demonstrates serializing query results to a specific format like JSON.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
>>> results = store.query("SELECT ?s ?p ?o WHERE { ?s ?p ?o }")
>>> results.serialize(format=QueryResultsFormat.JSON)
b'{"head":{"vars":["s","p","o"]},"results":{"bindings":[{"s":{"type":"uri","value":"http://example.com"},"p":{"type":"uri","value":"http://example.com/p"},"o":{"type":"literal","value":"1"}}]}}'
```

--------------------------------

### Dump RDF data to a store

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Demonstrates serializing store content to a byte buffer or file using specific RDF formats.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
>>> store.dump(format=RdfFormat.TRIG)
b'<http://example.com> <http://example.com/p> "1" .\n'
```

```python
>>> import io
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
>>> output = io.BytesIO()
>>> store.dump(output, RdfFormat.TURTLE, from_graph=NamedNode("http://example.com/g"), prefixes={"ex": "http://example.com/"}, base_iri="http://example.com")
>>> output.getvalue()
b'@base <http://example.com> .\n@prefix ex: </> .\n<> ex:p "1" .\n'
```

--------------------------------

### Store.load

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Loads RDF data into the store from a string, bytes, or file-like object.

```APIDOC
## Store.load(input=None, format=None, path=None, base_iri=None, to_graph=None, lenient=False)

### Description
Loads RDF data into the store. The input can be provided as a string, bytes, or an I/O object, or via a file path.

### Parameters
- **input** (bytes or str or IO) - Optional - The data to read.
- **format** (RdfFormat) - Optional - The RDF serialization format.
- **path** (str or os.PathLike) - Optional - File path to read from.
- **base_iri** (str) - Optional - Base IRI for relative IRI resolution.
- **to_graph** (NamedNode or BlankNode or DefaultGraph) - Optional - The graph to store triples in.
- **lenient** (bool) - Optional - Skip data validation during loading.
```

--------------------------------

### Serialize CONSTRUCT Query Results

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Shows how to serialize the results of a CONSTRUCT query into a specific RDF format using the serialize method.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
>>> results = store.query("CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }")
>>> results.serialize(format=RdfFormat.N_TRIPLES)
b'<http://example.com> <http://example.com/p> "1" .\n'
```

--------------------------------

### query(query, base_iri=None, prefixes=None, use_default_graph_as_union=False, default_graph=None, named_graphs=None, substitutions=None, custom_functions=None, custom_aggregate_functions=None)

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Executes a SPARQL query against the store. Supports ASK, CONSTRUCT, DESCRIBE, and SELECT query types.

```APIDOC
## query(query, ...)

### Description
Executes a SPARQL query against the store. Returns a boolean for ASK queries, an iterator of Triples for CONSTRUCT/DESCRIBE, or an iterator of QuerySolutions for SELECT.

### Parameters
- **query** (str) - Required - The SPARQL query to execute.
- **base_iri** (str or None) - Optional - Base IRI for relative IRI resolution.
- **prefixes** (dict) - Optional - Default prefixes for query parsing.
- **use_default_graph_as_union** (bool) - Optional - Whether to look for triples in all dataset graphs.
- **default_graph** (NamedNode/BlankNode/DefaultGraph/list) - Optional - Graphs to use as default.
- **named_graphs** (list) - Optional - Named graphs available in the query.
- **substitutions** (dict) - Optional - Variable substitutions.
- **custom_functions** (dict) - Optional - Custom SPARQL functions.
- **custom_aggregate_functions** (dict) - Optional - Custom aggregate functions.

### Returns
- **result** (QuerySolutions/QueryBoolean/QueryTriples) - The query result.

### Raises
- **SyntaxError** - If the query is invalid.
- **OSError** - If an error occurs while reading the store.
```

--------------------------------

### Store.optimize

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Optimizes the database for future workload, recommended after batch operations.

```APIDOC
## Store.optimize()

### Description
Performs database optimization to improve performance for future operations.
```

--------------------------------

### QueryTriples.serialize

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Writes the SPARQL CONSTRUCT or DESCRIBE query results into a file or returns them as bytes.

```APIDOC
## QueryTriples.serialize

### Description
Writes the query results into a file or returns the serialized content as bytes. Supports formats including JSON-LD, N-Triples, N-Quads, Turtle, TriG, N3, and RDF/XML.

### Parameters
- **output** (IO[bytes] or str or os.PathLike[str] or None) - Optional - The binary I/O object or file path to write to. If None, returns a bytes buffer.
- **format** (RdfFormat or None) - Optional - The format of the RDF serialization. If None, the format is guessed from the file extension.

### Returns
- **bytes or None** - The serialized content if output is None, otherwise None.

### Raises
- **ValueError** - If the format is not supported.
- **OSError** - If a system error occurs while writing the file.
```

--------------------------------

### Add Quad to Store

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Insert a single quad into the RDF store and verify its presence by listing the store contents.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
>>> list(store)
[<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### Bulk load RDF data into the store

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Loads RDF serialization into the store efficiently without keeping the entire dataset in memory.

```python
>>> store = Store()
>>> store.bulk_load(input=b'<foo> <p> "1" .', format=RdfFormat.TURTLE, base_iri="http://example.com/", to_graph=NamedNode("http://example.com/g"))
>>> list(store)
[<Quad subject=<NamedNode value=http://example.com/foo> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### Serialize SPARQL Query Results

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Shows how to serialize query results to a specific format like JSON.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
>>> results = store.query("ASK { ?s ?p ?o }")
>>> results.serialize(format=QueryResultsFormat.JSON)
b'{"head":{},"boolean":true}'
```

--------------------------------

### serialize(output=None, format=None)

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Writes the SPARQL ASK query results into a file or returns them as bytes. Supports XML, JSON, CSV, and TSV formats.

```APIDOC
## serialize(output=None, format=None)

### Description
Writes the query results into a file or returns them as a bytes object. If no output is provided, the serialized content is returned as bytes.

### Parameters
- **output** (IO[bytes] or str or os.PathLike[str] or None) - Optional - The binary I/O object or file path to write to.
- **format** (QueryResultsFormat or None) - Optional - The format of the query results serialization (XML, JSON, CSV, or TSV). If None, the format is guessed from the file extension.

### Returns
- **bytes or None** - The serialized content if output is None, otherwise None.

### Raises
- **ValueError** - If the format is not supported.
- **OSError** - If a system error occurs during writing.
```

--------------------------------

### clear

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Removes all contents from the store.

```APIDOC
## clear()

### Description
Clears the store by removing all its contents.
```

--------------------------------

### Lookup RdfFormat from extension

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Identify an RdfFormat instance based on a provided file extension string.

```python
>>> RdfFormat.from_extension("nt")
<RdfFormat N-Triples>
```

--------------------------------

### Bulk Extend Store

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Efficiently add multiple quads to the store without loading the entire collection into memory.

```python
>>> store = Store()
>>> store.bulk_extend([Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g'))])
>>> list(store)
[<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### RdfFormat.from_extension(extension)

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Looks for a known format from a given file extension.

```APIDOC
## RdfFormat.from_extension(extension)

### Description
Looks for a known format from an extension. It supports some aliases.

### Parameters
- **extension** (str) - Required - The file extension to look up.

### Returns
- **RdfFormat** - The corresponding format if known, otherwise None.
```

--------------------------------

### bulk_load

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Loads RDF serialization into the store efficiently, suitable for large files.

```APIDOC
## bulk_load(input=None, format=None, *, path=None, base_iri=None, to_graph=None, lenient=False)

### Description
Loads RDF serialization into the store without keeping it all in memory. Designed for high performance with large files.

### Parameters
- **input** (bytes, str, IO[bytes], or IO[str]) - Optional - The data to read from.
- **format** (RdfFormat) - Optional - The format of the RDF serialization.
- **path** (str or os.PathLike) - Optional - The file path to read from.
- **base_iri** (str) - Optional - The base IRI for resolving relative IRIs.
- **to_graph** (NamedNode, BlankNode, or DefaultGraph) - Optional - The graph to store triples in.
- **lenient** (bool) - Optional - Skip some data validation during loading.
```

--------------------------------

### Check RdfFormat dataset support

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Determine if the format supports RDF datasets in addition to RDF graphs.

```python
>>> RdfFormat.N_TRIPLES.supports_datasets
False
>>> RdfFormat.N_QUADS.supports_datasets
True
```

--------------------------------

### read_only(path)

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Opens a read-only store from the specified disk path.

```APIDOC
## read_only(path)

### Description
Opens a read-only store from disk. Note that opening as read-only while another process is writing is undefined behavior.

### Parameters
- **path** (str) - Required - Path to the primary read-write instance data.

### Returns
- **store** (Store) - The opened store instance.

### Raises
- **OSError** - If the directory contains invalid data or is inaccessible.
```

--------------------------------

### pyoxigraph.QuerySolutions

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

An iterator of QuerySolution objects returned by a SPARQL SELECT query.

```APIDOC
## class pyoxigraph.QuerySolutions

### Description
An iterator of QuerySolution objects returned by a SPARQL SELECT query.

### Methods
- **serialize(output=None, format=None)** - Writes the query results into a file or returns a bytes buffer. Supported formats include XML, JSON, CSV, and TSV.
- **variables** (property) - Returns the ordered list of all variables that could appear in the query results.
```

--------------------------------

### Store.add(quad)

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Adds a single quad to the RDF store.

```APIDOC
## Store.add(quad)

### Description
Adds a single quad to the store.

### Parameters
- **quad** (Quad) - The quad object to be added to the dataset.
```

--------------------------------

### Store.bulk_extend(quads)

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Adds a collection of quads to the store efficiently.

```APIDOC
## Store.bulk_extend(quads)

### Description
Adds a set of quads to the store without loading them all into memory.

### Parameters
- **quads** (collections.abc.Iterable[Quad]) - An iterable of quad objects to add.
```

--------------------------------

### serialize(input, to, format)

Source: https://pyoxigraph.readthedocs.io/en/stable/_sources/io.rst.txt

Serializes RDF data from a store or iterator into a specific RDF format.

```APIDOC
## serialize(input, to, format)

### Description
Serializes RDF triples from an input source into a specified output format.

### Parameters
- **input** (Store or iterator) - The source of RDF triples to serialize.
- **to** (file or str) - The destination to write the serialized output.
- **format** (RdfFormat) - The target RDF format for serialization.
```

--------------------------------

### Add Named Graph

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Register a new named graph in the store and retrieve the list of all named graphs.

```python
>>> store = Store()
>>> store.add_graph(NamedNode('http://example.com/g'))
>>> list(store.named_graphs())
[<NamedNode value=http://example.com/g>]
```

--------------------------------

### pyoxigraph.parse

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Parses RDF graph and dataset serialization formats from strings, bytes, or file paths.

```APIDOC
## pyoxigraph.parse(input=None, format=None, *, path=None, base_iri=None, without_named_graphs=False, rename_blank_nodes=False, lenient=False)

### Description
Parses RDF graph and dataset serialization formats. Supports formats including JSON-LD, N-Triples, N-Quads, Turtle, TriG, N3, and RDF/XML.

### Parameters
- **input** (bytes or str or IO) - Optional - The data to read from.
- **format** (RdfFormat) - Optional - The format of the RDF serialization. If None, guessed from file extension.
- **path** (str or os.PathLike) - Optional - The file path to read from.
- **base_iri** (str) - Optional - The base IRI used to resolve relative IRIs.
- **without_named_graphs** (bool) - Optional - Fails if parsing a named graph.
- **rename_blank_nodes** (bool) - Optional - Renames blank node identifiers to random IDs.
- **lenient** (bool) - Optional - Skips some data validation for faster parsing.

### Returns
- **QuadParser** - An iterator of RDF triples or quads.

### Errors
- **ValueError** - If the format is not supported.
- **SyntaxError** - If the provided data is invalid.
- **OSError** - If a system error occurs while reading the file.
```

--------------------------------

### Serialize Dataset to N-Quads

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Use the str function to obtain an N-Quads serialization of the dataset.

```python
>>> str(Dataset([Quad(NamedNode('http://example.com/s'), NamedNode('http://example.com/p'), NamedNode('http://example.com/o'), NamedNode('http://example.com/g'))]))
'<http://example.com/s> <http://example.com/p> <http://example.com/o> <http://example.com/g> .\n'
```

--------------------------------

### Store.quads_for_pattern

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Queries the store for quads matching a specific pattern.

```APIDOC
## Store.quads_for_pattern(subject, predicate, object, graph_name=None)

### Description
Looks for quads matching the provided subject, predicate, object, and graph name patterns.

### Parameters
- **subject** (NamedNode or BlankNode or Triple) - Optional - The quad subject.
- **predicate** (NamedNode) - Optional - The quad predicate.
- **object** (NamedNode or BlankNode or Literal or Triple) - Optional - The quad object.
- **graph_name** (NamedNode or BlankNode or DefaultGraph) - Optional - The quad graph name.
```

--------------------------------

### RdfFormat.from_media_type(media_type)

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Looks for a known format from a given media type.

```APIDOC
## RdfFormat.from_media_type(media_type)

### Description
Looks for a known format from a media type. It supports some media type aliases.

### Parameters
- **media_type** (str) - Required - The media type string.

### Returns
- **RdfFormat** - The corresponding format if known, otherwise None.
```

--------------------------------

### Add Quad to Dataset

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Add a quad to the dataset and verify its presence.

```python
>>> quad = Quad(NamedNode('http://example.com/s'), NamedNode('http://example.com/p'), NamedNode('http://example.com/o'), NamedNode('http://example.com/g'))
>>> dataset = Dataset()
>>> dataset.add(quad)
>>> quad in dataset
True
```

--------------------------------

### parse(input, format, base=None, to=None)

Source: https://pyoxigraph.readthedocs.io/en/stable/_sources/io.rst.txt

Parses RDF data from a file or string into a store or a list of triples.

```APIDOC
## parse(input, format, base=None, to=None)

### Description
Parses RDF data from a given input source into a specified destination format or store.

### Parameters
- **input** (file or str) - The RDF data to parse.
- **format** (RdfFormat) - The format of the input RDF data.
- **base** (str, optional) - The base IRI for relative IRI resolution.
- **to** (Store, optional) - The destination store to load the triples into.
```

--------------------------------

### Serialize and access BlankNode values

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Shows serialization of a BlankNode and how to access its identifier.

```python
>>> str(BlankNode('ex'))
'_:ex'
```

```python
>>> BlankNode("ex").value
'ex'
```

--------------------------------

### Store.flush

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Ensures all pending writes are saved to disk.

```APIDOC
## Store.flush

### Description
Flushes all buffers to ensure that all writes are persisted on disk.
```

--------------------------------

### Query quads by pattern

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Searches for quads matching a specific pattern, allowing wildcards by passing None for parameters.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
>>> list(store.quads_for_pattern(NamedNode('http://example.com'), None, None, None))
[<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### Serialize Quad to String

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Serializes a Quad object into a string format compatible with NTriples, Turtle, and SPARQL.

```python
>>> str(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
'<http://example.com> <http://example.com/p> "1" <http://example.com/g>'
```

```python
>>> str(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), DefaultGraph()))
'<http://example.com> <http://example.com/p> "1"'
```

--------------------------------

### Store.add_graph(graph_name)

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Adds a new named graph to the store.

```APIDOC
## Store.add_graph(graph_name)

### Description
Adds a named graph to the store.

### Parameters
- **graph_name** (NamedNode, BlankNode, or DefaultGraph) - The identifier for the graph to add.
```

--------------------------------

### dump

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Dumps store quads or triples into a file or output stream.

```APIDOC
## dump(output=None, format=None, *, from_graph=None, prefixes=None, base_iri=None)

### Description
Dumps the store quads or triples into a file or output stream.
```

--------------------------------

### Check RdfFormat RDF-star support

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Determine if the format supports RDF-star quoted triples.

```python
>>> RdfFormat.N_TRIPLES.supports_rdf_star
True
>>> RdfFormat.RDF_XML.supports_rdf_star
False
```

--------------------------------

### Access Literal properties

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Demonstrates accessing the datatype, direction, language, and value properties of a Literal object.

```python
>>> Literal('11', datatype=NamedNode('http://www.w3.org/2001/XMLSchema#integer')).datatype
<NamedNode value=http://www.w3.org/2001/XMLSchema#integer>
>>> Literal('example').datatype
<NamedNode value=http://www.w3.org/2001/XMLSchema#string>
>>> Literal('example', language='en').datatype
<NamedNode value=http://www.w3.org/1999/02/22-rdf-syntax-ns#langString>
```

```python
>>> Literal('example', language='en', direction=BaseDirection.LTR).direction
<LtrBaseDirection>
>>> Literal('example', language='en').direction
```

```python
>>> Literal('example', language='en').language
'en'
>>> Literal('example').language
```

```python
>>> Literal("example").value
'example'
```

--------------------------------

### Execute INSERT DATA update

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Adds data to the store using a SPARQL INSERT DATA operation.

```python
>>> store = Store()
>>> store.update('INSERT DATA { <http://example.com> <http://example.com/p> "1" }')
>>> list(store)
[<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<DefaultGraph>>]
```

--------------------------------

### pyoxigraph.serialize

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Serializes an RDF graph or dataset into a specified format.

```APIDOC
## pyoxigraph.serialize(input, output=None, format=None, *, prefixes=None, base_iri=None)

### Description
Serializes an RDF graph or dataset. It supports formats including JSON-LD, N-Triples, N-Quads, Turtle, TriG, N3, and RDF/XML.

### Parameters
- **input** (collections.abc.Iterable[Triple] or collections.abc.Iterable[Quad]) - Required - The RDF triples and quads to serialize.
- **output** (IO[bytes] or str or os.PathLike[str] or None) - Optional - The binary I/O object or file path to write to. If None, returns a bytes buffer.
- **format** (RdfFormat or None) - Optional - The format of the RDF serialization. If None, guessed from file extension.
- **prefixes** (dict[str, str] or None) - Optional - Prefixes used in the serialization if supported by the format.
- **base_iri** (str or None) - Optional - The base IRI used in the serialization if supported by the format.

### Returns
- **bytes or None** - Returns bytes with the serialization if output is None, otherwise returns None.

### Raises
- **ValueError** - If the format is not supported.
- **TypeError** - If a triple is given during a quad format serialization or vice versa.
- **OSError** - If a system error occurs while writing the file.
```

--------------------------------

### Serialize Store to NQuads

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Convert the entire contents of the RDF store into an NQuads string representation.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
>>> str(store)
'<http://example.com> <http://example.com/p> "1" <http://example.com/g> .\n'
```

--------------------------------

### Access Triple Components

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Retrieves the specific components of a Triple instance.

```python
>>> Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')).object
<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>>
```

```python
>>> Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')).predicate
<NamedNode value=http://example.com/p>
```

```python
>>> Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')).subject
<NamedNode value=http://example.com>
```

--------------------------------

### Serialize and access NamedNode values

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Demonstrates how to serialize a NamedNode to a string and retrieve its underlying IRI value.

```python
>>> str(NamedNode('http://example.com'))
'<http://example.com>'
```

```python
>>> NamedNode("http://example.com").value
'http://example.com'
```

--------------------------------

### RdfFormat

Source: https://pyoxigraph.readthedocs.io/en/stable/_sources/io.rst.txt

Enumeration of supported RDF serialization formats.

```APIDOC
## RdfFormat

### Description
Represents the supported RDF formats for parsing and serialization operations.
```

--------------------------------

### Access RdfFormat media type property

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Retrieve the IANA media type for the format.

```python
>>> RdfFormat.N_TRIPLES.media_type
'application/n-triples'
```

--------------------------------

### Access Quad Properties

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Retrieves specific components or the underlying triple from a Quad instance.

```python
>>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).graph_name
<NamedNode value=http://example.com/g>
```

```python
>>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).object
<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>>
```

```python
>>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).predicate
<NamedNode value=http://example.com/p>
```

```python
>>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).subject
<NamedNode value=http://example.com>
```

```python
>>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).triple
<Triple subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>>>
```

--------------------------------

### Serialize RDF to bytes

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Serializes a list of triples into Turtle format and returns the result as a bytes object.

```python
>>> serialize([Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'))], format=RdfFormat.TURTLE)
b'<http://example.com> <http://example.com/p> "1" .\n'
```

--------------------------------

### pyoxigraph.QuerySolution

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Represents a row in a SPARQL SELECT query result, associating variables with terms.

```APIDOC
## class pyoxigraph.QuerySolution

### Description
Tuple associating variables and terms that are the result of a SPARQL SELECT query. It can be indexed by variable name (Variable or str) or by position (int).
```

--------------------------------

### Lookup RdfFormat from media type

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Identify an RdfFormat instance based on a provided media type string, including aliases.

```python
>>> RdfFormat.from_media_type("text/turtle; charset=utf-8")
<RdfFormat Turtle>
```

--------------------------------

### Extend store with quads

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Adds a collection of quads to the store in a single transactional operation.

```python
>>> store = Store()
>>> store.extend([Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g'))])
>>> list(store)
[<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### Access RdfFormat media type

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Retrieve the IANA media type for a specific RDF format.

```python
>>> RdfFormat.N3.media_type
'text/n3'
```

--------------------------------

### Access RdfFormat name

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Retrieve the human-readable name of the format.

```python
>>> RdfFormat.N_TRIPLES.name
'N-Triples'
```

--------------------------------

### Serialize a Triple to String

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Converts a Triple instance into an NTriples, Turtle, and SPARQL compatible string format.

```python
>>> str(Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
'<http://example.com> <http://example.com/p> "1"'
```

--------------------------------

### Query Quads by Object

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Retrieve an iterator of quads that match a specific object.

```python
>>> store = Dataset([Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g'))])
>>> list(store.quads_for_object(Literal('1')))
[<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### Store.update()

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Executes a SPARQL 1.1 update operation on the store. Updates are applied transactionally, ensuring that either the entire operation succeeds or no changes are written.

```APIDOC
## Store.update(update, *, base_iri=None, prefixes=None, custom_functions=None, custom_aggregate_functions=None)

### Description
Executes a SPARQL 1.1 update. Updates are applied in a transactional manner: either the full operation succeeds, or nothing is written to the database.

### Parameters
- **update** (str) - Required - The SPARQL update string to execute.
- **base_iri** (str or None) - Optional - The base IRI used to resolve relative IRIs in the update.
- **prefixes** (dict[str, str] or None) - Optional - A dictionary of default prefixes (prefix name to prefix IRI).
- **custom_functions** (dict[NamedNode, Callable] or None) - Optional - Dictionary mapping custom function names to their definitions.
- **custom_aggregate_functions** (dict[NamedNode, Callable] or None) - Optional - Dictionary mapping custom aggregate functions to their definitions.

### Returns
- **None**

### Raises
- **SyntaxError** - If the provided update is invalid.
- **OSError** - If an error occurs while reading the store.
```

--------------------------------

### Access RdfFormat file extension

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Retrieve the IANA-registered file extension for a specific RDF format.

```python
>>> RdfFormat.N_TRIPLES.file_extension
'nt'
```

--------------------------------

### Canonicalize Dataset

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Canonicalize the dataset by renaming blank nodes using a specified algorithm.

```python
>>> d1 = Dataset([Quad(BlankNode(), NamedNode('http://example.com/p'), BlankNode())])
>>> d2 = Dataset([Quad(BlankNode(), NamedNode('http://example.com/p'), BlankNode())])
>>> d1 == d2
False
>>> d1.canonicalize(CanonicalizationAlgorithm.UNSTABLE)
>>> d2.canonicalize(CanonicalizationAlgorithm.UNSTABLE)
>>> d1 == d2
True
```

--------------------------------

### Check for named graph existence

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Verifies if a specific named graph exists within the store.

```python
>>> store = Store()
>>> store.add_graph(NamedNode('http://example.com/g'))
>>> store.contains_named_graph(NamedNode('http://example.com/g'))
True
```

--------------------------------

### Clear the store contents

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Removes all quads and data from the store instance.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
>>> store.clear()
>>> list(store)
[]
>>> list(store.named_graphs())
[]
```

--------------------------------

### pyoxigraph.QueryResultsFormat

Source: https://pyoxigraph.readthedocs.io/en/stable/sparql.html

Utility class representing SPARQL query results serialization formats.

```APIDOC
## pyoxigraph.QueryResultsFormat

### Description
Represents supported SPARQL query results serialization formats (XML, JSON, CSV, TSV).

### Methods
- **from_extension(extension: str)**: Returns a QueryResultsFormat for a given file extension.
- **from_media_type(media_type: str)**: Returns a QueryResultsFormat for a given media type.

### Properties
- **file_extension** (str): The IANA-registered file extension.
- **iri** (str): The format canonical IRI.
- **media_type** (str): The format IANA media type.
- **name** (str): The format name.
```

--------------------------------

### Query quads by predicate in Dataset

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Retrieves an iterator of quads matching a specific predicate.

```python
>>> store = Dataset([Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g'))])
>>> list(store.quads_for_predicate(NamedNode('http://example.com/p')))
[<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### Destructure Quad Components

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Unpacks a Quad object into its constituent subject, predicate, object, and graph name components.

```python
>>> (s, p, o, g) = Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g'))
```

--------------------------------

### Access RdfFormat canonical IRI

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Retrieve the canonical IRI for the format according to the Unique URIs for file formats registry.

```python
>>> RdfFormat.N_TRIPLES.iri
'http://www.w3.org/ns/formats/N-Triples'
```

--------------------------------

### Remove a quad from the store

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Deletes a specific quad from the store instance.

```python
>>> store = Store()
>>> quad = Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g'))
>>> store.add(quad)
>>> store.remove(quad)
>>> list(store)
[]
```

--------------------------------

### Query Quads by Graph Name

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Retrieve an iterator of quads associated with a specific graph name.

```python
>>> store = Dataset([Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g'))])
>>> list(store.quads_for_graph_name(NamedNode('http://example.com/g')))
[<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### Query quads by subject in Dataset

Source: https://pyoxigraph.readthedocs.io/en/stable/model.html

Retrieves an iterator of quads matching a specific subject.

```python
>>> store = Dataset([Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g'))])
>>> list(store.quads_for_subject(NamedNode('http://example.com')))
[<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
```

--------------------------------

### Retrieve named graphs

Source: https://pyoxigraph.readthedocs.io/en/stable/store.html

Retrieves an iterator over all named graphs currently present in the store.

```python
>>> store = Store()
>>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
>>> list(store.named_graphs())
[<NamedNode value=http://example.com/g>]
```

--------------------------------

### Serialize RDF to a BytesIO stream

Source: https://pyoxigraph.readthedocs.io/en/stable/io.html

Writes serialized RDF data to a BytesIO object with specified prefixes and base IRI.

```python
>>> import io
>>> output = io.BytesIO()
>>> serialize([Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'))], output, RdfFormat.TURTLE, prefixes={"ex": "http://example.com/"}, base_iri="http://example.com")
>>> output.getvalue()
b'@base <http://example.com> .\n@prefix ex: </> .\n<> ex:p "1" .\n'
```
Tokens:
Raw