parent
427d675c9b
commit
77edc05ced
@ -1 +0,0 @@ |
|||||||
Subproject commit aecd720a5fc2bf7eae9649265a017b68605a8c87 |
|
||||||
@ -1,38 +0,0 @@ |
|||||||
[package] |
|
||||||
name = "pyoxigraph" |
|
||||||
version.workspace = true |
|
||||||
authors.workspace = true |
|
||||||
license.workspace = true |
|
||||||
readme = "README.md" |
|
||||||
keywords = ["RDF", "SPARQL", "graph-database", "database"] |
|
||||||
repository = "https://github.com/oxigraph/oxigraph/tree/main/python" |
|
||||||
homepage = "https://pyoxigraph.readthedocs.io/" |
|
||||||
description = "Python bindings of Oxigraph, a SPARQL database and RDF toolkit" |
|
||||||
edition.workspace = true |
|
||||||
rust-version.workspace = true |
|
||||||
publish = false |
|
||||||
|
|
||||||
[lib] |
|
||||||
crate-type = ["cdylib"] |
|
||||||
name = "pyoxigraph" |
|
||||||
doctest = false |
|
||||||
doc = false |
|
||||||
|
|
||||||
[features] |
|
||||||
abi3 = ["pyo3/abi3-py38"] |
|
||||||
rocksdb-pkg-config = ["oxigraph/rocksdb-pkg-config"] |
|
||||||
|
|
||||||
[dependencies] |
|
||||||
pyo3 = { workspace = true, features = ["extension-module"] } |
|
||||||
|
|
||||||
[target.'cfg(any(target_family = "windows", target_os = "macos", target_os = "ios"))'.dependencies] |
|
||||||
oxigraph = { workspace = true, features = ["http-client-native-tls"] } |
|
||||||
|
|
||||||
[target.'cfg(target_family = "wasm")'.dependencies] |
|
||||||
oxigraph.workspace = true |
|
||||||
|
|
||||||
[target.'cfg(not(any(target_family = "windows", target_os = "macos", target_os = "ios", target_family = "wasm")))'.dependencies] |
|
||||||
oxigraph = { workspace = true, features = ["http-client-rustls-native"] } |
|
||||||
|
|
||||||
[lints] |
|
||||||
workspace = true |
|
||||||
@ -1,83 +0,0 @@ |
|||||||
# Pyoxigraph (Oxigraph for Python) |
|
||||||
|
|
||||||
[](https://pypi.org/project/pyoxigraph/) |
|
||||||
[](https://anaconda.org/conda-forge/pyoxigraph) |
|
||||||
 |
|
||||||
 |
|
||||||
[](https://github.com/oxigraph/oxigraph/actions) |
|
||||||
[](https://gitter.im/oxigraph/community) |
|
||||||
|
|
||||||
Pyoxigraph is a graph database library implementing the [SPARQL](https://www.w3.org/TR/sparql11-overview/) standard. |
|
||||||
It is a Python library written on top of [Oxigraph](https://crates.io/crates/oxigraph). |
|
||||||
|
|
||||||
Pyoxigraph offers two stores with [SPARQL 1.1](https://www.w3.org/TR/sparql11-overview/) capabilities. |
|
||||||
One of the store is in-memory, and the other one is disk based. |
|
||||||
|
|
||||||
It also provides a set of utility functions for reading, writing and processing RDF files in |
|
||||||
[Turtle](https://www.w3.org/TR/turtle/), |
|
||||||
[TriG](https://www.w3.org/TR/trig/), |
|
||||||
[N-Triples](https://www.w3.org/TR/n-triples/), |
|
||||||
[N-Quads](https://www.w3.org/TR/n-quads/) and |
|
||||||
[RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/). |
|
||||||
|
|
||||||
Pyoxigraph is distributed [on Pypi](https://pypi.org/project/pyoxigraph/) and [on conda-forge](https://anaconda.org/conda-forge/pyoxigraph). |
|
||||||
Run `pip install pyoxigraph` to install it. |
|
||||||
|
|
||||||
There exists also a small library providing [rdflib](https://rdflib.readthedocs.io) stores using pyoxigraph: [oxrdflib](https://github.com/oxigraph/oxrdflib). |
|
||||||
|
|
||||||
Pyoxigraph documentation is [available on the Oxigraph website](https://pyoxigraph.readthedocs.io/). |
|
||||||
|
|
||||||
## Build the development version |
|
||||||
|
|
||||||
To build and install the development version of pyoxigraph you need to clone this git repository including submodules (`git clone --recursive https://github.com/oxigraph/oxigraph.git`) |
|
||||||
and to run `pip install .` in the `python` directory (the one this README is in). |
|
||||||
|
|
||||||
Note that by default the installation will not use [cpython stable ABI](https://docs.python.org/3/c-api/stable.html). |
|
||||||
Use `--features abi3` feature to use cpython stable ABI. |
|
||||||
|
|
||||||
## Help |
|
||||||
|
|
||||||
Feel free to use [GitHub discussions](https://github.com/oxigraph/oxigraph/discussions) or [the Gitter chat](https://gitter.im/oxigraph/community) to ask questions or talk about Oxigraph. |
|
||||||
[Bug reports](https://github.com/oxigraph/oxigraph/issues) are also very welcome. |
|
||||||
|
|
||||||
If you need advanced support or are willing to pay to get some extra features, feel free to reach out to [Tpt](https://github.com/Tpt). |
|
||||||
|
|
||||||
## How to contribute |
|
||||||
|
|
||||||
Pyoxigraph is written in Rust using [PyO3](https://github.com/PyO3/pyo3). |
|
||||||
|
|
||||||
Pyoxigraph is built using [Maturin](https://github.com/PyO3/maturin). |
|
||||||
Maturin could be installed using the `pip install 'maturin>=0.9,<0.10'`. |
|
||||||
To install a development version of Oxigraph just run `maturin develop` in this README directory. |
|
||||||
|
|
||||||
### Tests |
|
||||||
|
|
||||||
The Python bindings tests are written in Python. |
|
||||||
To run them use `python -m unittest` in the `tests` directory. |
|
||||||
|
|
||||||
### Docs |
|
||||||
|
|
||||||
The Sphinx documentation can be generated and viewed in the browser using the following command: |
|
||||||
|
|
||||||
``` |
|
||||||
sphinx-autobuild docs docs/_build/html |
|
||||||
``` |
|
||||||
|
|
||||||
Note that you will need to have [sphinx-autobuild](https://pypi.org/project/sphinx-autobuild/) installed. |
|
||||||
|
|
||||||
Alternatively, you can use `sphinx-build` with Python's `http.server` to achieve the same thing. |
|
||||||
|
|
||||||
## License |
|
||||||
|
|
||||||
This project is licensed under either of |
|
||||||
|
|
||||||
- Apache License, Version 2.0, ([LICENSE-APACHE](../LICENSE-APACHE) or |
|
||||||
http://www.apache.org/licenses/LICENSE-2.0) |
|
||||||
- MIT license ([LICENSE-MIT](../LICENSE-MIT) or |
|
||||||
http://opensource.org/licenses/MIT) |
|
||||||
|
|
||||||
at your option. |
|
||||||
|
|
||||||
### Contribution |
|
||||||
|
|
||||||
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Oxigraph by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions. |
|
||||||
@ -1,38 +0,0 @@ |
|||||||
import datetime |
|
||||||
import sys |
|
||||||
from pathlib import Path |
|
||||||
|
|
||||||
import pyoxigraph |
|
||||||
|
|
||||||
sys.path.insert(0, str(Path(__file__).parent.parent.absolute())) |
|
||||||
|
|
||||||
# -- Project information ----------------------------------------------------- |
|
||||||
|
|
||||||
project = "pyoxigraph" |
|
||||||
copyright = f"{datetime.date.today().year}, Oxigraph contributors" |
|
||||||
author = pyoxigraph.__author__ |
|
||||||
version = pyoxigraph.__version__ |
|
||||||
release = pyoxigraph.__version__ |
|
||||||
|
|
||||||
# -- General configuration --------------------------------------------------- |
|
||||||
|
|
||||||
extensions = ["sphinx.ext.autodoc", "sphinx.ext.doctest", "sphinx.ext.intersphinx"] |
|
||||||
|
|
||||||
exclude_patterns = ["build", "Thumbs.db", ".DS_Store"] |
|
||||||
|
|
||||||
# -- Options for HTML output ------------------------------------------------- |
|
||||||
|
|
||||||
html_theme = "furo" |
|
||||||
html_static_path = [] |
|
||||||
html_logo = "../../logo.svg" |
|
||||||
html_favicon = "../../logo.svg" |
|
||||||
html_theme_options = {"body_max_width": None} |
|
||||||
html_baseurl = "https://pyoxigraph.readthedocs.io/en/stable/" |
|
||||||
|
|
||||||
# -- Options for doctests ------------------------------------------------- |
|
||||||
|
|
||||||
doctest_global_setup = "from pyoxigraph import *\nimport io" |
|
||||||
|
|
||||||
# -- Options for intersphinx ------------------------------------------------- |
|
||||||
|
|
||||||
intersphinx_mapping = {"python": ("https://docs.python.org/3", None)} |
|
||||||
@ -1,79 +0,0 @@ |
|||||||
pyoxigraph |release| |
|
||||||
==================== |
|
||||||
|
|
||||||
.. image:: https://img.shields.io/pypi/v/pyoxigraph |
|
||||||
:alt: PyPI |
|
||||||
:target: https://pypi.org/project/pyoxigraph/ |
|
||||||
.. image:: https://img.shields.io/conda/vn/conda-forge/pyoxigraph |
|
||||||
:alt: conda-forge |
|
||||||
:target: https://anaconda.org/conda-forge/pyoxigraph |
|
||||||
.. image:: https://img.shields.io/pypi/implementation/pyoxigraph |
|
||||||
:alt: PyPI - Implementation |
|
||||||
.. image:: https://img.shields.io/pypi/pyversions/pyoxigraph |
|
||||||
:alt: PyPI - Python Version |
|
||||||
.. image:: https://img.shields.io/pypi/l/pyoxigraph |
|
||||||
:alt: PyPI - License |
|
||||||
|
|
||||||
|
|
||||||
Pyoxigraph is a Python graph database library implementing the `SPARQL <https://www.w3.org/TR/sparql11-overview/>`_ standard. |
|
||||||
|
|
||||||
It is built on top of `Oxigraph <https://crates.io/crates/oxigraph>`_ using `PyO3 <https://pyo3.rs/>`_. |
|
||||||
|
|
||||||
It also provides a set of utility functions for reading, writing, and processing RDF files in |
|
||||||
`Turtle <https://www.w3.org/TR/turtle/>`_, |
|
||||||
`TriG <https://www.w3.org/TR/trig/>`_, |
|
||||||
`N-Triples <https://www.w3.org/TR/n-triples/>`_, |
|
||||||
`N-Quads <https://www.w3.org/TR/n-quads/>`_ and |
|
||||||
`RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_. |
|
||||||
|
|
||||||
Pyoxigraph is distributed `on Pypi <https://pypi.org/project/pyoxigraph/>`_ and `on conda-forge <https://anaconda.org/conda-forge/pyoxigraph>`_. |
|
||||||
|
|
||||||
There is also a small library providing a `rdflib <https://rdflib.readthedocs.io>`_ store using pyoxigraph: `oxrdflib <https://github.com/oxigraph/oxrdflib>`_. |
|
||||||
|
|
||||||
Oxigraph and pyoxigraph source code are on `GitHub <https://github.com/oxigraph/oxigraph/tree/main/python>`_. |
|
||||||
|
|
||||||
|
|
||||||
Installation |
|
||||||
"""""""""""" |
|
||||||
|
|
||||||
Pyoxigraph is distributed on `Pypi <https://pypi.org/project/pyoxigraph/>`_. |
|
||||||
|
|
||||||
To install it, run the usual ``pip install pyoxigraph`` |
|
||||||
|
|
||||||
|
|
||||||
Example |
|
||||||
""""""" |
|
||||||
|
|
||||||
Insert the triple ``<http://example/> <http://schema.org/name> "example"`` and print the name of ``<http://example/>`` in SPARQL: |
|
||||||
|
|
||||||
:: |
|
||||||
|
|
||||||
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) |
|
||||||
|
|
||||||
|
|
||||||
Table of contents |
|
||||||
""""""""""""""""" |
|
||||||
|
|
||||||
.. toctree:: |
|
||||||
|
|
||||||
model |
|
||||||
io |
|
||||||
store |
|
||||||
sparql |
|
||||||
migration |
|
||||||
|
|
||||||
|
|
||||||
Help |
|
||||||
"""" |
|
||||||
|
|
||||||
Feel free to use `GitHub discussions <https://github.com/oxigraph/oxigraph/discussions>`_ or `the Gitter chat <https://gitter.im/oxigraph/community>`_ to ask questions or talk about Oxigraph. |
|
||||||
`Bug reports <https://github.com/oxigraph/oxigraph/issues>`_ are also very welcome. |
|
||||||
|
|
||||||
If you need advanced support or are willing to pay to get some extra features, feel free to reach out to `Tpt <https://github.com/Tpt>`_. |
|
||||||
@ -1,21 +0,0 @@ |
|||||||
RDF Parsing and Serialization |
|
||||||
============================= |
|
||||||
.. py:currentmodule:: pyoxigraph |
|
||||||
|
|
||||||
Oxigraph provides functions to parse and serialize RDF files: |
|
||||||
|
|
||||||
|
|
||||||
Parsing |
|
||||||
""""""" |
|
||||||
.. autofunction:: parse |
|
||||||
|
|
||||||
|
|
||||||
Serialization |
|
||||||
""""""""""""" |
|
||||||
.. autofunction:: serialize |
|
||||||
|
|
||||||
|
|
||||||
Formats |
|
||||||
""""""" |
|
||||||
.. autoclass:: RdfFormat |
|
||||||
:members: |
|
||||||
@ -1,47 +0,0 @@ |
|||||||
Migration Guide |
|
||||||
=============== |
|
||||||
|
|
||||||
From 0.3 to 0.4 |
|
||||||
""""""""""""""" |
|
||||||
|
|
||||||
* Python 3.7 and ``musllinux_1_1`` support have been removed. |
|
||||||
* :py:class:`OSError` is now raised instead of :py:class:`IOError` on OS errors. |
|
||||||
* The ``mime_type`` parameter have been renamed to ``format`` in I/O functions. |
|
||||||
Using :py:class:`RdfFormat` is recommended to describe formats. |
|
||||||
* Boolean SPARQL results are now encoded with the :py:class:`QueryBoolean` class and not a simple :py:class:`bool`. |
|
||||||
* A `path` parameter has been added to all I/O method to read from a file. |
|
||||||
The existing ``input`` parameter now consider :py:class:`str` values to be a serialization to parse. |
|
||||||
For example, ``parse(path="foo.ttl")`` will parse the file ``foo.ttl`` whereas ``parse("foo", format=RdfFormat.N_TRIPLES)`` will parse a N-Triples file which content is ``foo``. |
|
||||||
|
|
||||||
|
|
||||||
From 0.2 to 0.3 |
|
||||||
""""""""""""""" |
|
||||||
|
|
||||||
* Python 3.6 and ``manylinux2010`` (`PEP 571 <https://www.python.org/dev/peps/pep-0571/>`_) support have been removed. The new minimal versions are Python 3.7 and ``manylinux2014`` (`PEP 599 <https://www.python.org/dev/peps/pep-0599/>`_). |
|
||||||
* The on-disk storage system has been rebuilt on top of `RocksDB <http://rocksdb.org/>`_. |
|
||||||
It is now implemented by the :py:class:`.Store` class that keeps the same API as the late :py:class:`.SledStore` class. |
|
||||||
|
|
||||||
To migrate you have to dump the store content using pyoxigraph **0.2** and the following code: |
|
||||||
|
|
||||||
.. code-block:: python |
|
||||||
|
|
||||||
from pyoxigraph import SledStore |
|
||||||
store = SledStore('MY_STORAGE_PATH') |
|
||||||
with open('temp_file.nq', 'wb') as fp: |
|
||||||
store.dump(fp, "application/n-quads") |
|
||||||
|
|
||||||
And then upgrade to pyoxigraph **0.3** and run: |
|
||||||
|
|
||||||
.. code-block:: 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") |
|
||||||
|
|
||||||
* The in-memory storage class :py:class:`.MemoryStore` has been merged into the :py:class:`.Store` class that provides the exact same API as the late :py:class:`.MemoryStore`. |
|
||||||
On platforms other than Linux, a temporary directory is created when opening the :py:class:`.Store` and automatically removed when it is garbage collected. No data is written in this directory. |
|
||||||
* :py:class:`.Store` operations are now transactional using the "repeatable read" isolation level: |
|
||||||
the store only exposes changes that have been "committed" (i.e. no partial writes) |
|
||||||
and the exposed state does not change for the complete duration of a read operation (e.g. a SPARQL query) or a read/write operation (e.g. a SPARQL update). |
|
||||||
* `RDF-star <https://w3c.github.io/rdf-star/cg-spec/2021-12-17.html>`_ is now supported (including serialization formats and SPARQL-star). :py:class:`.Triple` can now be used in :py:attr:`.Triple.object`, :py:attr:`.Triple.object`, :py:attr:`.Quad.subject` and :py:attr:`.Quad.object`. |
|
||||||
@ -1,47 +0,0 @@ |
|||||||
RDF Model |
|
||||||
========= |
|
||||||
.. py:currentmodule:: pyoxigraph |
|
||||||
|
|
||||||
Oxigraph provides python classes to represents basic RDF concepts: |
|
||||||
|
|
||||||
|
|
||||||
`IRIs <https://www.w3.org/TR/rdf11-concepts/#dfn-iri>`_ |
|
||||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
|
||||||
.. autoclass:: NamedNode |
|
||||||
:members: |
|
||||||
|
|
||||||
|
|
||||||
`Blank Nodes <https://www.w3.org/TR/rdf11-concepts/#dfn-blank-node>`_ |
|
||||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
|
||||||
.. autoclass:: BlankNode |
|
||||||
:members: |
|
||||||
|
|
||||||
|
|
||||||
`Literals <https://www.w3.org/TR/rdf11-concepts/#dfn-literal>`_ |
|
||||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
|
||||||
.. autoclass:: Literal |
|
||||||
:members: |
|
||||||
|
|
||||||
|
|
||||||
`Triples <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple>`_ |
|
||||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
|
||||||
.. autoclass:: Triple |
|
||||||
:members: |
|
||||||
|
|
||||||
|
|
||||||
Quads (`triples <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple>`_ in a `RDF dataset <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset>`_) |
|
||||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
|
||||||
.. autoclass:: Quad |
|
||||||
:members: |
|
||||||
|
|
||||||
.. autoclass:: DefaultGraph |
|
||||||
:members: |
|
||||||
|
|
||||||
|
|
||||||
`Datasets <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset>`_ |
|
||||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
|
||||||
.. autoclass:: Dataset |
|
||||||
:members: |
|
||||||
|
|
||||||
.. autoclass:: CanonicalizationAlgorithm |
|
||||||
:members: |
|
||||||
@ -1,33 +0,0 @@ |
|||||||
SPARQL utility objects |
|
||||||
====================== |
|
||||||
.. py:currentmodule:: pyoxigraph |
|
||||||
|
|
||||||
Oxigraph provides also some utilities related to SPARQL queries: |
|
||||||
|
|
||||||
Variable |
|
||||||
"""""""" |
|
||||||
.. autoclass:: Variable |
|
||||||
:members: |
|
||||||
|
|
||||||
``SELECT`` solutions |
|
||||||
"""""""""""""""""""" |
|
||||||
.. autoclass:: QuerySolutions |
|
||||||
:members: |
|
||||||
.. autoclass:: QuerySolution |
|
||||||
:members: |
|
||||||
|
|
||||||
``ASK`` results |
|
||||||
""""""""""""""" |
|
||||||
.. autoclass:: QueryBoolean |
|
||||||
:members: |
|
||||||
|
|
||||||
``CONSTRUCT`` results |
|
||||||
""""""""""""""""""""" |
|
||||||
.. autoclass:: QueryTriples |
|
||||||
:members: |
|
||||||
|
|
||||||
Query results parsing |
|
||||||
""""""""""""""""""""" |
|
||||||
.. autofunction:: parse_query_results |
|
||||||
.. autoclass:: QueryResultsFormat |
|
||||||
:members: |
|
||||||
@ -1,6 +0,0 @@ |
|||||||
RDF Store |
|
||||||
========= |
|
||||||
.. py:currentmodule:: pyoxigraph |
|
||||||
|
|
||||||
.. autoclass:: Store |
|
||||||
:members: |
|
||||||
@ -1,438 +0,0 @@ |
|||||||
import argparse |
|
||||||
import ast |
|
||||||
import importlib |
|
||||||
import inspect |
|
||||||
import logging |
|
||||||
import re |
|
||||||
import subprocess |
|
||||||
from functools import reduce |
|
||||||
from typing import Any, Dict, List, Mapping, Optional, Set, Tuple, Union |
|
||||||
|
|
||||||
|
|
||||||
def path_to_type(*elements: str) -> ast.AST: |
|
||||||
base: ast.AST = ast.Name(id=elements[0], ctx=ast.Load()) |
|
||||||
for e in elements[1:]: |
|
||||||
base = ast.Attribute(value=base, attr=e, ctx=ast.Load()) |
|
||||||
return base |
|
||||||
|
|
||||||
|
|
||||||
OBJECT_MEMBERS = dict(inspect.getmembers(object)) |
|
||||||
BUILTINS: Dict[str, Union[None, Tuple[List[ast.AST], ast.AST]]] = { |
|
||||||
"__annotations__": None, |
|
||||||
"__bool__": ([], path_to_type("bool")), |
|
||||||
"__bytes__": ([], path_to_type("bytes")), |
|
||||||
"__class__": None, |
|
||||||
"__contains__": ([path_to_type("typing", "Any")], path_to_type("bool")), |
|
||||||
"__del__": None, |
|
||||||
"__delattr__": ([path_to_type("str")], path_to_type("None")), |
|
||||||
"__delitem__": ([path_to_type("typing", "Any")], path_to_type("typing", "Any")), |
|
||||||
"__dict__": None, |
|
||||||
"__dir__": None, |
|
||||||
"__doc__": None, |
|
||||||
"__eq__": ([path_to_type("typing", "Any")], path_to_type("bool")), |
|
||||||
"__format__": ([path_to_type("str")], path_to_type("str")), |
|
||||||
"__ge__": ([path_to_type("typing", "Any")], path_to_type("bool")), |
|
||||||
"__getattribute__": ([path_to_type("str")], path_to_type("typing", "Any")), |
|
||||||
"__getitem__": ([path_to_type("typing", "Any")], path_to_type("typing", "Any")), |
|
||||||
"__gt__": ([path_to_type("typing", "Any")], path_to_type("bool")), |
|
||||||
"__hash__": ([], path_to_type("int")), |
|
||||||
"__init__": ([], path_to_type("None")), |
|
||||||
"__init_subclass__": None, |
|
||||||
"__iter__": ([], path_to_type("typing", "Any")), |
|
||||||
"__le__": ([path_to_type("typing", "Any")], path_to_type("bool")), |
|
||||||
"__len__": ([], path_to_type("int")), |
|
||||||
"__lt__": ([path_to_type("typing", "Any")], path_to_type("bool")), |
|
||||||
"__module__": None, |
|
||||||
"__ne__": ([path_to_type("typing", "Any")], path_to_type("bool")), |
|
||||||
"__new__": None, |
|
||||||
"__next__": ([], path_to_type("typing", "Any")), |
|
||||||
"__reduce__": None, |
|
||||||
"__reduce_ex__": None, |
|
||||||
"__repr__": ([], path_to_type("str")), |
|
||||||
"__setattr__": ( |
|
||||||
[path_to_type("str"), path_to_type("typing", "Any")], |
|
||||||
path_to_type("None"), |
|
||||||
), |
|
||||||
"__setitem__": ( |
|
||||||
[path_to_type("typing", "Any"), path_to_type("typing", "Any")], |
|
||||||
path_to_type("typing", "Any"), |
|
||||||
), |
|
||||||
"__sizeof__": None, |
|
||||||
"__str__": ([], path_to_type("str")), |
|
||||||
"__subclasshook__": None, |
|
||||||
} |
|
||||||
|
|
||||||
|
|
||||||
def module_stubs(module: Any) -> ast.Module: |
|
||||||
types_to_import = {"typing"} |
|
||||||
classes = [] |
|
||||||
functions = [] |
|
||||||
for member_name, member_value in inspect.getmembers(module): |
|
||||||
element_path = [module.__name__, member_name] |
|
||||||
if member_name.startswith("__"): |
|
||||||
pass |
|
||||||
elif inspect.isclass(member_value): |
|
||||||
classes.append(class_stubs(member_name, member_value, element_path, types_to_import)) |
|
||||||
elif inspect.isbuiltin(member_value): |
|
||||||
functions.append( |
|
||||||
function_stub( |
|
||||||
member_name, |
|
||||||
member_value, |
|
||||||
element_path, |
|
||||||
types_to_import, |
|
||||||
in_class=False, |
|
||||||
) |
|
||||||
) |
|
||||||
else: |
|
||||||
logging.warning(f"Unsupported root construction {member_name}") |
|
||||||
return ast.Module( |
|
||||||
body=[ast.Import(names=[ast.alias(name=t)]) for t in sorted(types_to_import)] + classes + functions, |
|
||||||
type_ignores=[], |
|
||||||
) |
|
||||||
|
|
||||||
|
|
||||||
def class_stubs(cls_name: str, cls_def: Any, element_path: List[str], types_to_import: Set[str]) -> ast.ClassDef: |
|
||||||
attributes: List[ast.AST] = [] |
|
||||||
methods: List[ast.AST] = [] |
|
||||||
magic_methods: List[ast.AST] = [] |
|
||||||
constants: List[ast.AST] = [] |
|
||||||
for member_name, member_value in inspect.getmembers(cls_def): |
|
||||||
current_element_path = [*element_path, member_name] |
|
||||||
if member_name == "__init__": |
|
||||||
try: |
|
||||||
inspect.signature(cls_def) # we check it actually exists |
|
||||||
methods = [ |
|
||||||
function_stub( |
|
||||||
member_name, |
|
||||||
cls_def, |
|
||||||
current_element_path, |
|
||||||
types_to_import, |
|
||||||
in_class=True, |
|
||||||
), |
|
||||||
*methods, |
|
||||||
] |
|
||||||
except ValueError as e: |
|
||||||
if "no signature found" not in str(e): |
|
||||||
raise ValueError(f"Error while parsing signature of {cls_name}.__init_") from e |
|
||||||
elif member_value == OBJECT_MEMBERS.get(member_name) or BUILTINS.get(member_name, ()) is None: |
|
||||||
pass |
|
||||||
elif inspect.isdatadescriptor(member_value): |
|
||||||
attributes.extend(data_descriptor_stub(member_name, member_value, current_element_path, types_to_import)) |
|
||||||
elif inspect.isroutine(member_value): |
|
||||||
(magic_methods if member_name.startswith("__") else methods).append( |
|
||||||
function_stub( |
|
||||||
member_name, |
|
||||||
member_value, |
|
||||||
current_element_path, |
|
||||||
types_to_import, |
|
||||||
in_class=True, |
|
||||||
) |
|
||||||
) |
|
||||||
elif member_name == "__match_args__": |
|
||||||
constants.append( |
|
||||||
ast.AnnAssign( |
|
||||||
target=ast.Name(id=member_name, ctx=ast.Store()), |
|
||||||
annotation=ast.Subscript( |
|
||||||
value=path_to_type("tuple"), |
|
||||||
slice=ast.Tuple(elts=[path_to_type("str"), ast.Ellipsis()], ctx=ast.Load()), |
|
||||||
ctx=ast.Load(), |
|
||||||
), |
|
||||||
value=ast.Constant(member_value), |
|
||||||
simple=1, |
|
||||||
) |
|
||||||
) |
|
||||||
elif member_value is not None: |
|
||||||
constants.append( |
|
||||||
ast.AnnAssign( |
|
||||||
target=ast.Name(id=member_name, ctx=ast.Store()), |
|
||||||
annotation=concatenated_path_to_type( |
|
||||||
member_value.__class__.__name__, element_path, types_to_import |
|
||||||
), |
|
||||||
value=ast.Ellipsis(), |
|
||||||
simple=1, |
|
||||||
) |
|
||||||
) |
|
||||||
else: |
|
||||||
logging.warning(f"Unsupported member {member_name} of class {'.'.join(element_path)}") |
|
||||||
|
|
||||||
doc = inspect.getdoc(cls_def) |
|
||||||
doc_comment = build_doc_comment(doc) if doc else None |
|
||||||
return ast.ClassDef( |
|
||||||
cls_name, |
|
||||||
bases=[], |
|
||||||
keywords=[], |
|
||||||
body=(([doc_comment] if doc_comment else []) + attributes + methods + magic_methods + constants) |
|
||||||
or [ast.Ellipsis()], |
|
||||||
decorator_list=[path_to_type("typing", "final")], |
|
||||||
) |
|
||||||
|
|
||||||
|
|
||||||
def data_descriptor_stub( |
|
||||||
data_desc_name: str, |
|
||||||
data_desc_def: Any, |
|
||||||
element_path: List[str], |
|
||||||
types_to_import: Set[str], |
|
||||||
) -> Union[Tuple[ast.AnnAssign, ast.Expr], Tuple[ast.AnnAssign]]: |
|
||||||
annotation = None |
|
||||||
doc_comment = None |
|
||||||
|
|
||||||
doc = inspect.getdoc(data_desc_def) |
|
||||||
if doc is not None: |
|
||||||
annotation = returns_stub(data_desc_name, doc, element_path, types_to_import) |
|
||||||
m = re.findall(r"^ *:return: *(.*) *$", doc, re.MULTILINE) |
|
||||||
if len(m) == 1: |
|
||||||
doc_comment = m[0] |
|
||||||
elif len(m) > 1: |
|
||||||
raise ValueError( |
|
||||||
f"Multiple return annotations found with :return: in {'.'.join(element_path)} documentation" |
|
||||||
) |
|
||||||
|
|
||||||
assign = ast.AnnAssign( |
|
||||||
target=ast.Name(id=data_desc_name, ctx=ast.Store()), |
|
||||||
annotation=annotation or path_to_type("typing", "Any"), |
|
||||||
simple=1, |
|
||||||
) |
|
||||||
doc_comment = build_doc_comment(doc_comment) if doc_comment else None |
|
||||||
return (assign, doc_comment) if doc_comment else (assign,) |
|
||||||
|
|
||||||
|
|
||||||
def function_stub( |
|
||||||
fn_name: str, |
|
||||||
fn_def: Any, |
|
||||||
element_path: List[str], |
|
||||||
types_to_import: Set[str], |
|
||||||
*, |
|
||||||
in_class: bool, |
|
||||||
) -> ast.FunctionDef: |
|
||||||
body: List[ast.AST] = [] |
|
||||||
doc = inspect.getdoc(fn_def) |
|
||||||
if doc is not None: |
|
||||||
doc_comment = build_doc_comment(doc) |
|
||||||
if doc_comment is not None: |
|
||||||
body.append(doc_comment) |
|
||||||
|
|
||||||
decorator_list = [] |
|
||||||
if in_class and hasattr(fn_def, "__self__"): |
|
||||||
decorator_list.append(ast.Name("staticmethod")) |
|
||||||
|
|
||||||
return ast.FunctionDef( |
|
||||||
fn_name, |
|
||||||
arguments_stub(fn_name, fn_def, doc or "", element_path, types_to_import), |
|
||||||
body or [ast.Ellipsis()], |
|
||||||
decorator_list=decorator_list, |
|
||||||
returns=returns_stub(fn_name, doc, element_path, types_to_import) if doc else None, |
|
||||||
lineno=0, |
|
||||||
) |
|
||||||
|
|
||||||
|
|
||||||
def arguments_stub( |
|
||||||
callable_name: str, |
|
||||||
callable_def: Any, |
|
||||||
doc: str, |
|
||||||
element_path: List[str], |
|
||||||
types_to_import: Set[str], |
|
||||||
) -> ast.arguments: |
|
||||||
real_parameters: Mapping[str, inspect.Parameter] = inspect.signature(callable_def).parameters |
|
||||||
if callable_name == "__init__": |
|
||||||
real_parameters = { |
|
||||||
"self": inspect.Parameter("self", inspect.Parameter.POSITIONAL_ONLY), |
|
||||||
**real_parameters, |
|
||||||
} |
|
||||||
|
|
||||||
parsed_param_types = {} |
|
||||||
optional_params = set() |
|
||||||
|
|
||||||
# Types for magic functions types |
|
||||||
builtin = BUILTINS.get(callable_name) |
|
||||||
if isinstance(builtin, tuple): |
|
||||||
param_names = list(real_parameters.keys()) |
|
||||||
if param_names and param_names[0] == "self": |
|
||||||
del param_names[0] |
|
||||||
for name, t in zip(param_names, builtin[0]): |
|
||||||
parsed_param_types[name] = t |
|
||||||
|
|
||||||
# Types from comment |
|
||||||
for match in re.findall(r"^ *:type *([a-z_]+): ([^\n]*) *$", doc, re.MULTILINE): |
|
||||||
if match[0] not in real_parameters: |
|
||||||
raise ValueError( |
|
||||||
f"The parameter {match[0]} of {'.'.join(element_path)} " |
|
||||||
"is defined in the documentation but not in the function signature" |
|
||||||
) |
|
||||||
type = match[1] |
|
||||||
if type.endswith(", optional"): |
|
||||||
optional_params.add(match[0]) |
|
||||||
type = type[:-10] |
|
||||||
parsed_param_types[match[0]] = convert_type_from_doc(type, element_path, types_to_import) |
|
||||||
|
|
||||||
# we parse the parameters |
|
||||||
posonlyargs = [] |
|
||||||
args = [] |
|
||||||
vararg = None |
|
||||||
kwonlyargs = [] |
|
||||||
kw_defaults = [] |
|
||||||
kwarg = None |
|
||||||
defaults = [] |
|
||||||
for param in real_parameters.values(): |
|
||||||
if param.name != "self" and param.name not in parsed_param_types: |
|
||||||
raise ValueError( |
|
||||||
f"The parameter {param.name} of {'.'.join(element_path)} " |
|
||||||
"has no type definition in the function documentation" |
|
||||||
) |
|
||||||
param_ast = ast.arg(arg=param.name, annotation=parsed_param_types.get(param.name)) |
|
||||||
|
|
||||||
default_ast = None |
|
||||||
if param.default != param.empty: |
|
||||||
default_ast = ast.Constant(param.default) |
|
||||||
if param.name not in optional_params: |
|
||||||
raise ValueError( |
|
||||||
f"Parameter {param.name} of {'.'.join(element_path)} " |
|
||||||
"is optional according to the type but not flagged as such in the doc" |
|
||||||
) |
|
||||||
elif param.name in optional_params: |
|
||||||
raise ValueError( |
|
||||||
f"Parameter {param.name} of {'.'.join(element_path)} " |
|
||||||
"is optional according to the documentation but has no default value" |
|
||||||
) |
|
||||||
|
|
||||||
if param.kind == param.POSITIONAL_ONLY: |
|
||||||
posonlyargs.append(param_ast) |
|
||||||
defaults.append(default_ast) |
|
||||||
elif param.kind == param.POSITIONAL_OR_KEYWORD: |
|
||||||
args.append(param_ast) |
|
||||||
defaults.append(default_ast) |
|
||||||
elif param.kind == param.VAR_POSITIONAL: |
|
||||||
vararg = param_ast |
|
||||||
elif param.kind == param.KEYWORD_ONLY: |
|
||||||
kwonlyargs.append(param_ast) |
|
||||||
kw_defaults.append(default_ast) |
|
||||||
elif param.kind == param.VAR_KEYWORD: |
|
||||||
kwarg = param_ast |
|
||||||
|
|
||||||
return ast.arguments( |
|
||||||
posonlyargs=posonlyargs, |
|
||||||
args=args, |
|
||||||
vararg=vararg, |
|
||||||
kwonlyargs=kwonlyargs, |
|
||||||
kw_defaults=kw_defaults, |
|
||||||
defaults=defaults, |
|
||||||
kwarg=kwarg, |
|
||||||
) |
|
||||||
|
|
||||||
|
|
||||||
def returns_stub(callable_name: str, doc: str, element_path: List[str], types_to_import: Set[str]) -> Optional[ast.AST]: |
|
||||||
m = re.findall(r"^ *:rtype: *([^\n]*) *$", doc, re.MULTILINE) |
|
||||||
if len(m) == 0: |
|
||||||
builtin = BUILTINS.get(callable_name) |
|
||||||
if isinstance(builtin, tuple) and builtin[1] is not None: |
|
||||||
return builtin[1] |
|
||||||
raise ValueError( |
|
||||||
f"The return type of {'.'.join(element_path)} " |
|
||||||
"has no type definition using :rtype: in the function documentation" |
|
||||||
) |
|
||||||
if len(m) > 1: |
|
||||||
raise ValueError(f"Multiple return type annotations found with :rtype: for {'.'.join(element_path)}") |
|
||||||
return convert_type_from_doc(m[0], element_path, types_to_import) |
|
||||||
|
|
||||||
|
|
||||||
def convert_type_from_doc(type_str: str, element_path: List[str], types_to_import: Set[str]) -> ast.AST: |
|
||||||
type_str = type_str.strip() |
|
||||||
return parse_type_to_ast(type_str, element_path, types_to_import) |
|
||||||
|
|
||||||
|
|
||||||
def parse_type_to_ast(type_str: str, element_path: List[str], types_to_import: Set[str]) -> ast.AST: |
|
||||||
# let's tokenize |
|
||||||
tokens = [] |
|
||||||
current_token = "" |
|
||||||
for c in type_str: |
|
||||||
if "a" <= c <= "z" or "A" <= c <= "Z" or c == ".": |
|
||||||
current_token += c |
|
||||||
else: |
|
||||||
if current_token: |
|
||||||
tokens.append(current_token) |
|
||||||
current_token = "" |
|
||||||
if c != " ": |
|
||||||
tokens.append(c) |
|
||||||
if current_token: |
|
||||||
tokens.append(current_token) |
|
||||||
|
|
||||||
# let's first parse nested parenthesis |
|
||||||
stack: List[List[Any]] = [[]] |
|
||||||
for token in tokens: |
|
||||||
if token == "[": |
|
||||||
children: List[str] = [] |
|
||||||
stack[-1].append(children) |
|
||||||
stack.append(children) |
|
||||||
elif token == "]": |
|
||||||
stack.pop() |
|
||||||
else: |
|
||||||
stack[-1].append(token) |
|
||||||
|
|
||||||
# then it's easy |
|
||||||
def parse_sequence(sequence: List[Any]) -> ast.AST: |
|
||||||
# we split based on "or" |
|
||||||
or_groups: List[List[str]] = [[]] |
|
||||||
for e in sequence: |
|
||||||
if e == "or": |
|
||||||
or_groups.append([]) |
|
||||||
else: |
|
||||||
or_groups[-1].append(e) |
|
||||||
if any(not g for g in or_groups): |
|
||||||
raise ValueError(f"Not able to parse type '{type_str}' used by {'.'.join(element_path)}") |
|
||||||
|
|
||||||
new_elements: List[ast.AST] = [] |
|
||||||
for group in or_groups: |
|
||||||
if len(group) == 1 and isinstance(group[0], str): |
|
||||||
new_elements.append(concatenated_path_to_type(group[0], element_path, types_to_import)) |
|
||||||
elif len(group) == 2 and isinstance(group[0], str) and isinstance(group[1], list): |
|
||||||
new_elements.append( |
|
||||||
ast.Subscript( |
|
||||||
value=concatenated_path_to_type(group[0], element_path, types_to_import), |
|
||||||
slice=parse_sequence(group[1]), |
|
||||||
ctx=ast.Load(), |
|
||||||
) |
|
||||||
) |
|
||||||
else: |
|
||||||
raise ValueError(f"Not able to parse type '{type_str}' used by {'.'.join(element_path)}") |
|
||||||
return reduce(lambda left, right: ast.BinOp(left=left, op=ast.BitOr(), right=right), new_elements) |
|
||||||
|
|
||||||
return parse_sequence(stack[0]) |
|
||||||
|
|
||||||
|
|
||||||
def concatenated_path_to_type(path: str, element_path: List[str], types_to_import: Set[str]) -> ast.AST: |
|
||||||
parts = path.split(".") |
|
||||||
if any(not p for p in parts): |
|
||||||
raise ValueError(f"Not able to parse type '{path}' used by {'.'.join(element_path)}") |
|
||||||
if len(parts) > 1: |
|
||||||
types_to_import.add(".".join(parts[:-1])) |
|
||||||
return path_to_type(*parts) |
|
||||||
|
|
||||||
|
|
||||||
def build_doc_comment(doc: str) -> Optional[ast.Expr]: |
|
||||||
lines = [line.strip() for line in doc.split("\n")] |
|
||||||
clean_lines = [] |
|
||||||
for line in lines: |
|
||||||
if line.startswith((":type", ":rtype")): |
|
||||||
continue |
|
||||||
clean_lines.append(line) |
|
||||||
text = "\n".join(clean_lines).strip() |
|
||||||
return ast.Expr(value=ast.Constant(text)) if text else None |
|
||||||
|
|
||||||
|
|
||||||
def format_with_ruff(file: str) -> None: |
|
||||||
subprocess.check_call(["python", "-m", "ruff", "format", file]) |
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__": |
|
||||||
parser = argparse.ArgumentParser(description="Extract Python type stub from a python module.") |
|
||||||
parser.add_argument("module_name", help="Name of the Python module for which generate stubs") |
|
||||||
parser.add_argument( |
|
||||||
"out", |
|
||||||
help="Name of the Python stub file to write to", |
|
||||||
type=argparse.FileType("wt"), |
|
||||||
) |
|
||||||
parser.add_argument("--ruff", help="Formats the generated stubs using Ruff", action="store_true") |
|
||||||
args = parser.parse_args() |
|
||||||
stub_content = ast.unparse(module_stubs(importlib.import_module(args.module_name))) |
|
||||||
args.out.write(stub_content) |
|
||||||
if args.ruff: |
|
||||||
format_with_ruff(args.out.name) |
|
||||||
@ -1,2 +0,0 @@ |
|||||||
pyoxigraph.pyoxigraph |
|
||||||
pyoxigraph.DefaultGraph.__init__ |
|
||||||
@ -1,59 +0,0 @@ |
|||||||
[build-system] |
|
||||||
requires = ["maturin~=1.0"] |
|
||||||
build-backend = "maturin" |
|
||||||
|
|
||||||
[project] |
|
||||||
# Most of the metadata are in Cargo.toml and injected by maturin |
|
||||||
name = "pyoxigraph" |
|
||||||
classifiers = [ |
|
||||||
"Development Status :: 3 - Alpha", |
|
||||||
"Intended Audience :: Developers", |
|
||||||
"License :: OSI Approved :: Apache Software License", |
|
||||||
"License :: OSI Approved :: MIT License", |
|
||||||
"Programming Language :: Python :: 3 :: Only", |
|
||||||
"Programming Language :: Python :: 3.8", |
|
||||||
"Programming Language :: Python :: 3.9", |
|
||||||
"Programming Language :: Python :: 3.10", |
|
||||||
"Programming Language :: Python :: 3.11", |
|
||||||
"Programming Language :: Rust", |
|
||||||
"Topic :: Database :: Database Engines/Servers", |
|
||||||
"Topic :: Software Development :: Libraries :: Python Modules", |
|
||||||
] |
|
||||||
requires-python = ">=3.8" |
|
||||||
|
|
||||||
[project.urls] |
|
||||||
Changelog = "https://github.com/oxigraph/oxigraph/blob/main/CHANGELOG.md" |
|
||||||
Documentation = "https://pyoxigraph.readthedocs.io/" |
|
||||||
Homepage = "https://pyoxigraph.readthedocs.io/" |
|
||||||
Source = "https://github.com/oxigraph/oxigraph/tree/main/python" |
|
||||||
Tracker = "https://github.com/oxigraph/oxigraph/issues" |
|
||||||
|
|
||||||
[tool.maturin] |
|
||||||
strip = true |
|
||||||
|
|
||||||
[tool.ruff] |
|
||||||
line-length = 120 |
|
||||||
|
|
||||||
[tool.ruff.lint] |
|
||||||
select = [ |
|
||||||
"ARG", |
|
||||||
"B", |
|
||||||
"C40", |
|
||||||
"E", |
|
||||||
"F", |
|
||||||
"FBT", |
|
||||||
"I", |
|
||||||
"ICN", |
|
||||||
"N", |
|
||||||
"PIE", |
|
||||||
"PTH", |
|
||||||
"RET", |
|
||||||
"RUF", |
|
||||||
"SIM", |
|
||||||
"T10", |
|
||||||
"TCH", |
|
||||||
"TID", |
|
||||||
"UP", |
|
||||||
"W", |
|
||||||
"YTT" |
|
||||||
] |
|
||||||
@ -1,6 +0,0 @@ |
|||||||
furo |
|
||||||
maturin~=1.0 |
|
||||||
mypy~=1.0 |
|
||||||
ruff~=0.3.0 |
|
||||||
sphinx~=7.0 |
|
||||||
sphinx-lint~=0.9.1 |
|
||||||
@ -1,327 +0,0 @@ |
|||||||
use crate::model::{hash, PyGraphNameRef, PyNamedNodeRef, PyQuad, PySubjectRef, PyTermRef}; |
|
||||||
use oxigraph::model::dataset::{CanonicalizationAlgorithm, Dataset}; |
|
||||||
use oxigraph::model::{Quad, QuadRef}; |
|
||||||
use pyo3::exceptions::PyKeyError; |
|
||||||
use pyo3::prelude::*; |
|
||||||
|
|
||||||
/// An in-memory `RDF dataset <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset>`_.
|
|
||||||
///
|
|
||||||
/// It can accommodate a fairly large number of quads (in the few millions).
|
|
||||||
///
|
|
||||||
/// Use :py:class:`Store` if you need on-disk persistence or SPARQL.
|
|
||||||
///
|
|
||||||
/// Warning: It interns the strings and does not do any garbage collection yet:
|
|
||||||
/// if you insert and remove a lot of different terms, memory will grow without any reduction.
|
|
||||||
///
|
|
||||||
/// :param quads: some quads to initialize the dataset with.
|
|
||||||
/// :type quads: collections.abc.Iterable[Quad] or None, optional
|
|
||||||
///
|
|
||||||
/// The :py:class:`str` function provides an N-Quads serialization:
|
|
||||||
///
|
|
||||||
/// >>> 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'
|
|
||||||
#[pyclass(name = "Dataset", module = "pyoxigraph")] |
|
||||||
#[derive(Eq, PartialEq, Debug, Clone)] |
|
||||||
pub struct PyDataset { |
|
||||||
inner: Dataset, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyDataset { |
|
||||||
#[new] |
|
||||||
#[pyo3(signature = (quads = None))] |
|
||||||
fn new(quads: Option<&Bound<'_, PyAny>>) -> PyResult<Self> { |
|
||||||
let mut inner = Dataset::new(); |
|
||||||
if let Some(quads) = quads { |
|
||||||
for quad in quads.iter()? { |
|
||||||
inner.insert(&*quad?.extract::<PyRef<'_, PyQuad>>()?); |
|
||||||
} |
|
||||||
} |
|
||||||
Ok(Self { inner }) |
|
||||||
} |
|
||||||
|
|
||||||
/// Looks for the quads with the given subject.
|
|
||||||
///
|
|
||||||
/// :param subject: the quad subject.
|
|
||||||
/// :type subject: NamedNode or BlankNode or Triple
|
|
||||||
/// :return: an iterator of the quads.
|
|
||||||
/// :rtype: collections.abc.Iterator[Quad]
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
pub fn quads_for_subject(&self, subject: PySubjectRef<'_>) -> QuadIter { |
|
||||||
QuadIter { |
|
||||||
inner: self |
|
||||||
.inner |
|
||||||
.quads_for_subject(&subject) |
|
||||||
.map(QuadRef::into_owned) |
|
||||||
.collect::<Vec<_>>() |
|
||||||
.into_iter(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Looks for the quads with the given predicate.
|
|
||||||
///
|
|
||||||
/// :param predicate: the quad predicate.
|
|
||||||
/// :type predicate: NamedNode
|
|
||||||
/// :return: an iterator of the quads.
|
|
||||||
/// :rtype: collections.abc.Iterator[Quad]
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
pub fn quads_for_predicate(&self, predicate: PyNamedNodeRef<'_>) -> QuadIter { |
|
||||||
QuadIter { |
|
||||||
inner: self |
|
||||||
.inner |
|
||||||
.quads_for_predicate(&predicate) |
|
||||||
.map(QuadRef::into_owned) |
|
||||||
.collect::<Vec<_>>() |
|
||||||
.into_iter(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Looks for the quads with the given object.
|
|
||||||
///
|
|
||||||
/// :param object: the quad object.
|
|
||||||
/// :type object: NamedNode or BlankNode or Literal or Triple
|
|
||||||
/// :return: an iterator of the quads.
|
|
||||||
/// :rtype: collections.abc.Iterator[Quad]
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
pub fn quads_for_object(&self, object: PyTermRef<'_>) -> QuadIter { |
|
||||||
QuadIter { |
|
||||||
inner: self |
|
||||||
.inner |
|
||||||
.quads_for_object(&object) |
|
||||||
.map(QuadRef::into_owned) |
|
||||||
.collect::<Vec<_>>() |
|
||||||
.into_iter(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Looks for the quads with the given graph name.
|
|
||||||
///
|
|
||||||
/// :param graph_name: the quad graph name.
|
|
||||||
/// :type graph_name: NamedNode or BlankNode or DefaultGraph
|
|
||||||
/// :return: an iterator of the quads.
|
|
||||||
/// :rtype: collections.abc.Iterator[Quad]
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
pub fn quads_for_graph_name(&self, graph_name: PyGraphNameRef<'_>) -> QuadIter { |
|
||||||
QuadIter { |
|
||||||
inner: self |
|
||||||
.inner |
|
||||||
.quads_for_graph_name(&graph_name) |
|
||||||
.map(QuadRef::into_owned) |
|
||||||
.collect::<Vec<_>>() |
|
||||||
.into_iter(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Adds a quad to the dataset.
|
|
||||||
///
|
|
||||||
/// :param quad: the quad to add.
|
|
||||||
/// :type quad: Quad
|
|
||||||
/// :rtype: None
|
|
||||||
///
|
|
||||||
/// >>> 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
|
|
||||||
fn add(&mut self, quad: &PyQuad) { |
|
||||||
self.inner.insert(quad); |
|
||||||
} |
|
||||||
|
|
||||||
/// Removes a quad from the dataset and raises an exception if it is not in the set.
|
|
||||||
///
|
|
||||||
/// :param quad: the quad to remove.
|
|
||||||
/// :type quad: Quad
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises KeyError: if the element was not in the set.
|
|
||||||
///
|
|
||||||
/// >>> quad = Quad(NamedNode('http://example.com/s'), NamedNode('http://example.com/p'), NamedNode('http://example.com/o'), NamedNode('http://example.com/g'))
|
|
||||||
/// >>> dataset = Dataset([quad])
|
|
||||||
/// >>> dataset.remove(quad)
|
|
||||||
/// >>> quad in dataset
|
|
||||||
/// False
|
|
||||||
fn remove(&mut self, quad: &PyQuad) -> PyResult<()> { |
|
||||||
if self.inner.remove(quad) { |
|
||||||
Ok(()) |
|
||||||
} else { |
|
||||||
Err(PyKeyError::new_err(format!( |
|
||||||
"{} is not in the Dataset", |
|
||||||
QuadRef::from(quad) |
|
||||||
))) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Removes a quad from the dataset if it is present.
|
|
||||||
///
|
|
||||||
/// :param quad: the quad to remove.
|
|
||||||
/// :type quad: Quad
|
|
||||||
/// :rtype: None
|
|
||||||
///
|
|
||||||
/// >>> quad = Quad(NamedNode('http://example.com/s'), NamedNode('http://example.com/p'), NamedNode('http://example.com/o'), NamedNode('http://example.com/g'))
|
|
||||||
/// >>> dataset = Dataset([quad])
|
|
||||||
/// >>> dataset.discard(quad)
|
|
||||||
/// >>> quad in dataset
|
|
||||||
/// False
|
|
||||||
fn discard(&mut self, quad: &PyQuad) { |
|
||||||
self.inner.remove(quad); |
|
||||||
} |
|
||||||
|
|
||||||
/// Removes all quads from the dataset.
|
|
||||||
///
|
|
||||||
/// :rtype: None
|
|
||||||
///
|
|
||||||
/// >>> quad = Quad(NamedNode('http://example.com/s'), NamedNode('http://example.com/p'), NamedNode('http://example.com/o'), NamedNode('http://example.com/g'))
|
|
||||||
/// >>> dataset = Dataset([quad])
|
|
||||||
/// >>> dataset.clear()
|
|
||||||
/// >>> len(dataset)
|
|
||||||
/// 0
|
|
||||||
fn clear(&mut self) { |
|
||||||
self.inner.clear() |
|
||||||
} |
|
||||||
|
|
||||||
/// Canonicalizes the dataset by renaming blank nodes.
|
|
||||||
///
|
|
||||||
/// Warning: Blank node ids depends on the current shape of the graph. Adding a new quad might change the ids of a lot of blank nodes.
|
|
||||||
/// Hence, this canonization might not be suitable for diffs.
|
|
||||||
///
|
|
||||||
/// Warning: This implementation worst-case complexity is in *O(b!)* with *b* the number of blank nodes in the input dataset.
|
|
||||||
///
|
|
||||||
/// :param algorithm: the canonicalization algorithm to use.
|
|
||||||
/// :type algorithm: CanonicalizationAlgorithm
|
|
||||||
/// :rtype: None
|
|
||||||
///
|
|
||||||
/// >>> 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
|
|
||||||
fn canonicalize(&mut self, algorithm: &PyCanonicalizationAlgorithm) { |
|
||||||
self.inner.canonicalize(algorithm.inner) |
|
||||||
} |
|
||||||
|
|
||||||
fn __str__(&self) -> String { |
|
||||||
self.inner.to_string() |
|
||||||
} |
|
||||||
|
|
||||||
fn __bool__(&self) -> bool { |
|
||||||
self.inner.is_empty() |
|
||||||
} |
|
||||||
|
|
||||||
fn __eq__(&self, other: &Self) -> bool { |
|
||||||
self.inner == other.inner |
|
||||||
} |
|
||||||
|
|
||||||
fn __ne__(&self, other: &Self) -> bool { |
|
||||||
self.inner != other.inner |
|
||||||
} |
|
||||||
|
|
||||||
fn __len__(&self) -> usize { |
|
||||||
self.inner.len() |
|
||||||
} |
|
||||||
|
|
||||||
fn __contains__(&self, quad: &PyQuad) -> bool { |
|
||||||
self.inner.contains(quad) |
|
||||||
} |
|
||||||
|
|
||||||
fn __iter__(&self) -> QuadIter { |
|
||||||
// TODO: very inefficient
|
|
||||||
QuadIter { |
|
||||||
inner: self |
|
||||||
.inner |
|
||||||
.iter() |
|
||||||
.map(QuadRef::into_owned) |
|
||||||
.collect::<Vec<_>>() |
|
||||||
.into_iter(), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#[pyclass(unsendable, module = "pyoxigraph")] |
|
||||||
pub struct QuadIter { |
|
||||||
inner: std::vec::IntoIter<Quad>, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl QuadIter { |
|
||||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
fn __next__(&mut self) -> Option<PyQuad> { |
|
||||||
Some(self.inner.next()?.into()) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// RDF canonicalization algorithms.
|
|
||||||
///
|
|
||||||
/// The following algorithms are supported:
|
|
||||||
///
|
|
||||||
/// * :py:attr:`CanonicalizationAlgorithm.UNSTABLE`: an unstable algorithm preferred by PyOxigraph.
|
|
||||||
#[pyclass(name = "CanonicalizationAlgorithm", module = "pyoxigraph")] |
|
||||||
#[derive(Clone)] |
|
||||||
pub struct PyCanonicalizationAlgorithm { |
|
||||||
inner: CanonicalizationAlgorithm, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyCanonicalizationAlgorithm { |
|
||||||
/// The algorithm preferred by PyOxigraph.
|
|
||||||
///
|
|
||||||
/// Warning: Might change between Oxigraph versions. No stability guaranties.
|
|
||||||
#[classattr] |
|
||||||
const UNSTABLE: Self = Self { |
|
||||||
inner: CanonicalizationAlgorithm::Unstable, |
|
||||||
}; |
|
||||||
|
|
||||||
fn __repr__(&self) -> String { |
|
||||||
format!( |
|
||||||
"<CanonicalizationAlgorithm {}>", |
|
||||||
match self.inner { |
|
||||||
CanonicalizationAlgorithm::Unstable => "unstable", |
|
||||||
_ => "unknown", |
|
||||||
} |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
fn __hash__(&self) -> u64 { |
|
||||||
hash(&self.inner) |
|
||||||
} |
|
||||||
|
|
||||||
fn __eq__(&self, other: &Self) -> bool { |
|
||||||
self.inner == other.inner |
|
||||||
} |
|
||||||
|
|
||||||
fn __ne__(&self, other: &Self) -> bool { |
|
||||||
self.inner != other.inner |
|
||||||
} |
|
||||||
|
|
||||||
/// :rtype: CanonicalizationAlgorithm
|
|
||||||
fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
/// :type memo: typing.Any
|
|
||||||
/// :rtype: CanonicalizationAlgorithm
|
|
||||||
#[allow(unused_variables)] |
|
||||||
fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,640 +0,0 @@ |
|||||||
#![allow(clippy::needless_option_as_deref)] |
|
||||||
|
|
||||||
use crate::model::{hash, PyQuad, PyTriple}; |
|
||||||
use oxigraph::io::{FromReadQuadReader, RdfFormat, RdfParseError, RdfParser, RdfSerializer}; |
|
||||||
use oxigraph::model::QuadRef; |
|
||||||
use pyo3::exceptions::{PyDeprecationWarning, PySyntaxError, PyValueError}; |
|
||||||
use pyo3::intern; |
|
||||||
use pyo3::prelude::*; |
|
||||||
use pyo3::types::{PyBytes, PyString}; |
|
||||||
use std::cmp::max; |
|
||||||
use std::ffi::OsStr; |
|
||||||
use std::fs::File; |
|
||||||
use std::io::{self, BufWriter, Cursor, Read, Write}; |
|
||||||
use std::path::{Path, PathBuf}; |
|
||||||
use std::sync::OnceLock; |
|
||||||
|
|
||||||
/// Parses RDF graph and dataset serialization formats.
|
|
||||||
///
|
|
||||||
/// It currently supports the following formats:
|
|
||||||
///
|
|
||||||
/// * `N-Triples <https://www.w3.org/TR/n-triples/>`_ (:py:attr:`RdfFormat.N_TRIPLES`)
|
|
||||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (:py:attr:`RdfFormat.N_QUADS`)
|
|
||||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (:py:attr:`RdfFormat.TURTLE`)
|
|
||||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (:py:attr:`RdfFormat.TRIG`)
|
|
||||||
/// * `N3 <https://w3c.github.io/N3/spec/>`_ (:py:attr:`RdfFormat.N3`)
|
|
||||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (:py:attr:`RdfFormat.RDF_XML`)
|
|
||||||
///
|
|
||||||
/// It supports also some media type and extension aliases.
|
|
||||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
|
||||||
/// and ``application/xml`` or ``xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
|
||||||
///
|
|
||||||
/// :param input: The :py:class:`str`, :py:class:`bytes` or I/O object to read from. For example, it could be the file content as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``.
|
|
||||||
/// :type input: bytes or str or typing.IO[bytes] or typing.IO[str] or None, optional
|
|
||||||
/// :param format: the format of the RDF serialization. If :py:const:`None`, the format is guessed from the file name extension.
|
|
||||||
/// :type format: RdfFormat or None, optional
|
|
||||||
/// :param path: The file path to read from. Replaces the ``input`` parameter.
|
|
||||||
/// :type path: str or os.PathLike[str] or None, optional
|
|
||||||
/// :param base_iri: the base IRI used to resolve the relative IRIs in the file or :py:const:`None` if relative IRI resolution should not be done.
|
|
||||||
/// :type base_iri: str or None, optional
|
|
||||||
/// :param without_named_graphs: Sets that the parser must fail when parsing a named graph.
|
|
||||||
/// :type without_named_graphs: bool, optional
|
|
||||||
/// :param rename_blank_nodes: Renames the blank nodes identifiers from the ones set in the serialization to random ids. This allows to avoid identifier conflicts when merging graphs together.
|
|
||||||
/// :type rename_blank_nodes: bool, optional
|
|
||||||
/// :return: an iterator of RDF triples or quads depending on the format.
|
|
||||||
/// :rtype: collections.abc.Iterator[Quad]
|
|
||||||
/// :raises ValueError: if the format is not supported.
|
|
||||||
/// :raises SyntaxError: if the provided data is invalid.
|
|
||||||
/// :raises OSError: if a system error happens while reading the file.
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[pyfunction] |
|
||||||
#[pyo3(signature = (input = None, format = None, *, path = None, base_iri = None, without_named_graphs = false, rename_blank_nodes = false))] |
|
||||||
pub fn parse( |
|
||||||
input: Option<PyReadableInput>, |
|
||||||
format: Option<PyRdfFormatInput>, |
|
||||||
path: Option<PathBuf>, |
|
||||||
base_iri: Option<&str>, |
|
||||||
without_named_graphs: bool, |
|
||||||
rename_blank_nodes: bool, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<PyObject> { |
|
||||||
let input = PyReadable::from_args(&path, input, py)?; |
|
||||||
let format = lookup_rdf_format(format, path.as_deref())?; |
|
||||||
let mut parser = RdfParser::from_format(format); |
|
||||||
if let Some(base_iri) = base_iri { |
|
||||||
parser = parser |
|
||||||
.with_base_iri(base_iri) |
|
||||||
.map_err(|e| PyValueError::new_err(e.to_string()))?; |
|
||||||
} |
|
||||||
if without_named_graphs { |
|
||||||
parser = parser.without_named_graphs(); |
|
||||||
} |
|
||||||
if rename_blank_nodes { |
|
||||||
parser = parser.rename_blank_nodes(); |
|
||||||
} |
|
||||||
Ok(PyQuadReader { |
|
||||||
inner: parser.parse_read(input), |
|
||||||
file_path: path, |
|
||||||
} |
|
||||||
.into_py(py)) |
|
||||||
} |
|
||||||
|
|
||||||
/// Serializes an RDF graph or dataset.
|
|
||||||
///
|
|
||||||
/// It currently supports the following formats:
|
|
||||||
///
|
|
||||||
/// * `canonical <https://www.w3.org/TR/n-triples/#canonical-ntriples>`_ `N-Triples <https://www.w3.org/TR/n-triples/>`_ (:py:attr:`RdfFormat.N_TRIPLES`)
|
|
||||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (:py:attr:`RdfFormat.N_QUADS`)
|
|
||||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (:py:attr:`RdfFormat.TURTLE`)
|
|
||||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (:py:attr:`RdfFormat.TRIG`)
|
|
||||||
/// * `N3 <https://w3c.github.io/N3/spec/>`_ (:py:attr:`RdfFormat.N3`)
|
|
||||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (:py:attr:`RdfFormat.RDF_XML`)
|
|
||||||
///
|
|
||||||
/// It supports also some media type and extension aliases.
|
|
||||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
|
||||||
/// and ``application/xml`` or ``xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
|
||||||
///
|
|
||||||
/// :param input: the RDF triples and quads to serialize.
|
|
||||||
/// :type input: collections.abc.Iterable[Triple] or collections.abc.Iterable[Quad]
|
|
||||||
/// :param output: The binary I/O object or file path to write to. For example, it could be a file path as a string or a file writer opened in binary mode with ``open('my_file.ttl', 'wb')``. If :py:const:`None`, a :py:class:`bytes` buffer is returned with the serialized content.
|
|
||||||
/// :type output: typing.IO[bytes] or str or os.PathLike[str] or None, optional
|
|
||||||
/// :param format: the format of the RDF serialization. If :py:const:`None`, the format is guessed from the file name extension.
|
|
||||||
/// :type format: RdfFormat or None, optional
|
|
||||||
/// :return: :py:class:`bytes` with the serialization if the ``output`` parameter is :py:const:`None`, :py:const:`None` if ``output`` is set.
|
|
||||||
/// :rtype: bytes or None
|
|
||||||
/// :raises ValueError: if the format is not supported.
|
|
||||||
/// :raises TypeError: if a triple is given during a quad format serialization or reverse.
|
|
||||||
/// :raises OSError: if a system error happens while writing the file.
|
|
||||||
///
|
|
||||||
/// >>> 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'
|
|
||||||
///
|
|
||||||
/// >>> import io
|
|
||||||
/// >>> output = io.BytesIO()
|
|
||||||
/// >>> serialize([Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'))], output, RdfFormat.TURTLE)
|
|
||||||
/// >>> output.getvalue()
|
|
||||||
/// b'<http://example.com> <http://example.com/p> "1" .\n'
|
|
||||||
#[pyfunction] |
|
||||||
#[pyo3(signature = (input, output = None, format = None))] |
|
||||||
pub fn serialize<'py>( |
|
||||||
input: &Bound<'py, PyAny>, |
|
||||||
output: Option<PyWritableOutput>, |
|
||||||
format: Option<PyRdfFormatInput>, |
|
||||||
py: Python<'py>, |
|
||||||
) -> PyResult<Option<Bound<'py, PyBytes>>> { |
|
||||||
PyWritable::do_write( |
|
||||||
|output, file_path| { |
|
||||||
let format = lookup_rdf_format(format, file_path.as_deref())?; |
|
||||||
let mut writer = RdfSerializer::from_format(format).serialize_to_write(output); |
|
||||||
for i in input.iter()? { |
|
||||||
let i = i?; |
|
||||||
if let Ok(triple) = i.extract::<PyRef<'_, PyTriple>>() { |
|
||||||
writer.write_triple(&*triple) |
|
||||||
} else { |
|
||||||
let quad = i.extract::<PyRef<'_, PyQuad>>()?; |
|
||||||
let quad = QuadRef::from(&*quad); |
|
||||||
if !quad.graph_name.is_default_graph() && !format.supports_datasets() { |
|
||||||
return Err(PyValueError::new_err( |
|
||||||
"The {format} format does not support named graphs", |
|
||||||
)); |
|
||||||
} |
|
||||||
writer.write_quad(quad) |
|
||||||
}?; |
|
||||||
} |
|
||||||
Ok(writer.finish()?) |
|
||||||
}, |
|
||||||
output, |
|
||||||
py, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
#[pyclass(name = "QuadReader", module = "pyoxigraph")] |
|
||||||
pub struct PyQuadReader { |
|
||||||
inner: FromReadQuadReader<PyReadable>, |
|
||||||
file_path: Option<PathBuf>, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyQuadReader { |
|
||||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
fn __next__(&mut self, py: Python<'_>) -> PyResult<Option<PyQuad>> { |
|
||||||
py.allow_threads(|| { |
|
||||||
Ok(self |
|
||||||
.inner |
|
||||||
.next() |
|
||||||
.transpose() |
|
||||||
.map_err(|e| map_parse_error(e, self.file_path.clone()))? |
|
||||||
.map(PyQuad::from)) |
|
||||||
}) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// RDF serialization formats.
|
|
||||||
///
|
|
||||||
/// The following formats are supported:
|
|
||||||
///
|
|
||||||
/// * `N-Triples <https://www.w3.org/TR/n-triples/>`_ (:py:attr:`RdfFormat.N_TRIPLES`)
|
|
||||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (:py:attr:`RdfFormat.N_QUADS`)
|
|
||||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (:py:attr:`RdfFormat.TURTLE`)
|
|
||||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (:py:attr:`RdfFormat.TRIG`)
|
|
||||||
/// * `N3 <https://w3c.github.io/N3/spec/>`_ (:py:attr:`RdfFormat.N3`)
|
|
||||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (:py:attr:`RdfFormat.RDF_XML`)
|
|
||||||
///
|
|
||||||
/// >>> RdfFormat.N3.media_type
|
|
||||||
/// 'text/n3'
|
|
||||||
#[pyclass(name = "RdfFormat", module = "pyoxigraph")] |
|
||||||
#[derive(Clone)] |
|
||||||
pub struct PyRdfFormat { |
|
||||||
inner: RdfFormat, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyRdfFormat { |
|
||||||
/// `N3 <https://w3c.github.io/N3/spec/>`_
|
|
||||||
#[classattr] |
|
||||||
const N3: Self = Self { |
|
||||||
inner: RdfFormat::N3, |
|
||||||
}; |
|
||||||
/// `N-Quads <https://www.w3.org/TR/n-quads/>`_
|
|
||||||
#[classattr] |
|
||||||
const N_QUADS: Self = Self { |
|
||||||
inner: RdfFormat::NQuads, |
|
||||||
}; |
|
||||||
/// `N-Triples <https://www.w3.org/TR/n-triples/>`_
|
|
||||||
#[classattr] |
|
||||||
const N_TRIPLES: Self = Self { |
|
||||||
inner: RdfFormat::NTriples, |
|
||||||
}; |
|
||||||
/// `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_
|
|
||||||
#[classattr] |
|
||||||
const RDF_XML: Self = Self { |
|
||||||
inner: RdfFormat::RdfXml, |
|
||||||
}; |
|
||||||
/// `TriG <https://www.w3.org/TR/trig/>`_
|
|
||||||
#[classattr] |
|
||||||
const TRIG: Self = Self { |
|
||||||
inner: RdfFormat::TriG, |
|
||||||
}; |
|
||||||
/// `Turtle <https://www.w3.org/TR/turtle/>`_
|
|
||||||
#[classattr] |
|
||||||
const TURTLE: Self = Self { |
|
||||||
inner: RdfFormat::Turtle, |
|
||||||
}; |
|
||||||
|
|
||||||
/// :return: the format canonical IRI according to the `Unique URIs for file formats registry <https://www.w3.org/ns/formats/>`_.
|
|
||||||
/// :rtype: str
|
|
||||||
///
|
|
||||||
/// >>> RdfFormat.N_TRIPLES.iri
|
|
||||||
/// 'http://www.w3.org/ns/formats/N-Triples'
|
|
||||||
#[getter] |
|
||||||
fn iri(&self) -> &'static str { |
|
||||||
self.inner.iri() |
|
||||||
} |
|
||||||
|
|
||||||
/// :return: the format `IANA media type <https://tools.ietf.org/html/rfc2046>`_.
|
|
||||||
/// :rtype: str
|
|
||||||
///
|
|
||||||
/// >>> RdfFormat.N_TRIPLES.media_type
|
|
||||||
/// 'application/n-triples'
|
|
||||||
#[getter] |
|
||||||
fn media_type(&self) -> &'static str { |
|
||||||
self.inner.media_type() |
|
||||||
} |
|
||||||
|
|
||||||
/// :return: the format `IANA-registered <https://tools.ietf.org/html/rfc2046>`_ file extension.
|
|
||||||
/// :rtype: str
|
|
||||||
///
|
|
||||||
/// >>> RdfFormat.N_TRIPLES.file_extension
|
|
||||||
/// 'nt'
|
|
||||||
#[getter] |
|
||||||
pub fn file_extension(&self) -> &'static str { |
|
||||||
self.inner.file_extension() |
|
||||||
} |
|
||||||
|
|
||||||
/// :return: the format name.
|
|
||||||
/// :rtype: str
|
|
||||||
///
|
|
||||||
/// >>> RdfFormat.N_TRIPLES.name
|
|
||||||
/// 'N-Triples'
|
|
||||||
#[getter] |
|
||||||
pub const fn name(&self) -> &'static str { |
|
||||||
self.inner.name() |
|
||||||
} |
|
||||||
|
|
||||||
/// :return: if the formats supports `RDF datasets <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset>`_ and not only `RDF graphs <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-graph>`_.
|
|
||||||
/// :rtype: bool
|
|
||||||
///
|
|
||||||
/// >>> RdfFormat.N_TRIPLES.supports_datasets
|
|
||||||
/// False
|
|
||||||
/// >>> RdfFormat.N_QUADS.supports_datasets
|
|
||||||
/// True
|
|
||||||
#[getter] |
|
||||||
pub fn supports_datasets(&self) -> bool { |
|
||||||
self.inner.supports_datasets() |
|
||||||
} |
|
||||||
|
|
||||||
/// :return: if the formats supports `RDF-star quoted triples <https://w3c.github.io/rdf-star/cg-spec/2021-12-17.html#dfn-quoted>`_.
|
|
||||||
/// :rtype: bool
|
|
||||||
///
|
|
||||||
/// >>> RdfFormat.N_TRIPLES.supports_rdf_star
|
|
||||||
/// True
|
|
||||||
/// >>> RdfFormat.RDF_XML.supports_rdf_star
|
|
||||||
/// False
|
|
||||||
#[getter] |
|
||||||
pub const fn supports_rdf_star(&self) -> bool { |
|
||||||
self.inner.supports_rdf_star() |
|
||||||
} |
|
||||||
|
|
||||||
/// Looks for a known format from a media type.
|
|
||||||
///
|
|
||||||
/// It supports some media type aliases.
|
|
||||||
/// For example, "application/xml" is going to return RDF/XML even if it is not its canonical media type.
|
|
||||||
///
|
|
||||||
/// :param media_type: the media type.
|
|
||||||
/// :type media_type: str
|
|
||||||
/// :return: :py:class:`RdfFormat` if the media type is known or :py:const:`None` if not.
|
|
||||||
/// :rtype: RdfFormat or None
|
|
||||||
///
|
|
||||||
/// >>> RdfFormat.from_media_type("text/turtle; charset=utf-8")
|
|
||||||
/// <RdfFormat Turtle>
|
|
||||||
#[staticmethod] |
|
||||||
pub fn from_media_type(media_type: &str) -> Option<Self> { |
|
||||||
Some(Self { |
|
||||||
inner: RdfFormat::from_media_type(media_type)?, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Looks for a known format from an extension.
|
|
||||||
///
|
|
||||||
/// It supports some aliases.
|
|
||||||
///
|
|
||||||
/// :param extension: the extension.
|
|
||||||
/// :type extension: str
|
|
||||||
/// :return: :py:class:`RdfFormat` if the extension is known or :py:const:`None` if not.
|
|
||||||
/// :rtype: RdfFormat or None
|
|
||||||
///
|
|
||||||
/// >>> RdfFormat.from_extension("nt")
|
|
||||||
/// <RdfFormat N-Triples>
|
|
||||||
#[staticmethod] |
|
||||||
pub fn from_extension(extension: &str) -> Option<Self> { |
|
||||||
Some(Self { |
|
||||||
inner: RdfFormat::from_extension(extension)?, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
fn __str__(&self) -> &'static str { |
|
||||||
self.inner.name() |
|
||||||
} |
|
||||||
|
|
||||||
fn __repr__(&self) -> String { |
|
||||||
format!("<RdfFormat {}>", self.inner.name()) |
|
||||||
} |
|
||||||
|
|
||||||
fn __hash__(&self) -> u64 { |
|
||||||
hash(&self.inner) |
|
||||||
} |
|
||||||
|
|
||||||
fn __eq__(&self, other: &Self) -> bool { |
|
||||||
self.inner == other.inner |
|
||||||
} |
|
||||||
|
|
||||||
fn __ne__(&self, other: &Self) -> bool { |
|
||||||
self.inner != other.inner |
|
||||||
} |
|
||||||
|
|
||||||
/// :rtype: RdfFormat
|
|
||||||
fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
/// :type memo: typing.Any
|
|
||||||
/// :rtype: RdfFormat
|
|
||||||
#[allow(unused_variables)] |
|
||||||
fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
pub enum PyReadable { |
|
||||||
Bytes(Cursor<Vec<u8>>), |
|
||||||
Io(PyIo), |
|
||||||
File(File), |
|
||||||
} |
|
||||||
|
|
||||||
impl PyReadable { |
|
||||||
pub fn from_args( |
|
||||||
path: &Option<PathBuf>, |
|
||||||
input: Option<PyReadableInput>, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<Self> { |
|
||||||
match (path, input) { |
|
||||||
(Some(_), Some(_)) => Err(PyValueError::new_err( |
|
||||||
"input and file_path can't be both set at the same time", |
|
||||||
)), |
|
||||||
(Some(path), None) => Ok(Self::File(py.allow_threads(|| File::open(path))?)), |
|
||||||
(None, Some(input)) => Ok(input.into()), |
|
||||||
(None, None) => Err(PyValueError::new_err( |
|
||||||
"Either input or file_path must be set", |
|
||||||
)), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl Read for PyReadable { |
|
||||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { |
|
||||||
match self { |
|
||||||
Self::Bytes(bytes) => bytes.read(buf), |
|
||||||
Self::Io(io) => io.read(buf), |
|
||||||
Self::File(file) => file.read(buf), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#[derive(FromPyObject)] |
|
||||||
pub enum PyReadableInput { |
|
||||||
String(String), |
|
||||||
Bytes(Vec<u8>), |
|
||||||
Io(PyObject), |
|
||||||
} |
|
||||||
|
|
||||||
impl From<PyReadableInput> for PyReadable { |
|
||||||
fn from(input: PyReadableInput) -> Self { |
|
||||||
match input { |
|
||||||
PyReadableInput::String(string) => Self::Bytes(Cursor::new(string.into_bytes())), |
|
||||||
PyReadableInput::Bytes(bytes) => Self::Bytes(Cursor::new(bytes)), |
|
||||||
PyReadableInput::Io(io) => Self::Io(PyIo(io)), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
pub enum PyWritable { |
|
||||||
Bytes(Vec<u8>), |
|
||||||
Io(PyIo), |
|
||||||
File(File), |
|
||||||
} |
|
||||||
|
|
||||||
impl PyWritable { |
|
||||||
pub fn do_write( |
|
||||||
write: impl FnOnce(BufWriter<Self>, Option<PathBuf>) -> PyResult<BufWriter<Self>>, |
|
||||||
output: Option<PyWritableOutput>, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<Option<Bound<'_, PyBytes>>> { |
|
||||||
let (output, file_path) = match output { |
|
||||||
Some(PyWritableOutput::Path(file_path)) => ( |
|
||||||
Self::File(py.allow_threads(|| File::create(&file_path))?), |
|
||||||
Some(file_path), |
|
||||||
), |
|
||||||
Some(PyWritableOutput::Io(object)) => (Self::Io(PyIo(object)), None), |
|
||||||
None => (Self::Bytes(Vec::new()), None), |
|
||||||
}; |
|
||||||
let writer = write(BufWriter::new(output), file_path)?; |
|
||||||
py.allow_threads(|| writer.into_inner())?.close(py) |
|
||||||
} |
|
||||||
|
|
||||||
fn close(self, py: Python<'_>) -> PyResult<Option<Bound<'_, PyBytes>>> { |
|
||||||
match self { |
|
||||||
Self::Bytes(bytes) => Ok(Some(PyBytes::new_bound(py, &bytes))), |
|
||||||
Self::File(mut file) => { |
|
||||||
py.allow_threads(|| { |
|
||||||
file.flush()?; |
|
||||||
file.sync_all() |
|
||||||
})?; |
|
||||||
Ok(None) |
|
||||||
} |
|
||||||
Self::Io(mut io) => { |
|
||||||
py.allow_threads(|| io.flush())?; |
|
||||||
Ok(None) |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl Write for PyWritable { |
|
||||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
|
||||||
match self { |
|
||||||
Self::Bytes(bytes) => bytes.write(buf), |
|
||||||
Self::Io(io) => io.write(buf), |
|
||||||
Self::File(file) => file.write(buf), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
fn flush(&mut self) -> io::Result<()> { |
|
||||||
match self { |
|
||||||
Self::Bytes(_) => Ok(()), |
|
||||||
Self::Io(io) => io.flush(), |
|
||||||
Self::File(file) => file.flush(), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#[derive(FromPyObject)] |
|
||||||
pub enum PyWritableOutput { |
|
||||||
Path(PathBuf), |
|
||||||
Io(PyObject), |
|
||||||
} |
|
||||||
|
|
||||||
pub struct PyIo(PyObject); |
|
||||||
|
|
||||||
impl Read for PyIo { |
|
||||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { |
|
||||||
Python::with_gil(|py| { |
|
||||||
if buf.is_empty() { |
|
||||||
return Ok(0); |
|
||||||
} |
|
||||||
let to_read = max(1, buf.len() / 4); // We divide by 4 because TextIO works with number of characters and not with number of bytes
|
|
||||||
let read = self |
|
||||||
.0 |
|
||||||
.bind(py) |
|
||||||
.call_method1(intern!(py, "read"), (to_read,))?; |
|
||||||
Ok(if let Ok(bytes) = read.extract::<&[u8]>() { |
|
||||||
buf[..bytes.len()].copy_from_slice(bytes); |
|
||||||
bytes.len() |
|
||||||
} else { |
|
||||||
// TODO: Python 3.10+ use directly .extract<&str>
|
|
||||||
let string = read.extract::<Bound<'_, PyString>>()?; |
|
||||||
let str = string.to_cow()?; |
|
||||||
buf[..str.len()].copy_from_slice(str.as_bytes()); |
|
||||||
str.len() |
|
||||||
}) |
|
||||||
}) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl Write for PyIo { |
|
||||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
|
||||||
Python::with_gil(|py| { |
|
||||||
Ok(self |
|
||||||
.0 |
|
||||||
.bind(py) |
|
||||||
.call_method1(intern!(py, "write"), (PyBytes::new_bound(py, buf),))? |
|
||||||
.extract::<usize>()?) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
fn flush(&mut self) -> io::Result<()> { |
|
||||||
Python::with_gil(|py| { |
|
||||||
self.0.bind(py).call_method0(intern!(py, "flush"))?; |
|
||||||
Ok(()) |
|
||||||
}) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
pub fn lookup_rdf_format( |
|
||||||
format: Option<PyRdfFormatInput>, |
|
||||||
path: Option<&Path>, |
|
||||||
) -> PyResult<RdfFormat> { |
|
||||||
if let Some(format) = format { |
|
||||||
return match format { |
|
||||||
PyRdfFormatInput::Object(format) => Ok(format.inner), |
|
||||||
PyRdfFormatInput::MediaType(media_type) => { |
|
||||||
deprecation_warning("Using string to specify a RDF format is deprecated, please use a RdfFormat object instead.")?; |
|
||||||
RdfFormat::from_media_type(&media_type).ok_or_else(|| { |
|
||||||
PyValueError::new_err(format!( |
|
||||||
"The media type {media_type} is not supported by pyoxigraph" |
|
||||||
)) |
|
||||||
}) |
|
||||||
} |
|
||||||
}; |
|
||||||
} |
|
||||||
let Some(path) = path else { |
|
||||||
return Err(PyValueError::new_err( |
|
||||||
"The format parameter is required when a file path is not given", |
|
||||||
)); |
|
||||||
}; |
|
||||||
let Some(ext) = path.extension().and_then(OsStr::to_str) else { |
|
||||||
return Err(PyValueError::new_err(format!( |
|
||||||
"The file name {} has no extension to guess a file format from", |
|
||||||
path.display() |
|
||||||
))); |
|
||||||
}; |
|
||||||
RdfFormat::from_extension(ext) |
|
||||||
.ok_or_else(|| PyValueError::new_err(format!("Not supported RDF format extension: {ext}"))) |
|
||||||
} |
|
||||||
|
|
||||||
#[derive(FromPyObject)] |
|
||||||
pub enum PyRdfFormatInput { |
|
||||||
Object(PyRdfFormat), |
|
||||||
MediaType(String), |
|
||||||
} |
|
||||||
|
|
||||||
pub fn map_parse_error(error: RdfParseError, file_path: Option<PathBuf>) -> PyErr { |
|
||||||
match error { |
|
||||||
RdfParseError::Syntax(error) => { |
|
||||||
// Python 3.9 does not support end line and end column
|
|
||||||
if python_version() >= (3, 10) { |
|
||||||
let params = if let Some(location) = error.location() { |
|
||||||
( |
|
||||||
file_path, |
|
||||||
Some(location.start.line + 1), |
|
||||||
Some(location.start.column + 1), |
|
||||||
None::<Vec<u8>>, |
|
||||||
Some(location.end.line + 1), |
|
||||||
Some(location.end.column + 1), |
|
||||||
) |
|
||||||
} else { |
|
||||||
(None, None, None, None, None, None) |
|
||||||
}; |
|
||||||
PySyntaxError::new_err((error.to_string(), params)) |
|
||||||
} else { |
|
||||||
let params = if let Some(location) = error.location() { |
|
||||||
( |
|
||||||
file_path, |
|
||||||
Some(location.start.line + 1), |
|
||||||
Some(location.start.column + 1), |
|
||||||
None::<Vec<u8>>, |
|
||||||
) |
|
||||||
} else { |
|
||||||
(None, None, None, None) |
|
||||||
}; |
|
||||||
PySyntaxError::new_err((error.to_string(), params)) |
|
||||||
} |
|
||||||
} |
|
||||||
RdfParseError::Io(error) => error.into(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Release the GIL
|
|
||||||
/// There should not be ANY use of pyo3 code inside of this method!!!
|
|
||||||
///
|
|
||||||
/// Code from pyo3: https://github.com/PyO3/pyo3/blob/a67180c8a42a0bc0fdc45b651b62c0644130cf47/src/python.rs#L366
|
|
||||||
#[allow(unsafe_code)] |
|
||||||
pub fn allow_threads_unsafe<T>(_py: Python<'_>, f: impl FnOnce() -> T) -> T { |
|
||||||
struct RestoreGuard { |
|
||||||
tstate: *mut pyo3::ffi::PyThreadState, |
|
||||||
} |
|
||||||
|
|
||||||
impl Drop for RestoreGuard { |
|
||||||
fn drop(&mut self) { |
|
||||||
// SAFETY: not cloned so called once
|
|
||||||
unsafe { |
|
||||||
pyo3::ffi::PyEval_RestoreThread(self.tstate); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
// SAFETY: we have the restore part in Drop to make sure it's properly executed
|
|
||||||
let tstate = unsafe { pyo3::ffi::PyEval_SaveThread() }; |
|
||||||
let _guard = RestoreGuard { tstate }; |
|
||||||
f() |
|
||||||
} |
|
||||||
|
|
||||||
pub fn python_version() -> (u8, u8) { |
|
||||||
static VERSION: OnceLock<(u8, u8)> = OnceLock::new(); |
|
||||||
*VERSION.get_or_init(|| { |
|
||||||
Python::with_gil(|py| { |
|
||||||
let v = py.version_info(); |
|
||||||
(v.major, v.minor) |
|
||||||
}) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
pub fn deprecation_warning(message: &str) -> PyResult<()> { |
|
||||||
Python::with_gil(|py| { |
|
||||||
PyErr::warn_bound(py, &py.get_type_bound::<PyDeprecationWarning>(), message, 0) |
|
||||||
}) |
|
||||||
} |
|
||||||
@ -1,47 +0,0 @@ |
|||||||
#![allow(
|
|
||||||
clippy::unused_self, |
|
||||||
clippy::trivially_copy_pass_by_ref, |
|
||||||
unused_qualifications |
|
||||||
)] |
|
||||||
|
|
||||||
mod dataset; |
|
||||||
mod io; |
|
||||||
mod model; |
|
||||||
mod sparql; |
|
||||||
mod store; |
|
||||||
|
|
||||||
use crate::dataset::*; |
|
||||||
use crate::io::*; |
|
||||||
use crate::model::*; |
|
||||||
use crate::sparql::*; |
|
||||||
use crate::store::*; |
|
||||||
use pyo3::prelude::*; |
|
||||||
|
|
||||||
/// Oxigraph Python bindings
|
|
||||||
#[pymodule] |
|
||||||
fn pyoxigraph(_py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> { |
|
||||||
module.add("__package__", "pyoxigraph")?; |
|
||||||
module.add("__version__", env!("CARGO_PKG_VERSION"))?; |
|
||||||
module.add("__author__", env!("CARGO_PKG_AUTHORS").replace(':', "\n"))?; |
|
||||||
|
|
||||||
module.add_class::<PyNamedNode>()?; |
|
||||||
module.add_class::<PyBlankNode>()?; |
|
||||||
module.add_class::<PyLiteral>()?; |
|
||||||
module.add_class::<PyDefaultGraph>()?; |
|
||||||
module.add_class::<PyTriple>()?; |
|
||||||
module.add_class::<PyQuad>()?; |
|
||||||
module.add_class::<PyDataset>()?; |
|
||||||
module.add_class::<PyStore>()?; |
|
||||||
module.add_class::<PyVariable>()?; |
|
||||||
module.add_class::<PyQuerySolutions>()?; |
|
||||||
module.add_class::<PyQuerySolution>()?; |
|
||||||
module.add_class::<PyQueryBoolean>()?; |
|
||||||
module.add_class::<PyQueryTriples>()?; |
|
||||||
module.add_class::<PyRdfFormat>()?; |
|
||||||
module.add_class::<PyQueryResultsFormat>()?; |
|
||||||
module.add_class::<PyCanonicalizationAlgorithm>()?; |
|
||||||
module.add_wrapped(wrap_pyfunction!(parse))?; |
|
||||||
module.add_wrapped(wrap_pyfunction!(parse_query_results))?; |
|
||||||
module.add_wrapped(wrap_pyfunction!(serialize))?; |
|
||||||
Ok(()) |
|
||||||
} |
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,740 +0,0 @@ |
|||||||
use crate::io::*; |
|
||||||
use crate::model::*; |
|
||||||
use crate::store::map_storage_error; |
|
||||||
use oxigraph::io::RdfSerializer; |
|
||||||
use oxigraph::model::Term; |
|
||||||
use oxigraph::sparql::results::{ |
|
||||||
FromReadQueryResultsReader, FromReadSolutionsReader, QueryResultsFormat, |
|
||||||
QueryResultsParseError, QueryResultsParser, QueryResultsSerializer, |
|
||||||
}; |
|
||||||
use oxigraph::sparql::{ |
|
||||||
EvaluationError, Query, QueryResults, QuerySolution, QuerySolutionIter, QueryTripleIter, |
|
||||||
Variable, |
|
||||||
}; |
|
||||||
use pyo3::basic::CompareOp; |
|
||||||
use pyo3::exceptions::{PyRuntimeError, PySyntaxError, PyValueError}; |
|
||||||
use pyo3::prelude::*; |
|
||||||
use pyo3::types::{PyBytes, PyString}; |
|
||||||
use std::ffi::OsStr; |
|
||||||
use std::io; |
|
||||||
use std::path::{Path, PathBuf}; |
|
||||||
use std::vec::IntoIter; |
|
||||||
|
|
||||||
pub fn parse_query( |
|
||||||
query: &str, |
|
||||||
base_iri: Option<&str>, |
|
||||||
use_default_graph_as_union: bool, |
|
||||||
default_graph: Option<&Bound<'_, PyAny>>, |
|
||||||
named_graphs: Option<&Bound<'_, PyAny>>, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<Query> { |
|
||||||
let mut query = allow_threads_unsafe(py, || Query::parse(query, base_iri)) |
|
||||||
.map_err(|e| map_evaluation_error(e.into()))?; |
|
||||||
|
|
||||||
if use_default_graph_as_union && default_graph.is_some() { |
|
||||||
return Err(PyValueError::new_err( |
|
||||||
"The query() method use_default_graph_as_union and default_graph arguments should not be set at the same time", |
|
||||||
)); |
|
||||||
} |
|
||||||
|
|
||||||
if use_default_graph_as_union { |
|
||||||
query.dataset_mut().set_default_graph_as_union(); |
|
||||||
} |
|
||||||
|
|
||||||
if let Some(default_graph) = default_graph { |
|
||||||
if let Ok(default_graphs) = default_graph.iter() { |
|
||||||
query.dataset_mut().set_default_graph( |
|
||||||
default_graphs |
|
||||||
.map(|graph| Ok(graph?.extract::<PyGraphName>()?.into())) |
|
||||||
.collect::<PyResult<_>>()?, |
|
||||||
) |
|
||||||
} else if let Ok(default_graph) = default_graph.extract::<PyGraphName>() { |
|
||||||
query |
|
||||||
.dataset_mut() |
|
||||||
.set_default_graph(vec![default_graph.into()]); |
|
||||||
} else { |
|
||||||
return Err(PyValueError::new_err( |
|
||||||
format!("The query() method default_graph argument should be a NamedNode, a BlankNode, the DefaultGraph or a not empty list of them. {} found", default_graph.get_type() |
|
||||||
))); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
if let Some(named_graphs) = named_graphs { |
|
||||||
query.dataset_mut().set_available_named_graphs( |
|
||||||
named_graphs |
|
||||||
.iter()? |
|
||||||
.map(|graph| Ok(graph?.extract::<PyNamedOrBlankNode>()?.into())) |
|
||||||
.collect::<PyResult<_>>()?, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
Ok(query) |
|
||||||
} |
|
||||||
|
|
||||||
pub fn query_results_to_python(py: Python<'_>, results: QueryResults) -> PyObject { |
|
||||||
match results { |
|
||||||
QueryResults::Solutions(inner) => PyQuerySolutions { |
|
||||||
inner: PyQuerySolutionsVariant::Query(inner), |
|
||||||
} |
|
||||||
.into_py(py), |
|
||||||
QueryResults::Graph(inner) => PyQueryTriples { inner }.into_py(py), |
|
||||||
QueryResults::Boolean(inner) => PyQueryBoolean { inner }.into_py(py), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Tuple associating variables and terms that are the result of a SPARQL ``SELECT`` query.
|
|
||||||
///
|
|
||||||
/// It is the equivalent of a row in SQL.
|
|
||||||
///
|
|
||||||
/// It could be indexes by variable name (:py:class:`Variable` or :py:class:`str`) or position in the tuple (:py:class:`int`).
|
|
||||||
/// Unpacking also works.
|
|
||||||
///
|
|
||||||
/// >>> 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>
|
|
||||||
#[pyclass(frozen, name = "QuerySolution", module = "pyoxigraph")] |
|
||||||
pub struct PyQuerySolution { |
|
||||||
inner: QuerySolution, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyQuerySolution { |
|
||||||
fn __repr__(&self) -> String { |
|
||||||
let mut buffer = String::new(); |
|
||||||
buffer.push_str("<QuerySolution"); |
|
||||||
for (k, v) in self.inner.iter() { |
|
||||||
buffer.push(' '); |
|
||||||
buffer.push_str(k.as_str()); |
|
||||||
buffer.push('='); |
|
||||||
term_repr(v.as_ref(), &mut buffer) |
|
||||||
} |
|
||||||
buffer.push('>'); |
|
||||||
buffer |
|
||||||
} |
|
||||||
|
|
||||||
fn __eq__(&self, other: &Self) -> bool { |
|
||||||
self.inner == other.inner |
|
||||||
} |
|
||||||
|
|
||||||
fn __ne__(&self, other: &Self) -> bool { |
|
||||||
self.inner != other.inner |
|
||||||
} |
|
||||||
|
|
||||||
fn __len__(&self) -> usize { |
|
||||||
self.inner.len() |
|
||||||
} |
|
||||||
|
|
||||||
fn __getitem__(&self, key: PySolutionKey<'_>) -> PyResult<Option<PyTerm>> { |
|
||||||
Ok(match key { |
|
||||||
PySolutionKey::Usize(key) => self.inner.get(key), |
|
||||||
PySolutionKey::Str(key) => self.inner.get(key.to_cow()?.as_ref()), |
|
||||||
PySolutionKey::Variable(key) => self.inner.get(<&Variable>::from(&*key)), |
|
||||||
} |
|
||||||
.map(|term| PyTerm::from(term.clone()))) |
|
||||||
} |
|
||||||
|
|
||||||
#[allow(clippy::unnecessary_to_owned)] |
|
||||||
fn __iter__(&self) -> SolutionValueIter { |
|
||||||
SolutionValueIter { |
|
||||||
inner: self.inner.values().to_vec().into_iter(), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#[derive(FromPyObject)] |
|
||||||
pub enum PySolutionKey<'a> { |
|
||||||
Usize(usize), |
|
||||||
Str(Bound<'a, PyString>), // TODO: Python 3.10+: use &str
|
|
||||||
Variable(PyRef<'a, PyVariable>), |
|
||||||
} |
|
||||||
|
|
||||||
#[pyclass(module = "pyoxigraph")] |
|
||||||
pub struct SolutionValueIter { |
|
||||||
inner: IntoIter<Option<Term>>, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl SolutionValueIter { |
|
||||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
fn __next__(&mut self) -> Option<Option<PyTerm>> { |
|
||||||
self.inner.next().map(|v| v.map(PyTerm::from)) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// An iterator of :py:class:`QuerySolution` returned by a SPARQL ``SELECT`` query
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[pyclass(unsendable, name = "QuerySolutions", module = "pyoxigraph")] |
|
||||||
pub struct PyQuerySolutions { |
|
||||||
inner: PyQuerySolutionsVariant, |
|
||||||
} |
|
||||||
enum PyQuerySolutionsVariant { |
|
||||||
Query(QuerySolutionIter), |
|
||||||
Reader { |
|
||||||
iter: FromReadSolutionsReader<PyReadable>, |
|
||||||
file_path: Option<PathBuf>, |
|
||||||
}, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyQuerySolutions { |
|
||||||
/// :return: the ordered list of all variables that could appear in the query results
|
|
||||||
/// :rtype: list[Variable]
|
|
||||||
///
|
|
||||||
/// >>> store = Store()
|
|
||||||
/// >>> store.query('SELECT ?s WHERE { ?s ?p ?o }').variables
|
|
||||||
/// [<Variable value=s>]
|
|
||||||
#[getter] |
|
||||||
fn variables(&self) -> Vec<PyVariable> { |
|
||||||
match &self.inner { |
|
||||||
PyQuerySolutionsVariant::Query(inner) => { |
|
||||||
inner.variables().iter().map(|v| v.clone().into()).collect() |
|
||||||
} |
|
||||||
PyQuerySolutionsVariant::Reader { iter, .. } => { |
|
||||||
iter.variables().iter().map(|v| v.clone().into()).collect() |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Writes the query results into a file.
|
|
||||||
///
|
|
||||||
/// It currently supports the following formats:
|
|
||||||
///
|
|
||||||
/// * `XML <https://www.w3.org/TR/rdf-sparql-XMLres/>`_ (:py:attr:`QueryResultsFormat.XML`)
|
|
||||||
/// * `JSON <https://www.w3.org/TR/sparql11-results-json/>`_ (:py:attr:`QueryResultsFormat.JSON`)
|
|
||||||
/// * `CSV <https://www.w3.org/TR/sparql11-results-csv-tsv/>`_ (:py:attr:`QueryResultsFormat.CSV`)
|
|
||||||
/// * `TSV <https://www.w3.org/TR/sparql11-results-csv-tsv/>`_ (:py:attr:`QueryResultsFormat.TSV`)
|
|
||||||
///
|
|
||||||
/// It supports also some media type and extension aliases.
|
|
||||||
/// For example, ``application/json`` could also be used for `JSON <https://www.w3.org/TR/sparql11-results-json/>`_.
|
|
||||||
///
|
|
||||||
/// :param output: The binary I/O object or file path to write to. For example, it could be a file path as a string or a file writer opened in binary mode with ``open('my_file.ttl', 'wb')``. If :py:const:`None`, a :py:class:`bytes` buffer is returned with the serialized content.
|
|
||||||
/// :type output: typing.IO[bytes] or str or os.PathLike[str] or None, optional
|
|
||||||
/// :param format: the format of the query results serialization. If :py:const:`None`, the format is guessed from the file name extension.
|
|
||||||
/// :type format: QueryResultsFormat or None, optional
|
|
||||||
/// :rtype: bytes or None
|
|
||||||
/// :raises ValueError: if the format is not supported.
|
|
||||||
/// :raises OSError: if a system error happens while writing the file.
|
|
||||||
///
|
|
||||||
/// >>> 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"}}]}}'
|
|
||||||
#[pyo3(signature = (output = None, format = None))] |
|
||||||
fn serialize<'py>( |
|
||||||
&mut self, |
|
||||||
output: Option<PyWritableOutput>, |
|
||||||
format: Option<PyQueryResultsFormatInput>, |
|
||||||
py: Python<'py>, |
|
||||||
) -> PyResult<Option<Bound<'py, PyBytes>>> { |
|
||||||
PyWritable::do_write( |
|
||||||
|output, file_path| { |
|
||||||
let format = lookup_query_results_format(format, file_path.as_deref())?; |
|
||||||
let mut writer = QueryResultsSerializer::from_format(format) |
|
||||||
.serialize_solutions_to_write( |
|
||||||
output, |
|
||||||
match &self.inner { |
|
||||||
PyQuerySolutionsVariant::Query(inner) => inner.variables().to_vec(), |
|
||||||
PyQuerySolutionsVariant::Reader { iter, .. } => { |
|
||||||
iter.variables().to_vec() |
|
||||||
} |
|
||||||
}, |
|
||||||
)?; |
|
||||||
match &mut self.inner { |
|
||||||
PyQuerySolutionsVariant::Query(inner) => { |
|
||||||
for solution in inner { |
|
||||||
writer.write(&solution.map_err(map_evaluation_error)?)?; |
|
||||||
} |
|
||||||
} |
|
||||||
PyQuerySolutionsVariant::Reader { iter, file_path } => { |
|
||||||
for solution in iter { |
|
||||||
writer.write(&solution.map_err(|e| { |
|
||||||
map_query_results_parse_error(e, file_path.clone()) |
|
||||||
})?)?; |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
Ok(writer.finish()?) |
|
||||||
}, |
|
||||||
output, |
|
||||||
py, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
fn __next__(&mut self, py: Python<'_>) -> PyResult<Option<PyQuerySolution>> { |
|
||||||
Ok(match &mut self.inner { |
|
||||||
PyQuerySolutionsVariant::Query(inner) => allow_threads_unsafe(py, || { |
|
||||||
inner.next().transpose().map_err(map_evaluation_error) |
|
||||||
}), |
|
||||||
PyQuerySolutionsVariant::Reader { iter, file_path } => iter |
|
||||||
.next() |
|
||||||
.transpose() |
|
||||||
.map_err(|e| map_query_results_parse_error(e, file_path.clone())), |
|
||||||
}? |
|
||||||
.map(move |inner| PyQuerySolution { inner })) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// A boolean returned by a SPARQL ``ASK`` query.
|
|
||||||
///
|
|
||||||
/// It can be easily casted to a regular boolean using the :py:func:`bool` function.
|
|
||||||
///
|
|
||||||
/// >>> store = Store()
|
|
||||||
/// >>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
|
|
||||||
/// >>> bool(store.query('ASK { ?s ?p ?o }'))
|
|
||||||
/// True
|
|
||||||
#[pyclass(unsendable, name = "QueryBoolean", module = "pyoxigraph")] |
|
||||||
pub struct PyQueryBoolean { |
|
||||||
inner: bool, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyQueryBoolean { |
|
||||||
/// Writes the query results into a file.
|
|
||||||
///
|
|
||||||
/// It currently supports the following formats:
|
|
||||||
///
|
|
||||||
/// * `XML <https://www.w3.org/TR/rdf-sparql-XMLres/>`_ (:py:attr:`QueryResultsFormat.XML`)
|
|
||||||
/// * `JSON <https://www.w3.org/TR/sparql11-results-json/>`_ (:py:attr:`QueryResultsFormat.JSON`)
|
|
||||||
/// * `CSV <https://www.w3.org/TR/sparql11-results-csv-tsv/>`_ (:py:attr:`QueryResultsFormat.CSV`)
|
|
||||||
/// * `TSV <https://www.w3.org/TR/sparql11-results-csv-tsv/>`_ (:py:attr:`QueryResultsFormat.TSV`)
|
|
||||||
///
|
|
||||||
/// It supports also some media type and extension aliases.
|
|
||||||
/// For example, ``application/json`` could also be used for `JSON <https://www.w3.org/TR/sparql11-results-json/>`_.
|
|
||||||
///
|
|
||||||
/// :param output: The binary I/O object or file path to write to. For example, it could be a file path as a string or a file writer opened in binary mode with ``open('my_file.ttl', 'wb')``. If :py:const:`None`, a :py:class:`bytes` buffer is returned with the serialized content.
|
|
||||||
/// :type output: typing.IO[bytes] or str or os.PathLike[str] or None, optional
|
|
||||||
/// :param format: the format of the query results serialization. If :py:const:`None`, the format is guessed from the file name extension.
|
|
||||||
/// :type format: QueryResultsFormat or None, optional
|
|
||||||
/// :rtype: bytes or None
|
|
||||||
/// :raises ValueError: if the format is not supported.
|
|
||||||
/// :raises OSError: if a system error happens while writing the file.
|
|
||||||
///
|
|
||||||
/// >>> 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}'
|
|
||||||
#[pyo3(signature = (output = None, format = None))] |
|
||||||
fn serialize<'py>( |
|
||||||
&mut self, |
|
||||||
output: Option<PyWritableOutput>, |
|
||||||
format: Option<PyQueryResultsFormatInput>, |
|
||||||
py: Python<'py>, |
|
||||||
) -> PyResult<Option<Bound<'py, PyBytes>>> { |
|
||||||
PyWritable::do_write( |
|
||||||
|output, file_path| { |
|
||||||
let format = lookup_query_results_format(format, file_path.as_deref())?; |
|
||||||
py.allow_threads(|| { |
|
||||||
Ok(QueryResultsSerializer::from_format(format) |
|
||||||
.serialize_boolean_to_write(output, self.inner)?) |
|
||||||
}) |
|
||||||
}, |
|
||||||
output, |
|
||||||
py, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
fn __bool__(&self) -> bool { |
|
||||||
self.inner |
|
||||||
} |
|
||||||
|
|
||||||
fn __richcmp__(&self, other: &Self, op: CompareOp) -> bool { |
|
||||||
op.matches(self.inner.cmp(&other.inner)) |
|
||||||
} |
|
||||||
|
|
||||||
fn __hash__(&self) -> u64 { |
|
||||||
self.inner.into() |
|
||||||
} |
|
||||||
|
|
||||||
fn __repr__(&self) -> String { |
|
||||||
format!("<QueryBoolean {}>", self.inner) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// An iterator of :py:class:`Triple` returned by a SPARQL ``CONSTRUCT`` or ``DESCRIBE`` query
|
|
||||||
///
|
|
||||||
/// >>> 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>>>]
|
|
||||||
#[pyclass(unsendable, name = "QueryTriples", module = "pyoxigraph")] |
|
||||||
pub struct PyQueryTriples { |
|
||||||
inner: QueryTripleIter, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyQueryTriples { |
|
||||||
/// Writes the query results into a file.
|
|
||||||
///
|
|
||||||
/// It currently supports the following formats:
|
|
||||||
///
|
|
||||||
/// * `canonical <https://www.w3.org/TR/n-triples/#canonical-ntriples>`_ `N-Triples <https://www.w3.org/TR/n-triples/>`_ (:py:attr:`RdfFormat.N_TRIPLES`)
|
|
||||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (:py:attr:`RdfFormat.N_QUADS`)
|
|
||||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (:py:attr:`RdfFormat.TURTLE`)
|
|
||||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (:py:attr:`RdfFormat.TRIG`)
|
|
||||||
/// * `N3 <https://w3c.github.io/N3/spec/>`_ (:py:attr:`RdfFormat.N3`)
|
|
||||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (:py:attr:`RdfFormat.RDF_XML`)
|
|
||||||
///
|
|
||||||
/// It supports also some media type and extension aliases.
|
|
||||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
|
||||||
/// and ``application/xml`` or ``xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
|
||||||
///
|
|
||||||
/// :param output: The binary I/O object or file path to write to. For example, it could be a file path as a string or a file writer opened in binary mode with ``open('my_file.ttl', 'wb')``. If :py:const:`None`, a :py:class:`bytes` buffer is returned with the serialized content.
|
|
||||||
/// :type output: typing.IO[bytes] or str or os.PathLike[str] or None, optional
|
|
||||||
/// :param format: the format of the RDF serialization. If :py:const:`None`, the format is guessed from the file name extension.
|
|
||||||
/// :type format: RdfFormat or None, optional
|
|
||||||
/// :rtype: bytes or None
|
|
||||||
/// :raises ValueError: if the format is not supported.
|
|
||||||
/// :raises OSError: if a system error happens while writing the file.
|
|
||||||
///
|
|
||||||
/// >>> 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'
|
|
||||||
#[pyo3(signature = (output = None, format = None))] |
|
||||||
fn serialize<'py>( |
|
||||||
&mut self, |
|
||||||
output: Option<PyWritableOutput>, |
|
||||||
format: Option<PyRdfFormatInput>, |
|
||||||
py: Python<'py>, |
|
||||||
) -> PyResult<Option<Bound<'py, PyBytes>>> { |
|
||||||
PyWritable::do_write( |
|
||||||
|output, file_path| { |
|
||||||
let format = lookup_rdf_format(format, file_path.as_deref())?; |
|
||||||
let mut writer = RdfSerializer::from_format(format).serialize_to_write(output); |
|
||||||
for triple in &mut self.inner { |
|
||||||
writer.write_triple(&triple.map_err(map_evaluation_error)?)?; |
|
||||||
} |
|
||||||
Ok(writer.finish()?) |
|
||||||
}, |
|
||||||
output, |
|
||||||
py, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
fn __next__(&mut self, py: Python<'_>) -> PyResult<Option<PyTriple>> { |
|
||||||
Ok(allow_threads_unsafe(py, || self.inner.next()) |
|
||||||
.transpose() |
|
||||||
.map_err(map_evaluation_error)? |
|
||||||
.map(Into::into)) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Parses SPARQL query results.
|
|
||||||
///
|
|
||||||
/// It currently supports the following formats:
|
|
||||||
///
|
|
||||||
/// * `XML <https://www.w3.org/TR/rdf-sparql-XMLres/>`_ (:py:attr:`QueryResultsFormat.XML`)
|
|
||||||
/// * `JSON <https://www.w3.org/TR/sparql11-results-json/>`_ (:py:attr:`QueryResultsFormat.JSON`)
|
|
||||||
/// * `TSV <https://www.w3.org/TR/sparql11-results-csv-tsv/>`_ (:py:attr:`QueryResultsFormat.TSV`)
|
|
||||||
///
|
|
||||||
/// It supports also some media type and extension aliases.
|
|
||||||
/// For example, ``application/json`` could also be used for `JSON <https://www.w3.org/TR/sparql11-results-json/>`_.
|
|
||||||
///
|
|
||||||
/// :param input: The :py:class:`str`, :py:class:`bytes` or I/O object to read from. For example, it could be the file content as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``.
|
|
||||||
/// :type input: bytes or str or typing.IO[bytes] or typing.IO[str] or None, optional
|
|
||||||
/// :param format: the format of the query results serialization. If :py:const:`None`, the format is guessed from the file name extension.
|
|
||||||
/// :type format: QueryResultsFormat or None, optional
|
|
||||||
/// :param path: The file path to read from. Replaces the ``input`` parameter.
|
|
||||||
/// :type path: str or os.PathLike[str] or None, optional
|
|
||||||
/// :return: an iterator of :py:class:`QuerySolution` or a :py:class:`bool`.
|
|
||||||
/// :rtype: QuerySolutions or QueryBoolean
|
|
||||||
/// :raises ValueError: if the format is not supported.
|
|
||||||
/// :raises SyntaxError: if the provided data is invalid.
|
|
||||||
/// :raises OSError: if a system error happens while reading the file.
|
|
||||||
///
|
|
||||||
/// >>> list(parse_query_results('?s\t?p\t?o\n<http://example.com/s>\t<http://example.com/s>\t1\n', QueryResultsFormat.TSV))
|
|
||||||
/// [<QuerySolution s=<NamedNode value=http://example.com/s> p=<NamedNode value=http://example.com/s> o=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#integer>>>]
|
|
||||||
///
|
|
||||||
/// >>> parse_query_results('{"head":{},"boolean":true}', QueryResultsFormat.JSON)
|
|
||||||
/// <QueryBoolean true>
|
|
||||||
#[pyfunction] |
|
||||||
#[pyo3(signature = (input = None, format = None, *, path = None))] |
|
||||||
pub fn parse_query_results( |
|
||||||
input: Option<PyReadableInput>, |
|
||||||
format: Option<PyQueryResultsFormatInput>, |
|
||||||
path: Option<PathBuf>, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<PyObject> { |
|
||||||
let input = PyReadable::from_args(&path, input, py)?; |
|
||||||
let format = lookup_query_results_format(format, path.as_deref())?; |
|
||||||
let results = QueryResultsParser::from_format(format) |
|
||||||
.parse_read(input) |
|
||||||
.map_err(|e| map_query_results_parse_error(e, path.clone()))?; |
|
||||||
Ok(match results { |
|
||||||
FromReadQueryResultsReader::Solutions(iter) => PyQuerySolutions { |
|
||||||
inner: PyQuerySolutionsVariant::Reader { |
|
||||||
iter, |
|
||||||
file_path: path, |
|
||||||
}, |
|
||||||
} |
|
||||||
.into_py(py), |
|
||||||
FromReadQueryResultsReader::Boolean(inner) => PyQueryBoolean { inner }.into_py(py), |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// `SPARQL query <https://www.w3.org/TR/sparql11-query/>`_ results serialization formats.
|
|
||||||
///
|
|
||||||
/// The following formats are supported:
|
|
||||||
///
|
|
||||||
/// * `XML <https://www.w3.org/TR/rdf-sparql-XMLres/>`_ (:py:attr:`QueryResultsFormat.XML`)
|
|
||||||
/// * `JSON <https://www.w3.org/TR/sparql11-results-json/>`_ (:py:attr:`QueryResultsFormat.JSON`)
|
|
||||||
/// * `CSV <https://www.w3.org/TR/sparql11-results-csv-tsv/>`_ (:py:attr:`QueryResultsFormat.CSV`)
|
|
||||||
/// * `TSV <https://www.w3.org/TR/sparql11-results-csv-tsv/>`_ (:py:attr:`QueryResultsFormat.TSV`)
|
|
||||||
#[pyclass(name = "QueryResultsFormat", module = "pyoxigraph")] |
|
||||||
#[derive(Clone)] |
|
||||||
pub struct PyQueryResultsFormat { |
|
||||||
inner: QueryResultsFormat, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyQueryResultsFormat { |
|
||||||
/// `SPARQL Query Results CSV Format <https://www.w3.org/TR/sparql11-results-csv-tsv/>`_
|
|
||||||
#[classattr] |
|
||||||
const CSV: Self = Self { |
|
||||||
inner: QueryResultsFormat::Csv, |
|
||||||
}; |
|
||||||
/// `SPARQL Query Results JSON Format <https://www.w3.org/TR/sparql11-results-json/>`_
|
|
||||||
#[classattr] |
|
||||||
const JSON: Self = Self { |
|
||||||
inner: QueryResultsFormat::Json, |
|
||||||
}; |
|
||||||
/// `SPARQL Query Results TSV Format <https://www.w3.org/TR/sparql11-results-csv-tsv/>`_
|
|
||||||
#[classattr] |
|
||||||
const TSV: Self = Self { |
|
||||||
inner: QueryResultsFormat::Tsv, |
|
||||||
}; |
|
||||||
/// `SPARQL Query Results XML Format <https://www.w3.org/TR/rdf-sparql-XMLres/>`_
|
|
||||||
#[classattr] |
|
||||||
const XML: Self = Self { |
|
||||||
inner: QueryResultsFormat::Xml, |
|
||||||
}; |
|
||||||
|
|
||||||
/// :return: the format canonical IRI according to the `Unique URIs for file formats registry <https://www.w3.org/ns/formats/>`_.
|
|
||||||
/// :rtype: str
|
|
||||||
///
|
|
||||||
/// >>> QueryResultsFormat.JSON.iri
|
|
||||||
/// 'http://www.w3.org/ns/formats/SPARQL_Results_JSON'
|
|
||||||
#[getter] |
|
||||||
fn iri(&self) -> &'static str { |
|
||||||
self.inner.iri() |
|
||||||
} |
|
||||||
|
|
||||||
/// :return: the format `IANA media type <https://tools.ietf.org/html/rfc2046>`_.
|
|
||||||
/// :rtype: str
|
|
||||||
///
|
|
||||||
/// >>> QueryResultsFormat.JSON.media_type
|
|
||||||
/// 'application/sparql-results+json'
|
|
||||||
#[getter] |
|
||||||
fn media_type(&self) -> &'static str { |
|
||||||
self.inner.media_type() |
|
||||||
} |
|
||||||
|
|
||||||
/// :return: the format `IANA-registered <https://tools.ietf.org/html/rfc2046>`_ file extension.
|
|
||||||
/// :rtype: str
|
|
||||||
///
|
|
||||||
/// >>> QueryResultsFormat.JSON.file_extension
|
|
||||||
/// 'srj'
|
|
||||||
#[getter] |
|
||||||
fn file_extension(&self) -> &'static str { |
|
||||||
self.inner.file_extension() |
|
||||||
} |
|
||||||
|
|
||||||
/// :return: the format name.
|
|
||||||
/// :rtype: str
|
|
||||||
///
|
|
||||||
/// >>> QueryResultsFormat.JSON.name
|
|
||||||
/// 'SPARQL Results in JSON'
|
|
||||||
#[getter] |
|
||||||
pub const fn name(&self) -> &'static str { |
|
||||||
self.inner.name() |
|
||||||
} |
|
||||||
|
|
||||||
/// Looks for a known format from a media type.
|
|
||||||
///
|
|
||||||
/// It supports some media type aliases.
|
|
||||||
/// For example, "application/xml" is going to return :py:const:`QueryResultsFormat.XML` even if it is not its canonical media type.
|
|
||||||
///
|
|
||||||
/// :param media_type: the media type.
|
|
||||||
/// :type media_type: str
|
|
||||||
/// :return: :py:class:`QueryResultsFormat` if the media type is known or :py:const:`None` if not.
|
|
||||||
/// :rtype: QueryResultsFormat or None
|
|
||||||
///
|
|
||||||
/// >>> QueryResultsFormat.from_media_type("application/sparql-results+json; charset=utf-8")
|
|
||||||
/// <QueryResultsFormat SPARQL Results in JSON>
|
|
||||||
#[staticmethod] |
|
||||||
fn from_media_type(media_type: &str) -> Option<Self> { |
|
||||||
Some(Self { |
|
||||||
inner: QueryResultsFormat::from_media_type(media_type)?, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Looks for a known format from an extension.
|
|
||||||
///
|
|
||||||
/// It supports some aliases.
|
|
||||||
///
|
|
||||||
/// :param extension: the extension.
|
|
||||||
/// :type extension: str
|
|
||||||
/// :return: :py:class:`QueryResultsFormat` if the extension is known or :py:const:`None` if not.
|
|
||||||
/// :rtype: QueryResultsFormat or None
|
|
||||||
///
|
|
||||||
/// >>> QueryResultsFormat.from_extension("json")
|
|
||||||
/// <QueryResultsFormat SPARQL Results in JSON>
|
|
||||||
#[staticmethod] |
|
||||||
fn from_extension(extension: &str) -> Option<Self> { |
|
||||||
Some(Self { |
|
||||||
inner: QueryResultsFormat::from_extension(extension)?, |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
fn __str__(&self) -> &'static str { |
|
||||||
self.inner.name() |
|
||||||
} |
|
||||||
|
|
||||||
fn __repr__(&self) -> String { |
|
||||||
format!("<QueryResultsFormat {}>", self.inner.name()) |
|
||||||
} |
|
||||||
|
|
||||||
fn __hash__(&self) -> u64 { |
|
||||||
hash(&self.inner) |
|
||||||
} |
|
||||||
|
|
||||||
fn __eq__(&self, other: &Self) -> bool { |
|
||||||
self.inner == other.inner |
|
||||||
} |
|
||||||
|
|
||||||
fn __ne__(&self, other: &Self) -> bool { |
|
||||||
self.inner != other.inner |
|
||||||
} |
|
||||||
|
|
||||||
/// :rtype: QueryResultsFormat
|
|
||||||
fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
/// :type memo: typing.Any
|
|
||||||
/// :rtype: QueryResultsFormat
|
|
||||||
#[allow(unused_variables)] |
|
||||||
fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
pub fn lookup_query_results_format( |
|
||||||
format: Option<PyQueryResultsFormatInput>, |
|
||||||
path: Option<&Path>, |
|
||||||
) -> PyResult<QueryResultsFormat> { |
|
||||||
if let Some(format) = format { |
|
||||||
return match format { |
|
||||||
PyQueryResultsFormatInput::Object(format) => Ok(format.inner), |
|
||||||
PyQueryResultsFormatInput::MediaType(media_type) => { |
|
||||||
deprecation_warning("Using a string to specify a query results format is deprecated, please use a QueryResultsFormat object instead.")?; |
|
||||||
QueryResultsFormat::from_media_type(&media_type).ok_or_else(|| { |
|
||||||
PyValueError::new_err(format!( |
|
||||||
"The media type {media_type} is not supported by pyoxigraph" |
|
||||||
)) |
|
||||||
}) |
|
||||||
} |
|
||||||
}; |
|
||||||
} |
|
||||||
let Some(path) = path else { |
|
||||||
return Err(PyValueError::new_err( |
|
||||||
"The format parameter is required when a file path is not given", |
|
||||||
)); |
|
||||||
}; |
|
||||||
let Some(ext) = path.extension().and_then(OsStr::to_str) else { |
|
||||||
return Err(PyValueError::new_err(format!( |
|
||||||
"The file name {} has no extension to guess a file format from", |
|
||||||
path.display() |
|
||||||
))); |
|
||||||
}; |
|
||||||
QueryResultsFormat::from_extension(ext) |
|
||||||
.ok_or_else(|| PyValueError::new_err(format!("Not supported RDF format extension: {ext}"))) |
|
||||||
} |
|
||||||
|
|
||||||
#[derive(FromPyObject)] |
|
||||||
pub enum PyQueryResultsFormatInput { |
|
||||||
Object(PyQueryResultsFormat), |
|
||||||
MediaType(String), |
|
||||||
} |
|
||||||
|
|
||||||
pub fn map_evaluation_error(error: EvaluationError) -> PyErr { |
|
||||||
match error { |
|
||||||
EvaluationError::Parsing(error) => PySyntaxError::new_err(error.to_string()), |
|
||||||
EvaluationError::Storage(error) => map_storage_error(error), |
|
||||||
EvaluationError::GraphParsing(error) => map_parse_error(error, None), |
|
||||||
EvaluationError::ResultsParsing(error) => map_query_results_parse_error(error, None), |
|
||||||
EvaluationError::ResultsSerialization(error) => error.into(), |
|
||||||
EvaluationError::Service(error) => match error.downcast::<io::Error>() { |
|
||||||
Ok(error) => (*error).into(), |
|
||||||
Err(error) => PyRuntimeError::new_err(error.to_string()), |
|
||||||
}, |
|
||||||
_ => PyRuntimeError::new_err(error.to_string()), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
pub fn map_query_results_parse_error( |
|
||||||
error: QueryResultsParseError, |
|
||||||
file_path: Option<PathBuf>, |
|
||||||
) -> PyErr { |
|
||||||
match error { |
|
||||||
QueryResultsParseError::Syntax(error) => { |
|
||||||
// Python 3.9 does not support end line and end column
|
|
||||||
if python_version() >= (3, 10) { |
|
||||||
let params = if let Some(location) = error.location() { |
|
||||||
( |
|
||||||
file_path, |
|
||||||
Some(location.start.line + 1), |
|
||||||
Some(location.start.column + 1), |
|
||||||
None::<Vec<u8>>, |
|
||||||
Some(location.end.line + 1), |
|
||||||
Some(location.end.column + 1), |
|
||||||
) |
|
||||||
} else { |
|
||||||
(None, None, None, None, None, None) |
|
||||||
}; |
|
||||||
PySyntaxError::new_err((error.to_string(), params)) |
|
||||||
} else { |
|
||||||
let params = if let Some(location) = error.location() { |
|
||||||
( |
|
||||||
file_path, |
|
||||||
Some(location.start.line + 1), |
|
||||||
Some(location.start.column + 1), |
|
||||||
None::<Vec<u8>>, |
|
||||||
) |
|
||||||
} else { |
|
||||||
(None, None, None, None) |
|
||||||
}; |
|
||||||
PySyntaxError::new_err((error.to_string(), params)) |
|
||||||
} |
|
||||||
} |
|
||||||
QueryResultsParseError::Io(error) => error.into(), |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,865 +0,0 @@ |
|||||||
#![allow(clippy::needless_option_as_deref)] |
|
||||||
|
|
||||||
use crate::io::{ |
|
||||||
allow_threads_unsafe, lookup_rdf_format, map_parse_error, PyRdfFormatInput, PyReadable, |
|
||||||
PyReadableInput, PyWritable, PyWritableOutput, |
|
||||||
}; |
|
||||||
use crate::model::*; |
|
||||||
use crate::sparql::*; |
|
||||||
use oxigraph::io::RdfParser; |
|
||||||
use oxigraph::model::GraphNameRef; |
|
||||||
use oxigraph::sparql::Update; |
|
||||||
use oxigraph::store::{self, LoaderError, SerializerError, StorageError, Store}; |
|
||||||
use pyo3::exceptions::{PyRuntimeError, PyValueError}; |
|
||||||
use pyo3::prelude::*; |
|
||||||
use pyo3::types::PyBytes; |
|
||||||
use std::path::PathBuf; |
|
||||||
|
|
||||||
/// RDF store.
|
|
||||||
///
|
|
||||||
/// It encodes a `RDF dataset <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset>`_ and allows to query it using SPARQL.
|
|
||||||
/// It is based on the `RocksDB <https://rocksdb.org/>`_ key-value database.
|
|
||||||
///
|
|
||||||
/// This store ensures the "repeatable read" isolation level: the store only exposes changes that have
|
|
||||||
/// been "committed" (i.e. no partial writes) and the exposed state does not change for the complete duration
|
|
||||||
/// of a read operation (e.g. a SPARQL query) or a read/write operation (e.g. a SPARQL update).
|
|
||||||
///
|
|
||||||
/// The :py:class:`Store` constructor opens a read-write instance.
|
|
||||||
/// To open a static read-only instance use :py:func:`Store.read_only`
|
|
||||||
/// and to open a read-only instance that tracks a read-write instance use :py:func:`Store.secondary`.
|
|
||||||
///
|
|
||||||
/// :param path: the path of the directory in which the store should read and write its data. If the directory does not exist, it is created.
|
|
||||||
/// If no directory is provided a temporary one is created and removed when the Python garbage collector removes the store.
|
|
||||||
/// In this case, the store data are kept in memory and never written on disk.
|
|
||||||
/// :type path: str or os.PathLike[str] or None, optional
|
|
||||||
/// :raises OSError: if the target directory contains invalid data or could not be accessed.
|
|
||||||
///
|
|
||||||
/// The :py:class:`str` function provides a serialization of the store in NQuads:
|
|
||||||
///
|
|
||||||
/// >>> 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'
|
|
||||||
#[pyclass(frozen, name = "Store", module = "pyoxigraph")] |
|
||||||
#[derive(Clone)] |
|
||||||
pub struct PyStore { |
|
||||||
inner: Store, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl PyStore { |
|
||||||
#[cfg(not(target_family = "wasm"))] |
|
||||||
#[new] |
|
||||||
#[pyo3(signature = (path = None))] |
|
||||||
fn new(path: Option<PathBuf>, py: Python<'_>) -> PyResult<Self> { |
|
||||||
py.allow_threads(|| { |
|
||||||
Ok(Self { |
|
||||||
inner: if let Some(path) = path { |
|
||||||
Store::open(path) |
|
||||||
} else { |
|
||||||
Store::new() |
|
||||||
} |
|
||||||
.map_err(map_storage_error)?, |
|
||||||
}) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
#[cfg(target_family = "wasm")] |
|
||||||
#[new] |
|
||||||
fn new(py: Python<'_>) -> PyResult<Self> { |
|
||||||
py.allow_threads(|| { |
|
||||||
Ok(Self { |
|
||||||
inner: Store::new().map_err(map_storage_error)?, |
|
||||||
}) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Opens a read-only store from disk.
|
|
||||||
///
|
|
||||||
/// Opening as read-only while having an other process writing the database is undefined behavior.
|
|
||||||
/// :py:func:`Store.secondary` should be used in this case.
|
|
||||||
///
|
|
||||||
/// :param path: path to the primary read-write instance data.
|
|
||||||
/// :type path: str
|
|
||||||
/// :return: the opened store.
|
|
||||||
/// :rtype: Store
|
|
||||||
/// :raises OSError: if the target directory contains invalid data or could not be accessed.
|
|
||||||
#[cfg(not(target_family = "wasm"))] |
|
||||||
#[staticmethod] |
|
||||||
fn read_only(path: &str, py: Python<'_>) -> PyResult<Self> { |
|
||||||
py.allow_threads(|| { |
|
||||||
Ok(Self { |
|
||||||
inner: Store::open_read_only(path).map_err(map_storage_error)?, |
|
||||||
}) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Opens a read-only clone of a running read-write store.
|
|
||||||
///
|
|
||||||
/// Changes done while this process is running will be replicated after a possible lag.
|
|
||||||
///
|
|
||||||
/// It should only be used if a primary instance opened with :py:func:`Store` is running at the same time.
|
|
||||||
///
|
|
||||||
/// If you want to simple read-only store use :py:func:`Store.read_only`.
|
|
||||||
///
|
|
||||||
/// :param primary_path: path to the primary read-write instance data.
|
|
||||||
/// :type primary_path: str
|
|
||||||
/// :param secondary_path: path to an other directory for the secondary instance cache. If not given a temporary directory will be used.
|
|
||||||
/// :type secondary_path: str or None, optional
|
|
||||||
/// :return: the opened store.
|
|
||||||
/// :rtype: Store
|
|
||||||
/// :raises OSError: if the target directories contain invalid data or could not be accessed.
|
|
||||||
#[cfg(not(target_family = "wasm"))] |
|
||||||
#[staticmethod] |
|
||||||
#[pyo3(signature = (primary_path, secondary_path = None))] |
|
||||||
fn secondary( |
|
||||||
primary_path: &str, |
|
||||||
secondary_path: Option<&str>, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<Self> { |
|
||||||
py.allow_threads(|| { |
|
||||||
Ok(Self { |
|
||||||
inner: if let Some(secondary_path) = secondary_path { |
|
||||||
Store::open_persistent_secondary(primary_path, secondary_path) |
|
||||||
} else { |
|
||||||
Store::open_secondary(primary_path) |
|
||||||
} |
|
||||||
.map_err(map_storage_error)?, |
|
||||||
}) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Adds a quad to the store.
|
|
||||||
///
|
|
||||||
/// :param quad: the quad to add.
|
|
||||||
/// :type quad: Quad
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the quad insertion.
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
fn add(&self, quad: &PyQuad, py: Python<'_>) -> PyResult<()> { |
|
||||||
py.allow_threads(|| { |
|
||||||
self.inner.insert(quad).map_err(map_storage_error)?; |
|
||||||
Ok(()) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Adds atomically a set of quads to this store.
|
|
||||||
///
|
|
||||||
/// Insertion is done in a transactional manner: either the full operation succeeds or nothing is written to the database.
|
|
||||||
/// The :py:func:`bulk_extend` method is also available for much faster loading of a large number of quads but without transactional guarantees.
|
|
||||||
///
|
|
||||||
/// :param quads: the quads to add.
|
|
||||||
/// :type quads: collections.abc.Iterable[Quad]
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the quad insertion.
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
fn extend(&self, quads: &Bound<'_, PyAny>, py: Python<'_>) -> PyResult<()> { |
|
||||||
let quads = quads |
|
||||||
.iter()? |
|
||||||
.map(|q| q?.extract()) |
|
||||||
.collect::<PyResult<Vec<PyQuad>>>()?; |
|
||||||
py.allow_threads(|| { |
|
||||||
self.inner.extend(quads).map_err(map_storage_error)?; |
|
||||||
Ok(()) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Adds a set of quads to this store.
|
|
||||||
///
|
|
||||||
/// This function is designed to be as fast as possible **without** transactional guarantees.
|
|
||||||
/// Only a part of the data might be written to the store.
|
|
||||||
///
|
|
||||||
/// :param quads: the quads to add.
|
|
||||||
/// :type quads: collections.abc.Iterable[Quad]
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the quad insertion.
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[cfg(not(target_family = "wasm"))] |
|
||||||
fn bulk_extend(&self, quads: &Bound<'_, PyAny>) -> PyResult<()> { |
|
||||||
self.inner |
|
||||||
.bulk_loader() |
|
||||||
.load_ok_quads::<PyErr, PythonOrStorageError>( |
|
||||||
quads.iter()?.map(|q| q?.extract::<PyQuad>()), |
|
||||||
)?; |
|
||||||
Ok(()) |
|
||||||
} |
|
||||||
|
|
||||||
/// Removes a quad from the store.
|
|
||||||
///
|
|
||||||
/// :param quad: the quad to remove.
|
|
||||||
/// :type quad: Quad
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the quad removal.
|
|
||||||
///
|
|
||||||
/// >>> 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)
|
|
||||||
/// []
|
|
||||||
fn remove(&self, quad: &PyQuad, py: Python<'_>) -> PyResult<()> { |
|
||||||
py.allow_threads(|| { |
|
||||||
self.inner.remove(quad).map_err(map_storage_error)?; |
|
||||||
Ok(()) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Looks for the quads matching a given pattern.
|
|
||||||
///
|
|
||||||
/// :param subject: the quad subject or :py:const:`None` to match everything.
|
|
||||||
/// :type subject: NamedNode or BlankNode or Triple or None
|
|
||||||
/// :param predicate: the quad predicate or :py:const:`None` to match everything.
|
|
||||||
/// :type predicate: NamedNode or None
|
|
||||||
/// :param object: the quad object or :py:const:`None` to match everything.
|
|
||||||
/// :type object: NamedNode or BlankNode or Literal or Triple or None
|
|
||||||
/// :param graph_name: the quad graph name. To match only the default graph, use :py:class:`DefaultGraph`. To match everything use :py:const:`None`.
|
|
||||||
/// :type graph_name: NamedNode or BlankNode or DefaultGraph or None, optional
|
|
||||||
/// :return: an iterator of the quads matching the pattern.
|
|
||||||
/// :rtype: collections.abc.Iterator[Quad]
|
|
||||||
/// :raises OSError: if an error happens during the quads lookup.
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
#[pyo3(signature = (subject, predicate, object, graph_name = None))] |
|
||||||
fn quads_for_pattern( |
|
||||||
&self, |
|
||||||
subject: Option<PySubjectRef<'_>>, |
|
||||||
predicate: Option<PyNamedNodeRef<'_>>, |
|
||||||
object: Option<PyTermRef<'_>>, |
|
||||||
graph_name: Option<PyGraphNameRef<'_>>, |
|
||||||
) -> QuadIter { |
|
||||||
QuadIter { |
|
||||||
inner: self.inner.quads_for_pattern( |
|
||||||
subject.as_ref().map(Into::into), |
|
||||||
predicate.as_ref().map(Into::into), |
|
||||||
object.as_ref().map(Into::into), |
|
||||||
graph_name.as_ref().map(Into::into), |
|
||||||
), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Executes a `SPARQL 1.1 query <https://www.w3.org/TR/sparql11-query/>`_.
|
|
||||||
///
|
|
||||||
/// :param query: the query to execute.
|
|
||||||
/// :type query: str
|
|
||||||
/// :param base_iri: the base IRI used to resolve the relative IRIs in the SPARQL query or :py:const:`None` if relative IRI resolution should not be done.
|
|
||||||
/// :type base_iri: str or None, optional
|
|
||||||
/// :param use_default_graph_as_union: if the SPARQL query should look for triples in all the dataset graphs by default (i.e. without `GRAPH` operations). Disabled by default.
|
|
||||||
/// :type use_default_graph_as_union: bool, optional
|
|
||||||
/// :param default_graph: list of the graphs that should be used as the query default graph. By default, the store default graph is used.
|
|
||||||
/// :type default_graph: NamedNode or BlankNode or DefaultGraph or list[NamedNode or BlankNode or DefaultGraph] or None, optional
|
|
||||||
/// :param named_graphs: list of the named graphs that could be used in SPARQL `GRAPH` clause. By default, all the store named graphs are available.
|
|
||||||
/// :type named_graphs: list[NamedNode or BlankNode] or None, optional
|
|
||||||
/// :return: a :py:class:`bool` for ``ASK`` queries, an iterator of :py:class:`Triple` for ``CONSTRUCT`` and ``DESCRIBE`` queries and an iterator of :py:class:`QuerySolution` for ``SELECT`` queries.
|
|
||||||
/// :rtype: QuerySolutions or QueryBoolean or QueryTriples
|
|
||||||
/// :raises SyntaxError: if the provided query is invalid.
|
|
||||||
/// :raises OSError: if an error happens while reading the store.
|
|
||||||
///
|
|
||||||
/// ``SELECT`` query:
|
|
||||||
///
|
|
||||||
/// >>> 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>]
|
|
||||||
///
|
|
||||||
/// ``CONSTRUCT`` query:
|
|
||||||
///
|
|
||||||
/// >>> 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>>>]
|
|
||||||
///
|
|
||||||
/// ``ASK`` query:
|
|
||||||
///
|
|
||||||
/// >>> store = Store()
|
|
||||||
/// >>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
|
|
||||||
/// >>> bool(store.query('ASK { ?s ?p ?o }'))
|
|
||||||
/// True
|
|
||||||
#[pyo3(signature = (query, *, base_iri = None, use_default_graph_as_union = false, default_graph = None, named_graphs = None))] |
|
||||||
fn query( |
|
||||||
&self, |
|
||||||
query: &str, |
|
||||||
base_iri: Option<&str>, |
|
||||||
use_default_graph_as_union: bool, |
|
||||||
default_graph: Option<&Bound<'_, PyAny>>, |
|
||||||
named_graphs: Option<&Bound<'_, PyAny>>, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<PyObject> { |
|
||||||
let query = parse_query( |
|
||||||
query, |
|
||||||
base_iri, |
|
||||||
use_default_graph_as_union, |
|
||||||
default_graph, |
|
||||||
named_graphs, |
|
||||||
py, |
|
||||||
)?; |
|
||||||
let results = |
|
||||||
allow_threads_unsafe(py, || self.inner.query(query)).map_err(map_evaluation_error)?; |
|
||||||
Ok(query_results_to_python(py, results)) |
|
||||||
} |
|
||||||
|
|
||||||
/// Executes a `SPARQL 1.1 update <https://www.w3.org/TR/sparql11-update/>`_.
|
|
||||||
///
|
|
||||||
/// Updates are applied in a transactional manner: either the full operation succeeds or nothing is written to the database.
|
|
||||||
///
|
|
||||||
/// :param update: the update to execute.
|
|
||||||
/// :type update: str
|
|
||||||
/// :param base_iri: the base IRI used to resolve the relative IRIs in the SPARQL update or :py:const:`None` if relative IRI resolution should not be done.
|
|
||||||
/// :type base_iri: str or None, optional
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises SyntaxError: if the provided update is invalid.
|
|
||||||
/// :raises OSError: if an error happens while reading the store.
|
|
||||||
///
|
|
||||||
/// ``INSERT DATA`` update:
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
///
|
|
||||||
/// ``DELETE DATA`` update:
|
|
||||||
///
|
|
||||||
/// >>> store = Store()
|
|
||||||
/// >>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
|
|
||||||
/// >>> store.update('DELETE DATA { <http://example.com> <http://example.com/p> "1" }')
|
|
||||||
/// >>> list(store)
|
|
||||||
/// []
|
|
||||||
///
|
|
||||||
/// ``DELETE`` update:
|
|
||||||
///
|
|
||||||
/// >>> store = Store()
|
|
||||||
/// >>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
|
|
||||||
/// >>> store.update('DELETE WHERE { <http://example.com> ?p ?o }')
|
|
||||||
/// >>> list(store)
|
|
||||||
/// []
|
|
||||||
#[pyo3(signature = (update, *, base_iri = None))] |
|
||||||
fn update(&self, update: &str, base_iri: Option<&str>, py: Python<'_>) -> PyResult<()> { |
|
||||||
py.allow_threads(|| { |
|
||||||
let update = |
|
||||||
Update::parse(update, base_iri).map_err(|e| map_evaluation_error(e.into()))?; |
|
||||||
self.inner.update(update).map_err(map_evaluation_error) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Loads an RDF serialization into the store.
|
|
||||||
///
|
|
||||||
/// Loads are applied in a transactional manner: either the full operation succeeds or nothing is written to the database.
|
|
||||||
/// The :py:func:`bulk_load` method is also available for much faster loading of big files but without transactional guarantees.
|
|
||||||
///
|
|
||||||
/// Beware, the full file is loaded into memory.
|
|
||||||
///
|
|
||||||
/// It currently supports the following formats:
|
|
||||||
///
|
|
||||||
/// * `N-Triples <https://www.w3.org/TR/n-triples/>`_ (:py:attr:`RdfFormat.N_TRIPLES`)
|
|
||||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (:py:attr:`RdfFormat.N_QUADS`)
|
|
||||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (:py:attr:`RdfFormat.TURTLE`)
|
|
||||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (:py:attr:`RdfFormat.TRIG`)
|
|
||||||
/// * `N3 <https://w3c.github.io/N3/spec/>`_ (:py:attr:`RdfFormat.N3`)
|
|
||||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (:py:attr:`RdfFormat.RDF_XML`)
|
|
||||||
///
|
|
||||||
/// It supports also some media type and extension aliases.
|
|
||||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
|
||||||
/// and ``application/xml`` or ``xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
|
||||||
///
|
|
||||||
/// :param input: The :py:class:`str`, :py:class:`bytes` or I/O object to read from. For example, it could be the file content as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``.
|
|
||||||
/// :type input: bytes or str or typing.IO[bytes] or typing.IO[str] or None, optional
|
|
||||||
/// :param format: the format of the RDF serialization. If :py:const:`None`, the format is guessed from the file name extension.
|
|
||||||
/// :type format: RdfFormat or None, optional
|
|
||||||
/// :param path: The file path to read from. Replaces the ``input`` parameter.
|
|
||||||
/// :type path: str or os.PathLike[str] or None, optional
|
|
||||||
/// :param base_iri: the base IRI used to resolve the relative IRIs in the file or :py:const:`None` if relative IRI resolution should not be done.
|
|
||||||
/// :type base_iri: str or None, optional
|
|
||||||
/// :param to_graph: if it is a file composed of triples, the graph in which the triples should be stored. By default, the default graph is used.
|
|
||||||
/// :type to_graph: NamedNode or BlankNode or DefaultGraph or None, optional
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises ValueError: if the format is not supported.
|
|
||||||
/// :raises SyntaxError: if the provided data is invalid.
|
|
||||||
/// :raises OSError: if an error happens during a quad insertion or if a system error happens while reading the file.
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
#[pyo3(signature = (input = None, format = None, *, path = None, base_iri = None, to_graph = None))] |
|
||||||
fn load( |
|
||||||
&self, |
|
||||||
input: Option<PyReadableInput>, |
|
||||||
format: Option<PyRdfFormatInput>, |
|
||||||
path: Option<PathBuf>, |
|
||||||
base_iri: Option<&str>, |
|
||||||
to_graph: Option<PyGraphNameRef<'_>>, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<()> { |
|
||||||
let to_graph_name = to_graph.as_ref().map(GraphNameRef::from); |
|
||||||
let input = PyReadable::from_args(&path, input, py)?; |
|
||||||
let format = lookup_rdf_format(format, path.as_deref())?; |
|
||||||
py.allow_threads(|| { |
|
||||||
let mut parser = RdfParser::from_format(format); |
|
||||||
if let Some(base_iri) = base_iri { |
|
||||||
parser = parser |
|
||||||
.with_base_iri(base_iri) |
|
||||||
.map_err(|e| PyValueError::new_err(e.to_string()))?; |
|
||||||
} |
|
||||||
if let Some(to_graph_name) = to_graph_name { |
|
||||||
parser = parser.with_default_graph(to_graph_name); |
|
||||||
} |
|
||||||
self.inner |
|
||||||
.load_from_read(parser, input) |
|
||||||
.map_err(|e| map_loader_error(e, path)) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Loads an RDF serialization into the store.
|
|
||||||
///
|
|
||||||
/// This function is designed to be as fast as possible on big files **without** transactional guarantees.
|
|
||||||
/// If the file is invalid only a piece of it might be written to the store.
|
|
||||||
///
|
|
||||||
/// The :py:func:`load` method is also available for loads with transactional guarantees.
|
|
||||||
///
|
|
||||||
/// It currently supports the following formats:
|
|
||||||
///
|
|
||||||
/// * `N-Triples <https://www.w3.org/TR/n-triples/>`_ (:py:attr:`RdfFormat.N_TRIPLES`)
|
|
||||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (:py:attr:`RdfFormat.N_QUADS`)
|
|
||||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (:py:attr:`RdfFormat.TURTLE`)
|
|
||||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (:py:attr:`RdfFormat.TRIG`)
|
|
||||||
/// * `N3 <https://w3c.github.io/N3/spec/>`_ (:py:attr:`RdfFormat.N3`)
|
|
||||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (:py:attr:`RdfFormat.RDF_XML`)
|
|
||||||
///
|
|
||||||
/// It supports also some media type and extension aliases.
|
|
||||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
|
||||||
/// and ``application/xml`` or ``xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
|
||||||
///
|
|
||||||
/// :param input: The :py:class:`str`, :py:class:`bytes` or I/O object to read from. For example, it could be the file content as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``.
|
|
||||||
/// :type input: bytes or str or typing.IO[bytes] or typing.IO[str] or None, optional
|
|
||||||
/// :param format: the format of the RDF serialization. If :py:const:`None`, the format is guessed from the file name extension.
|
|
||||||
/// :type format: RdfFormat or None, optional
|
|
||||||
/// :param path: The file path to read from. Replaces the ``input`` parameter.
|
|
||||||
/// :type path: str or os.PathLike[str] or None, optional
|
|
||||||
/// :param base_iri: the base IRI used to resolve the relative IRIs in the file or :py:const:`None` if relative IRI resolution should not be done.
|
|
||||||
/// :type base_iri: str or None, optional
|
|
||||||
/// :param to_graph: if it is a file composed of triples, the graph in which the triples should be stored. By default, the default graph is used.
|
|
||||||
/// :type to_graph: NamedNode or BlankNode or DefaultGraph or None, optional
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises ValueError: if the format is not supported.
|
|
||||||
/// :raises SyntaxError: if the provided data is invalid.
|
|
||||||
/// :raises OSError: if an error happens during a quad insertion or if a system error happens while reading the file.
|
|
||||||
///
|
|
||||||
/// >>> 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>>]
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
#[pyo3(signature = (input = None, format = None, *, path = None, base_iri = None, to_graph = None))] |
|
||||||
fn bulk_load( |
|
||||||
&self, |
|
||||||
input: Option<PyReadableInput>, |
|
||||||
format: Option<PyRdfFormatInput>, |
|
||||||
path: Option<PathBuf>, |
|
||||||
base_iri: Option<&str>, |
|
||||||
to_graph: Option<PyGraphNameRef<'_>>, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<()> { |
|
||||||
let to_graph_name = to_graph.as_ref().map(GraphNameRef::from); |
|
||||||
let input = PyReadable::from_args(&path, input, py)?; |
|
||||||
let format = lookup_rdf_format(format, path.as_deref())?; |
|
||||||
py.allow_threads(|| { |
|
||||||
let mut parser = RdfParser::from_format(format); |
|
||||||
if let Some(base_iri) = base_iri { |
|
||||||
parser = parser |
|
||||||
.with_base_iri(base_iri) |
|
||||||
.map_err(|e| PyValueError::new_err(e.to_string()))?; |
|
||||||
} |
|
||||||
if let Some(to_graph_name) = to_graph_name { |
|
||||||
parser = parser.with_default_graph(to_graph_name); |
|
||||||
} |
|
||||||
self.inner |
|
||||||
.load_from_read(parser, input) |
|
||||||
.map_err(|e| map_loader_error(e, path)) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Dumps the store quads or triples into a file.
|
|
||||||
///
|
|
||||||
/// It currently supports the following formats:
|
|
||||||
///
|
|
||||||
/// * `N-Triples <https://www.w3.org/TR/n-triples/>`_ (:py:attr:`RdfFormat.N_TRIPLES`)
|
|
||||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (:py:attr:`RdfFormat.N_QUADS`)
|
|
||||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (:py:attr:`RdfFormat.TURTLE`)
|
|
||||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (:py:attr:`RdfFormat.TRIG`)
|
|
||||||
/// * `N3 <https://w3c.github.io/N3/spec/>`_ (:py:attr:`RdfFormat.N3`)
|
|
||||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (:py:attr:`RdfFormat.RDF_XML`)
|
|
||||||
///
|
|
||||||
/// It supports also some media type and extension aliases.
|
|
||||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
|
||||||
/// and ``application/xml`` or ``xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
|
||||||
///
|
|
||||||
/// :param output: The binary I/O object or file path to write to. For example, it could be a file path as a string or a file writer opened in binary mode with ``open('my_file.ttl', 'wb')``. If :py:const:`None`, a :py:class:`bytes` buffer is returned with the serialized content.
|
|
||||||
/// :type output: typing.IO[bytes] or str or os.PathLike[str] or None, optional
|
|
||||||
/// :param format: the format of the RDF serialization. If :py:const:`None`, the format is guessed from the file name extension.
|
|
||||||
/// :type format: RdfFormat or None, optional
|
|
||||||
/// :param from_graph: the store graph from which dump the triples. Required if the serialization format does not support named graphs. If it does supports named graphs the full dataset is written.
|
|
||||||
/// :type from_graph: NamedNode or BlankNode or DefaultGraph or None, optional
|
|
||||||
/// :return: :py:class:`bytes` with the serialization if the ``output`` parameter is :py:const:`None`, :py:const:`None` if ``output`` is set.
|
|
||||||
/// :rtype: bytes or None
|
|
||||||
/// :raises ValueError: if the format is not supported or the `from_graph` parameter is not given with a syntax not supporting named graphs.
|
|
||||||
/// :raises OSError: if an error happens during a quad lookup or file writing.
|
|
||||||
///
|
|
||||||
/// >>> 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'
|
|
||||||
///
|
|
||||||
/// >>> 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"))
|
|
||||||
/// >>> output.getvalue()
|
|
||||||
/// b'<http://example.com> <http://example.com/p> "1" .\n'
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
#[pyo3(signature = (output = None, format = None, *, from_graph = None))] |
|
||||||
fn dump<'py>( |
|
||||||
&self, |
|
||||||
output: Option<PyWritableOutput>, |
|
||||||
format: Option<PyRdfFormatInput>, |
|
||||||
from_graph: Option<PyGraphNameRef<'_>>, |
|
||||||
py: Python<'py>, |
|
||||||
) -> PyResult<Option<Bound<'py, PyBytes>>> { |
|
||||||
let from_graph_name = from_graph.as_ref().map(GraphNameRef::from); |
|
||||||
PyWritable::do_write( |
|
||||||
|output, file_path| { |
|
||||||
py.allow_threads(|| { |
|
||||||
let format = lookup_rdf_format(format, file_path.as_deref())?; |
|
||||||
if let Some(from_graph_name) = from_graph_name { |
|
||||||
self.inner |
|
||||||
.dump_graph_to_write(from_graph_name, format, output) |
|
||||||
} else { |
|
||||||
self.inner.dump_to_write(format, output) |
|
||||||
} |
|
||||||
.map_err(map_serializer_error) |
|
||||||
}) |
|
||||||
}, |
|
||||||
output, |
|
||||||
py, |
|
||||||
) |
|
||||||
} |
|
||||||
|
|
||||||
/// Returns an iterator over all the store named graphs.
|
|
||||||
///
|
|
||||||
/// :return: an iterator of the store graph names.
|
|
||||||
/// :rtype: collections.abc.Iterator[NamedNode or BlankNode]
|
|
||||||
/// :raises OSError: if an error happens during the named graphs lookup.
|
|
||||||
///
|
|
||||||
/// >>> 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>]
|
|
||||||
fn named_graphs(&self) -> GraphNameIter { |
|
||||||
GraphNameIter { |
|
||||||
inner: self.inner.named_graphs(), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
/// Returns if the store contains the given named graph.
|
|
||||||
///
|
|
||||||
/// :param graph_name: the name of the named graph.
|
|
||||||
/// :type graph_name: NamedNode or BlankNode or DefaultGraph
|
|
||||||
/// :rtype: bool
|
|
||||||
/// :raises OSError: if an error happens during the named graph lookup.
|
|
||||||
///
|
|
||||||
/// >>> store = Store()
|
|
||||||
/// >>> store.add_graph(NamedNode('http://example.com/g'))
|
|
||||||
/// >>> store.contains_named_graph(NamedNode('http://example.com/g'))
|
|
||||||
/// True
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
fn contains_named_graph( |
|
||||||
&self, |
|
||||||
graph_name: PyGraphNameRef<'_>, |
|
||||||
py: Python<'_>, |
|
||||||
) -> PyResult<bool> { |
|
||||||
let graph_name = GraphNameRef::from(&graph_name); |
|
||||||
py.allow_threads(|| { |
|
||||||
match graph_name { |
|
||||||
GraphNameRef::DefaultGraph => Ok(true), |
|
||||||
GraphNameRef::NamedNode(graph_name) => self.inner.contains_named_graph(graph_name), |
|
||||||
GraphNameRef::BlankNode(graph_name) => self.inner.contains_named_graph(graph_name), |
|
||||||
} |
|
||||||
.map_err(map_storage_error) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Adds a named graph to the store.
|
|
||||||
///
|
|
||||||
/// :param graph_name: the name of the name graph to add.
|
|
||||||
/// :type graph_name: NamedNode or BlankNode or DefaultGraph
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the named graph insertion.
|
|
||||||
///
|
|
||||||
/// >>> store = Store()
|
|
||||||
/// >>> store.add_graph(NamedNode('http://example.com/g'))
|
|
||||||
/// >>> list(store.named_graphs())
|
|
||||||
/// [<NamedNode value=http://example.com/g>]
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
fn add_graph(&self, graph_name: PyGraphNameRef<'_>, py: Python<'_>) -> PyResult<()> { |
|
||||||
let graph_name = GraphNameRef::from(&graph_name); |
|
||||||
py.allow_threads(|| { |
|
||||||
match graph_name { |
|
||||||
GraphNameRef::DefaultGraph => Ok(()), |
|
||||||
GraphNameRef::NamedNode(graph_name) => { |
|
||||||
self.inner.insert_named_graph(graph_name).map(|_| ()) |
|
||||||
} |
|
||||||
GraphNameRef::BlankNode(graph_name) => { |
|
||||||
self.inner.insert_named_graph(graph_name).map(|_| ()) |
|
||||||
} |
|
||||||
} |
|
||||||
.map_err(map_storage_error) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Clears a graph from the store without removing it.
|
|
||||||
///
|
|
||||||
/// :param graph_name: the name of the name graph to clear.
|
|
||||||
/// :type graph_name: NamedNode or BlankNode or DefaultGraph
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the operation.
|
|
||||||
///
|
|
||||||
/// >>> store = Store()
|
|
||||||
/// >>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
|
|
||||||
/// >>> store.clear_graph(NamedNode('http://example.com/g'))
|
|
||||||
/// >>> list(store)
|
|
||||||
/// []
|
|
||||||
/// >>> list(store.named_graphs())
|
|
||||||
/// [<NamedNode value=http://example.com/g>]
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
fn clear_graph(&self, graph_name: PyGraphNameRef<'_>, py: Python<'_>) -> PyResult<()> { |
|
||||||
let graph_name = GraphNameRef::from(&graph_name); |
|
||||||
py.allow_threads(|| { |
|
||||||
self.inner |
|
||||||
.clear_graph(graph_name) |
|
||||||
.map_err(map_storage_error) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Removes a graph from the store.
|
|
||||||
///
|
|
||||||
/// The default graph will not be removed but just cleared.
|
|
||||||
///
|
|
||||||
/// :param graph_name: the name of the name graph to remove.
|
|
||||||
/// :type graph_name: NamedNode or BlankNode or DefaultGraph
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the named graph removal.
|
|
||||||
///
|
|
||||||
/// >>> store = Store()
|
|
||||||
/// >>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
|
|
||||||
/// >>> store.remove_graph(NamedNode('http://example.com/g'))
|
|
||||||
/// >>> list(store.named_graphs())
|
|
||||||
/// []
|
|
||||||
#[allow(clippy::needless_pass_by_value)] |
|
||||||
fn remove_graph(&self, graph_name: PyGraphNameRef<'_>, py: Python<'_>) -> PyResult<()> { |
|
||||||
let graph_name = GraphNameRef::from(&graph_name); |
|
||||||
py.allow_threads(|| { |
|
||||||
match graph_name { |
|
||||||
GraphNameRef::DefaultGraph => self.inner.clear_graph(GraphNameRef::DefaultGraph), |
|
||||||
GraphNameRef::NamedNode(graph_name) => { |
|
||||||
self.inner.remove_named_graph(graph_name).map(|_| ()) |
|
||||||
} |
|
||||||
GraphNameRef::BlankNode(graph_name) => { |
|
||||||
self.inner.remove_named_graph(graph_name).map(|_| ()) |
|
||||||
} |
|
||||||
} |
|
||||||
.map_err(map_storage_error) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
/// Clears the store by removing all its contents.
|
|
||||||
///
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the operation.
|
|
||||||
///
|
|
||||||
/// >>> 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())
|
|
||||||
/// []
|
|
||||||
fn clear(&self, py: Python<'_>) -> PyResult<()> { |
|
||||||
py.allow_threads(|| self.inner.clear().map_err(map_storage_error)) |
|
||||||
} |
|
||||||
|
|
||||||
/// Flushes all buffers and ensures that all writes are saved on disk.
|
|
||||||
///
|
|
||||||
/// Flushes are automatically done using background threads but might lag a little bit.
|
|
||||||
///
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the flush.
|
|
||||||
#[cfg(not(target_family = "wasm"))] |
|
||||||
fn flush(&self, py: Python<'_>) -> PyResult<()> { |
|
||||||
py.allow_threads(|| self.inner.flush().map_err(map_storage_error)) |
|
||||||
} |
|
||||||
|
|
||||||
/// Optimizes the database for future workload.
|
|
||||||
///
|
|
||||||
/// Useful to call after a batch upload or another similar operation.
|
|
||||||
///
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the optimization.
|
|
||||||
#[cfg(not(target_family = "wasm"))] |
|
||||||
fn optimize(&self, py: Python<'_>) -> PyResult<()> { |
|
||||||
py.allow_threads(|| self.inner.optimize().map_err(map_storage_error)) |
|
||||||
} |
|
||||||
|
|
||||||
/// Creates database backup into the `target_directory`.
|
|
||||||
///
|
|
||||||
/// After its creation, the backup is usable using :py:class:`Store` constructor.
|
|
||||||
/// like a regular pyxigraph database and operates independently from the original database.
|
|
||||||
///
|
|
||||||
/// Warning: Backups are only possible for on-disk databases created by providing a path to :py:class:`Store` constructor.
|
|
||||||
/// Temporary in-memory databases created without path are not compatible with the backup system.
|
|
||||||
///
|
|
||||||
/// Warning: An error is raised if the ``target_directory`` already exists.
|
|
||||||
///
|
|
||||||
/// If the target directory is in the same file system as the current database,
|
|
||||||
/// the database content will not be fully copied
|
|
||||||
/// but hard links will be used to point to the original database immutable snapshots.
|
|
||||||
/// This allows cheap regular backups.
|
|
||||||
///
|
|
||||||
/// If you want to move your data to another RDF storage system, you should have a look at the :py:func:`dump_dataset` function instead.
|
|
||||||
///
|
|
||||||
/// :param target_directory: the directory name to save the database to.
|
|
||||||
/// :type target_directory: str or os.PathLike[str]
|
|
||||||
/// :rtype: None
|
|
||||||
/// :raises OSError: if an error happens during the backup.
|
|
||||||
#[cfg(not(target_family = "wasm"))] |
|
||||||
fn backup(&self, target_directory: PathBuf, py: Python<'_>) -> PyResult<()> { |
|
||||||
py.allow_threads(|| { |
|
||||||
self.inner |
|
||||||
.backup(target_directory) |
|
||||||
.map_err(map_storage_error) |
|
||||||
}) |
|
||||||
} |
|
||||||
|
|
||||||
fn __str__(&self, py: Python<'_>) -> String { |
|
||||||
py.allow_threads(|| self.inner.to_string()) |
|
||||||
} |
|
||||||
|
|
||||||
fn __bool__(&self) -> PyResult<bool> { |
|
||||||
Ok(!self.inner.is_empty().map_err(map_storage_error)?) |
|
||||||
} |
|
||||||
|
|
||||||
fn __len__(&self) -> PyResult<usize> { |
|
||||||
self.inner.len().map_err(map_storage_error) |
|
||||||
} |
|
||||||
|
|
||||||
fn __contains__(&self, quad: &PyQuad) -> PyResult<bool> { |
|
||||||
self.inner.contains(quad).map_err(map_storage_error) |
|
||||||
} |
|
||||||
|
|
||||||
fn __iter__(&self) -> QuadIter { |
|
||||||
QuadIter { |
|
||||||
inner: self.inner.iter(), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#[pyclass(unsendable, module = "pyoxigraph")] |
|
||||||
pub struct QuadIter { |
|
||||||
inner: store::QuadIter, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl QuadIter { |
|
||||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
fn __next__(&mut self) -> PyResult<Option<PyQuad>> { |
|
||||||
self.inner |
|
||||||
.next() |
|
||||||
.map(|q| Ok(q.map_err(map_storage_error)?.into())) |
|
||||||
.transpose() |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
#[pyclass(unsendable, module = "pyoxigraph")] |
|
||||||
pub struct GraphNameIter { |
|
||||||
inner: store::GraphNameIter, |
|
||||||
} |
|
||||||
|
|
||||||
#[pymethods] |
|
||||||
impl GraphNameIter { |
|
||||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> { |
|
||||||
slf |
|
||||||
} |
|
||||||
|
|
||||||
fn __next__(&mut self) -> PyResult<Option<PyNamedOrBlankNode>> { |
|
||||||
self.inner |
|
||||||
.next() |
|
||||||
.map(|q| Ok(q.map_err(map_storage_error)?.into())) |
|
||||||
.transpose() |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
pub fn map_storage_error(error: StorageError) -> PyErr { |
|
||||||
match error { |
|
||||||
StorageError::Io(error) => error.into(), |
|
||||||
_ => PyRuntimeError::new_err(error.to_string()), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
pub fn map_loader_error(error: LoaderError, file_path: Option<PathBuf>) -> PyErr { |
|
||||||
match error { |
|
||||||
LoaderError::Storage(error) => map_storage_error(error), |
|
||||||
LoaderError::Parsing(error) => map_parse_error(error, file_path), |
|
||||||
LoaderError::InvalidBaseIri { .. } => PyValueError::new_err(error.to_string()), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
pub fn map_serializer_error(error: SerializerError) -> PyErr { |
|
||||||
match error { |
|
||||||
SerializerError::Storage(error) => map_storage_error(error), |
|
||||||
SerializerError::Io(error) => error.into(), |
|
||||||
SerializerError::DatasetFormatExpected(_) => PyValueError::new_err(error.to_string()), |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
enum PythonOrStorageError { |
|
||||||
Python(PyErr), |
|
||||||
Storage(StorageError), |
|
||||||
} |
|
||||||
|
|
||||||
impl From<PyErr> for PythonOrStorageError { |
|
||||||
fn from(error: PyErr) -> Self { |
|
||||||
Self::Python(error) |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
impl From<StorageError> for PythonOrStorageError { |
|
||||||
fn from(error: StorageError) -> Self { |
|
||||||
Self::Storage(error) |
|
||||||
} |
|
||||||
} |
|
||||||
impl From<PythonOrStorageError> for PyErr { |
|
||||||
fn from(error: PythonOrStorageError) -> Self { |
|
||||||
match error { |
|
||||||
PythonOrStorageError::Python(error) => error, |
|
||||||
PythonOrStorageError::Storage(error) => map_storage_error(error), |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
@ -1,37 +0,0 @@ |
|||||||
# type: ignore |
|
||||||
import inspect |
|
||||||
from doctest import DocTestFinder, DocTestSuite |
|
||||||
|
|
||||||
import pyoxigraph |
|
||||||
|
|
||||||
|
|
||||||
class ExtendedDocTestFinder(DocTestFinder): |
|
||||||
""" |
|
||||||
More aggressive doctest lookup |
|
||||||
""" |
|
||||||
|
|
||||||
def _find(self, tests, obj, name, module, source_lines, globs, seen): |
|
||||||
# If we've already processed this object, then ignore it. |
|
||||||
if id(obj) in seen: |
|
||||||
return |
|
||||||
seen[id(obj)] = 1 |
|
||||||
|
|
||||||
# Find a test for this object, and add it to the list of tests. |
|
||||||
test = self._get_test(obj, name, module, globs, source_lines) |
|
||||||
if test is not None: |
|
||||||
tests.append(test) |
|
||||||
|
|
||||||
# Look for tests in a module's contained objects. |
|
||||||
if inspect.ismodule(obj) or inspect.isclass(obj): |
|
||||||
for valname, val in obj.__dict__.items(): |
|
||||||
if valname == "__doc__": |
|
||||||
continue |
|
||||||
# Special handling for staticmethod/classmethod. |
|
||||||
if isinstance(val, (staticmethod, classmethod)): |
|
||||||
val = val.__func__ |
|
||||||
self._find(tests, val, f"{name}.{valname}", module, source_lines, globs, seen) |
|
||||||
|
|
||||||
|
|
||||||
def load_tests(_loader, tests, _ignore): |
|
||||||
tests.addTests(DocTestSuite(pyoxigraph, test_finder=ExtendedDocTestFinder())) |
|
||||||
return tests |
|
||||||
@ -1,266 +0,0 @@ |
|||||||
import sys |
|
||||||
import unittest |
|
||||||
from io import BytesIO, StringIO, UnsupportedOperation |
|
||||||
from tempfile import NamedTemporaryFile, TemporaryFile |
|
||||||
|
|
||||||
from pyoxigraph import ( |
|
||||||
Literal, |
|
||||||
NamedNode, |
|
||||||
Quad, |
|
||||||
QueryBoolean, |
|
||||||
QueryResultsFormat, |
|
||||||
QuerySolutions, |
|
||||||
RdfFormat, |
|
||||||
parse, |
|
||||||
parse_query_results, |
|
||||||
serialize, |
|
||||||
) |
|
||||||
|
|
||||||
EXAMPLE_TRIPLE = Quad( |
|
||||||
NamedNode("http://example.com/foo"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
Literal("éù"), |
|
||||||
) |
|
||||||
EXAMPLE_QUAD = Quad( |
|
||||||
NamedNode("http://example.com/foo"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
Literal("1"), |
|
||||||
NamedNode("http://example.com/g"), |
|
||||||
) |
|
||||||
|
|
||||||
|
|
||||||
class TestParse(unittest.TestCase): |
|
||||||
def test_parse_file(self) -> None: |
|
||||||
with NamedTemporaryFile(suffix=".ttl") as fp: |
|
||||||
fp.write('<foo> <p> "éù" .'.encode()) |
|
||||||
fp.flush() |
|
||||||
self.assertEqual( |
|
||||||
list(parse(path=fp.name, base_iri="http://example.com/")), |
|
||||||
[EXAMPLE_TRIPLE], |
|
||||||
) |
|
||||||
|
|
||||||
def test_parse_not_existing_file(self) -> None: |
|
||||||
with self.assertRaises(IOError) as _: |
|
||||||
parse(path="/tmp/not-existing-oxigraph-file.ttl", format=RdfFormat.TURTLE) |
|
||||||
|
|
||||||
def test_parse_str(self) -> None: |
|
||||||
self.assertEqual( |
|
||||||
list( |
|
||||||
parse( |
|
||||||
'<foo> <p> "éù" .', |
|
||||||
RdfFormat.TURTLE, |
|
||||||
base_iri="http://example.com/", |
|
||||||
) |
|
||||||
), |
|
||||||
[EXAMPLE_TRIPLE], |
|
||||||
) |
|
||||||
|
|
||||||
def test_parse_bytes(self) -> None: |
|
||||||
self.assertEqual( |
|
||||||
list( |
|
||||||
parse( |
|
||||||
'<foo> <p> "éù" .'.encode(), |
|
||||||
RdfFormat.TURTLE, |
|
||||||
base_iri="http://example.com/", |
|
||||||
) |
|
||||||
), |
|
||||||
[EXAMPLE_TRIPLE], |
|
||||||
) |
|
||||||
|
|
||||||
def test_parse_str_io(self) -> None: |
|
||||||
self.assertEqual( |
|
||||||
list( |
|
||||||
parse( |
|
||||||
StringIO('<foo> <p> "éù" .'), |
|
||||||
RdfFormat.TURTLE, |
|
||||||
base_iri="http://example.com/", |
|
||||||
) |
|
||||||
), |
|
||||||
[EXAMPLE_TRIPLE], |
|
||||||
) |
|
||||||
|
|
||||||
def test_parse_long_str_io(self) -> None: |
|
||||||
self.assertEqual( |
|
||||||
list( |
|
||||||
parse( |
|
||||||
StringIO('<foo> <p> "éù" .\n' * 1024), |
|
||||||
RdfFormat.TURTLE, |
|
||||||
base_iri="http://example.com/", |
|
||||||
) |
|
||||||
), |
|
||||||
[EXAMPLE_TRIPLE] * 1024, |
|
||||||
) |
|
||||||
|
|
||||||
def test_parse_bytes_io(self) -> None: |
|
||||||
self.assertEqual( |
|
||||||
list( |
|
||||||
parse( |
|
||||||
BytesIO('<foo> <p> "éù" .'.encode()), |
|
||||||
RdfFormat.TURTLE, |
|
||||||
base_iri="http://example.com/", |
|
||||||
) |
|
||||||
), |
|
||||||
[EXAMPLE_TRIPLE], |
|
||||||
) |
|
||||||
|
|
||||||
def test_parse_io_error(self) -> None: |
|
||||||
with self.assertRaises(UnsupportedOperation) as _, TemporaryFile("wb") as fp: |
|
||||||
list(parse(fp, RdfFormat.N_TRIPLES)) |
|
||||||
|
|
||||||
def test_parse_quad(self) -> None: |
|
||||||
self.assertEqual( |
|
||||||
list( |
|
||||||
parse( |
|
||||||
'<g> { <foo> <p> "1" }', |
|
||||||
RdfFormat.TRIG, |
|
||||||
base_iri="http://example.com/", |
|
||||||
) |
|
||||||
), |
|
||||||
[EXAMPLE_QUAD], |
|
||||||
) |
|
||||||
|
|
||||||
def test_parse_syntax_error(self) -> None: |
|
||||||
with NamedTemporaryFile() as fp: |
|
||||||
fp.write(b"@base <http://example.com/> .\n") |
|
||||||
fp.write(b'<foo> "p" "1"') |
|
||||||
fp.flush() |
|
||||||
with self.assertRaises(SyntaxError) as ctx: |
|
||||||
list(parse(path=fp.name, format=RdfFormat.TURTLE)) |
|
||||||
self.assertEqual(ctx.exception.filename, fp.name) |
|
||||||
self.assertEqual(ctx.exception.lineno, 2) |
|
||||||
self.assertEqual(ctx.exception.offset, 7) |
|
||||||
if sys.version_info >= (3, 10): |
|
||||||
self.assertEqual(ctx.exception.end_lineno, 2) |
|
||||||
self.assertEqual(ctx.exception.end_offset, 10) |
|
||||||
|
|
||||||
def test_parse_without_named_graphs(self) -> None: |
|
||||||
with self.assertRaises(SyntaxError) as _: |
|
||||||
list( |
|
||||||
parse( |
|
||||||
'<g> { <foo> <p> "1" }', |
|
||||||
RdfFormat.TRIG, |
|
||||||
base_iri="http://example.com/", |
|
||||||
without_named_graphs=True, |
|
||||||
) |
|
||||||
) |
|
||||||
|
|
||||||
def test_parse_rename_blank_nodes(self) -> None: |
|
||||||
self.assertNotEqual( |
|
||||||
list( |
|
||||||
parse( |
|
||||||
'_:s <http://example.com/p> "o" .', |
|
||||||
RdfFormat.N_TRIPLES, |
|
||||||
rename_blank_nodes=True, |
|
||||||
) |
|
||||||
), |
|
||||||
list( |
|
||||||
parse( |
|
||||||
'_:s <http://example.com/p> "o" .', |
|
||||||
RdfFormat.N_TRIPLES, |
|
||||||
rename_blank_nodes=True, |
|
||||||
) |
|
||||||
), |
|
||||||
) |
|
||||||
|
|
||||||
|
|
||||||
class TestSerialize(unittest.TestCase): |
|
||||||
def test_serialize_to_bytes(self) -> None: |
|
||||||
self.assertEqual( |
|
||||||
(serialize([EXAMPLE_TRIPLE.triple], None, RdfFormat.TURTLE) or b"").decode(), |
|
||||||
'<http://example.com/foo> <http://example.com/p> "éù" .\n', |
|
||||||
) |
|
||||||
|
|
||||||
def test_serialize_to_bytes_io(self) -> None: |
|
||||||
output = BytesIO() |
|
||||||
serialize([EXAMPLE_TRIPLE.triple], output, RdfFormat.TURTLE) |
|
||||||
self.assertEqual( |
|
||||||
output.getvalue().decode(), |
|
||||||
'<http://example.com/foo> <http://example.com/p> "éù" .\n', |
|
||||||
) |
|
||||||
|
|
||||||
def test_serialize_to_file(self) -> None: |
|
||||||
with NamedTemporaryFile(suffix=".ttl") as fp: |
|
||||||
serialize([EXAMPLE_TRIPLE], fp.name) |
|
||||||
self.assertEqual( |
|
||||||
fp.read().decode(), |
|
||||||
'<http://example.com/foo> <http://example.com/p> "éù" .\n', |
|
||||||
) |
|
||||||
|
|
||||||
def test_serialize_io_error(self) -> None: |
|
||||||
with self.assertRaises(UnsupportedOperation) as _, TemporaryFile("rb") as fp: |
|
||||||
serialize([EXAMPLE_TRIPLE], fp, RdfFormat.TURTLE) |
|
||||||
|
|
||||||
def test_serialize_quad(self) -> None: |
|
||||||
output = BytesIO() |
|
||||||
serialize([EXAMPLE_QUAD], output, RdfFormat.TRIG) |
|
||||||
self.assertEqual( |
|
||||||
output.getvalue(), |
|
||||||
b'<http://example.com/g> {\n\t<http://example.com/foo> <http://example.com/p> "1" .\n}\n', |
|
||||||
) |
|
||||||
|
|
||||||
|
|
||||||
class TestParseQuerySolutions(unittest.TestCase): |
|
||||||
def test_parse_file(self) -> None: |
|
||||||
with NamedTemporaryFile(suffix=".tsv") as fp: |
|
||||||
fp.write(b'?s\t?p\t?o\n<http://example.com/s>\t<http://example.com/s>\t"1"\n') |
|
||||||
fp.flush() |
|
||||||
r = parse_query_results(path=fp.name) |
|
||||||
self.assertIsInstance(r, QuerySolutions) |
|
||||||
results = list(r) # type: ignore[arg-type] |
|
||||||
self.assertEqual(results[0]["s"], NamedNode("http://example.com/s")) |
|
||||||
self.assertEqual(results[0][2], Literal("1")) |
|
||||||
|
|
||||||
def test_parse_not_existing_file(self) -> None: |
|
||||||
with self.assertRaises(IOError) as _: |
|
||||||
parse_query_results(path="/tmp/not-existing-oxigraph-file.ttl", format=QueryResultsFormat.JSON) |
|
||||||
|
|
||||||
def test_parse_str(self) -> None: |
|
||||||
result = parse_query_results("true", QueryResultsFormat.TSV) |
|
||||||
self.assertIsInstance(result, QueryBoolean) |
|
||||||
self.assertTrue(result) |
|
||||||
|
|
||||||
def test_parse_bytes(self) -> None: |
|
||||||
result = parse_query_results(b"false", QueryResultsFormat.TSV) |
|
||||||
self.assertIsInstance(result, QueryBoolean) |
|
||||||
self.assertFalse(result) |
|
||||||
|
|
||||||
def test_parse_str_io(self) -> None: |
|
||||||
result = parse_query_results("true", QueryResultsFormat.TSV) |
|
||||||
self.assertIsInstance(result, QueryBoolean) |
|
||||||
self.assertTrue(result) |
|
||||||
|
|
||||||
def test_parse_bytes_io(self) -> None: |
|
||||||
result = parse_query_results(BytesIO(b"false"), QueryResultsFormat.TSV) |
|
||||||
self.assertIsInstance(result, QueryBoolean) |
|
||||||
self.assertFalse(result) |
|
||||||
|
|
||||||
def test_parse_io_error(self) -> None: |
|
||||||
with self.assertRaises(UnsupportedOperation) as _, TemporaryFile("wb") as fp: |
|
||||||
parse_query_results(fp, QueryResultsFormat.XML) |
|
||||||
|
|
||||||
def test_parse_syntax_error_json(self) -> None: |
|
||||||
with NamedTemporaryFile() as fp: |
|
||||||
fp.write(b"{]") |
|
||||||
fp.flush() |
|
||||||
with self.assertRaises(SyntaxError) as ctx: |
|
||||||
list(parse_query_results(path=fp.name, format=QueryResultsFormat.JSON)) # type: ignore[arg-type] |
|
||||||
self.assertEqual(ctx.exception.filename, fp.name) |
|
||||||
self.assertEqual(ctx.exception.lineno, 1) |
|
||||||
self.assertEqual(ctx.exception.offset, 2) |
|
||||||
if sys.version_info >= (3, 10): |
|
||||||
self.assertEqual(ctx.exception.end_lineno, 1) |
|
||||||
self.assertEqual(ctx.exception.end_offset, 3) |
|
||||||
|
|
||||||
def test_parse_syntax_error_tsv(self) -> None: |
|
||||||
with NamedTemporaryFile() as fp: |
|
||||||
fp.write(b"?a\t?test\n") |
|
||||||
fp.write(b"1\t<foo >\n") |
|
||||||
fp.flush() |
|
||||||
with self.assertRaises(SyntaxError) as ctx: |
|
||||||
list(parse_query_results(path=fp.name, format=QueryResultsFormat.TSV)) # type: ignore[arg-type] |
|
||||||
self.assertEqual(ctx.exception.filename, fp.name) |
|
||||||
self.assertEqual(ctx.exception.lineno, 2) |
|
||||||
self.assertEqual(ctx.exception.offset, 3) |
|
||||||
if sys.version_info >= (3, 10): |
|
||||||
self.assertEqual(ctx.exception.end_lineno, 2) |
|
||||||
self.assertEqual(ctx.exception.end_offset, 9) |
|
||||||
@ -1,376 +0,0 @@ |
|||||||
import copy |
|
||||||
import pickle |
|
||||||
import sys |
|
||||||
import unittest |
|
||||||
|
|
||||||
from pyoxigraph import ( |
|
||||||
BlankNode, |
|
||||||
DefaultGraph, |
|
||||||
Literal, |
|
||||||
NamedNode, |
|
||||||
Quad, |
|
||||||
Triple, |
|
||||||
Variable, |
|
||||||
) |
|
||||||
|
|
||||||
XSD_STRING = NamedNode("http://www.w3.org/2001/XMLSchema#string") |
|
||||||
XSD_INTEGER = NamedNode("http://www.w3.org/2001/XMLSchema#integer") |
|
||||||
RDF_LANG_STRING = NamedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString") |
|
||||||
|
|
||||||
|
|
||||||
def match_works(test: unittest.TestCase, matched_value: str, constraint: str) -> None: |
|
||||||
"""Hack for Python < 3.10 compatibility""" |
|
||||||
if sys.version_info < (3, 10): |
|
||||||
return test.skipTest("match has been introduced by Python 3.10") |
|
||||||
found = True |
|
||||||
exec( |
|
||||||
f""" |
|
||||||
match {matched_value}: |
|
||||||
case {constraint}: |
|
||||||
found = True |
|
||||||
""" |
|
||||||
) |
|
||||||
test.assertTrue(found) |
|
||||||
return None |
|
||||||
|
|
||||||
|
|
||||||
class TestNamedNode(unittest.TestCase): |
|
||||||
def test_constructor(self) -> None: |
|
||||||
self.assertEqual(NamedNode("http://foo").value, "http://foo") |
|
||||||
|
|
||||||
def test_string(self) -> None: |
|
||||||
self.assertEqual(str(NamedNode("http://foo")), "<http://foo>") |
|
||||||
|
|
||||||
def test_equal(self) -> None: |
|
||||||
self.assertEqual(NamedNode("http://foo"), NamedNode("http://foo")) |
|
||||||
self.assertNotEqual(NamedNode("http://foo"), NamedNode("http://bar")) |
|
||||||
|
|
||||||
def test_pickle(self) -> None: |
|
||||||
node = NamedNode("http://foo") |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(node)), node) |
|
||||||
self.assertEqual(copy.copy(node), node) |
|
||||||
self.assertEqual(copy.deepcopy(node), node) |
|
||||||
|
|
||||||
def test_basic_match(self) -> None: |
|
||||||
match_works(self, 'NamedNode("http://foo")', 'NamedNode("http://foo")') |
|
||||||
|
|
||||||
def test_wildcard_match(self) -> None: |
|
||||||
match_works(self, 'NamedNode("http://foo")', "NamedNode(x)") |
|
||||||
|
|
||||||
|
|
||||||
class TestBlankNode(unittest.TestCase): |
|
||||||
def test_constructor(self) -> None: |
|
||||||
self.assertEqual(BlankNode("foo").value, "foo") |
|
||||||
self.assertNotEqual(BlankNode(), BlankNode()) |
|
||||||
|
|
||||||
def test_string(self) -> None: |
|
||||||
self.assertEqual(str(BlankNode("foo")), "_:foo") |
|
||||||
|
|
||||||
def test_equal(self) -> None: |
|
||||||
self.assertEqual(BlankNode("foo"), BlankNode("foo")) |
|
||||||
self.assertNotEqual(BlankNode("foo"), BlankNode("bar")) |
|
||||||
self.assertNotEqual(BlankNode("foo"), NamedNode("http://foo")) |
|
||||||
self.assertNotEqual(NamedNode("http://foo"), BlankNode("foo")) |
|
||||||
|
|
||||||
def test_pickle(self) -> None: |
|
||||||
node = BlankNode("foo") |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(node)), node) |
|
||||||
self.assertEqual(copy.copy(node), node) |
|
||||||
self.assertEqual(copy.deepcopy(node), node) |
|
||||||
|
|
||||||
auto = BlankNode() |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(auto)), auto) |
|
||||||
self.assertEqual(copy.copy(auto), auto) |
|
||||||
self.assertEqual(copy.deepcopy(auto), auto) |
|
||||||
|
|
||||||
def test_basic_match(self) -> None: |
|
||||||
match_works(self, 'BlankNode("foo")', 'BlankNode("foo")') |
|
||||||
|
|
||||||
def test_wildcard_match(self) -> None: |
|
||||||
match_works(self, 'BlankNode("foo")', "BlankNode(x)") |
|
||||||
|
|
||||||
|
|
||||||
class TestLiteral(unittest.TestCase): |
|
||||||
def test_constructor(self) -> None: |
|
||||||
self.assertEqual(Literal("foo").value, "foo") |
|
||||||
self.assertEqual(Literal("foo").datatype, XSD_STRING) |
|
||||||
|
|
||||||
self.assertEqual(Literal("foo", language="en").value, "foo") |
|
||||||
self.assertEqual(Literal("foo", language="en").language, "en") |
|
||||||
self.assertEqual(Literal("foo", language="en").datatype, RDF_LANG_STRING) |
|
||||||
|
|
||||||
self.assertEqual(Literal("foo", datatype=XSD_INTEGER).value, "foo") |
|
||||||
self.assertEqual(Literal("foo", datatype=XSD_INTEGER).datatype, XSD_INTEGER) |
|
||||||
|
|
||||||
def test_string(self) -> None: |
|
||||||
self.assertEqual(str(Literal("foo")), '"foo"') |
|
||||||
self.assertEqual(str(Literal("foo", language="en")), '"foo"@en') |
|
||||||
self.assertEqual( |
|
||||||
str(Literal("foo", datatype=XSD_INTEGER)), |
|
||||||
'"foo"^^<http://www.w3.org/2001/XMLSchema#integer>', |
|
||||||
) |
|
||||||
|
|
||||||
def test_equals(self) -> None: |
|
||||||
self.assertEqual(Literal("foo", datatype=XSD_STRING), Literal("foo")) |
|
||||||
self.assertEqual( |
|
||||||
Literal("foo", language="en", datatype=RDF_LANG_STRING), |
|
||||||
Literal("foo", language="en"), |
|
||||||
) |
|
||||||
self.assertNotEqual(NamedNode("http://foo"), Literal("foo")) |
|
||||||
self.assertNotEqual(Literal("foo"), NamedNode("http://foo")) |
|
||||||
self.assertNotEqual(BlankNode("foo"), Literal("foo")) |
|
||||||
self.assertNotEqual(Literal("foo"), BlankNode("foo")) |
|
||||||
|
|
||||||
def test_pickle(self) -> None: |
|
||||||
simple = Literal("foo") |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(simple)), simple) |
|
||||||
self.assertEqual(copy.copy(simple), simple) |
|
||||||
self.assertEqual(copy.deepcopy(simple), simple) |
|
||||||
|
|
||||||
lang_tagged = Literal("foo", language="en") |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(lang_tagged)), lang_tagged) |
|
||||||
self.assertEqual(copy.copy(lang_tagged), lang_tagged) |
|
||||||
self.assertEqual(copy.deepcopy(lang_tagged), lang_tagged) |
|
||||||
|
|
||||||
number = Literal("1", datatype=XSD_INTEGER) |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(number)), number) |
|
||||||
self.assertEqual(copy.copy(number), number) |
|
||||||
self.assertEqual(copy.deepcopy(number), number) |
|
||||||
|
|
||||||
def test_basic_match(self) -> None: |
|
||||||
match_works(self, 'Literal("foo", language="en")', 'Literal("foo", language="en")') |
|
||||||
match_works( |
|
||||||
self, |
|
||||||
'Literal("1", datatype=XSD_INTEGER)', |
|
||||||
'Literal("1", datatype=NamedNode("http://www.w3.org/2001/XMLSchema#integer"))', |
|
||||||
) |
|
||||||
|
|
||||||
def test_wildcard_match(self) -> None: |
|
||||||
match_works(self, 'Literal("foo", language="en")', "Literal(v, language=l)") |
|
||||||
match_works(self, 'Literal("1", datatype=XSD_INTEGER)', "Literal(v, datatype=d)") |
|
||||||
|
|
||||||
|
|
||||||
class TestTriple(unittest.TestCase): |
|
||||||
def test_constructor(self) -> None: |
|
||||||
t = Triple( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
) |
|
||||||
self.assertEqual(t.subject, NamedNode("http://example.com/s")) |
|
||||||
self.assertEqual(t.predicate, NamedNode("http://example.com/p")) |
|
||||||
self.assertEqual(t.object, NamedNode("http://example.com/o")) |
|
||||||
|
|
||||||
def test_rdf_star_constructor(self) -> None: |
|
||||||
t = Triple( |
|
||||||
Triple( |
|
||||||
NamedNode("http://example.com/ss"), |
|
||||||
NamedNode("http://example.com/sp"), |
|
||||||
NamedNode("http://example.com/so"), |
|
||||||
), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
Triple( |
|
||||||
NamedNode("http://example.com/os"), |
|
||||||
NamedNode("http://example.com/op"), |
|
||||||
NamedNode("http://example.com/oo"), |
|
||||||
), |
|
||||||
) |
|
||||||
self.assertEqual( |
|
||||||
t.subject, |
|
||||||
Triple( |
|
||||||
NamedNode("http://example.com/ss"), |
|
||||||
NamedNode("http://example.com/sp"), |
|
||||||
NamedNode("http://example.com/so"), |
|
||||||
), |
|
||||||
) |
|
||||||
self.assertEqual(t.predicate, NamedNode("http://example.com/p")) |
|
||||||
self.assertEqual( |
|
||||||
t.object, |
|
||||||
Triple( |
|
||||||
NamedNode("http://example.com/os"), |
|
||||||
NamedNode("http://example.com/op"), |
|
||||||
NamedNode("http://example.com/oo"), |
|
||||||
), |
|
||||||
) |
|
||||||
|
|
||||||
def test_mapping(self) -> None: |
|
||||||
t = Triple( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
) |
|
||||||
self.assertEqual(t[0], NamedNode("http://example.com/s")) |
|
||||||
self.assertEqual(t[1], NamedNode("http://example.com/p")) |
|
||||||
self.assertEqual(t[2], NamedNode("http://example.com/o")) |
|
||||||
|
|
||||||
def test_destruct(self) -> None: |
|
||||||
(s, p, o) = Triple( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
) |
|
||||||
self.assertEqual(s, NamedNode("http://example.com/s")) |
|
||||||
self.assertEqual(p, NamedNode("http://example.com/p")) |
|
||||||
self.assertEqual(o, NamedNode("http://example.com/o")) |
|
||||||
|
|
||||||
def test_string(self) -> None: |
|
||||||
self.assertEqual( |
|
||||||
str( |
|
||||||
Triple( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
) |
|
||||||
), |
|
||||||
"<http://example.com/s> <http://example.com/p> <http://example.com/o>", |
|
||||||
) |
|
||||||
|
|
||||||
def test_pickle(self) -> None: |
|
||||||
triple = Triple( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
) |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(triple)), triple) |
|
||||||
self.assertEqual(copy.copy(triple), triple) |
|
||||||
self.assertEqual(copy.deepcopy(triple), triple) |
|
||||||
|
|
||||||
def test_match(self) -> None: |
|
||||||
match_works( |
|
||||||
self, |
|
||||||
'Triple(NamedNode("http://example.com/s"), NamedNode("http://example.com/p"), ' |
|
||||||
'NamedNode("http://example.com/o"))', |
|
||||||
'Triple(NamedNode("http://example.com/s"), NamedNode(p), o)', |
|
||||||
) |
|
||||||
|
|
||||||
|
|
||||||
class TestDefaultGraph(unittest.TestCase): |
|
||||||
def test_equal(self) -> None: |
|
||||||
self.assertEqual(DefaultGraph(), DefaultGraph()) |
|
||||||
self.assertNotEqual(DefaultGraph(), NamedNode("http://bar")) |
|
||||||
|
|
||||||
def test_pickle(self) -> None: |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(DefaultGraph())), DefaultGraph()) |
|
||||||
self.assertEqual(copy.copy(DefaultGraph()), DefaultGraph()) |
|
||||||
self.assertEqual(copy.deepcopy(DefaultGraph()), DefaultGraph()) |
|
||||||
|
|
||||||
def test_match(self) -> None: |
|
||||||
match_works(self, "DefaultGraph()", "DefaultGraph()") |
|
||||||
|
|
||||||
|
|
||||||
class TestQuad(unittest.TestCase): |
|
||||||
def test_constructor(self) -> None: |
|
||||||
t = Quad( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
NamedNode("http://example.com/g"), |
|
||||||
) |
|
||||||
self.assertEqual(t.subject, NamedNode("http://example.com/s")) |
|
||||||
self.assertEqual(t.predicate, NamedNode("http://example.com/p")) |
|
||||||
self.assertEqual(t.object, NamedNode("http://example.com/o")) |
|
||||||
self.assertEqual(t.graph_name, NamedNode("http://example.com/g")) |
|
||||||
self.assertEqual( |
|
||||||
t.triple, |
|
||||||
Triple( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
), |
|
||||||
) |
|
||||||
self.assertEqual( |
|
||||||
Quad( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
), |
|
||||||
Quad( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
DefaultGraph(), |
|
||||||
), |
|
||||||
) |
|
||||||
|
|
||||||
def test_mapping(self) -> None: |
|
||||||
t = Quad( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
NamedNode("http://example.com/g"), |
|
||||||
) |
|
||||||
self.assertEqual(t[0], NamedNode("http://example.com/s")) |
|
||||||
self.assertEqual(t[1], NamedNode("http://example.com/p")) |
|
||||||
self.assertEqual(t[2], NamedNode("http://example.com/o")) |
|
||||||
self.assertEqual(t[3], NamedNode("http://example.com/g")) |
|
||||||
|
|
||||||
def test_destruct(self) -> None: |
|
||||||
(s, p, o, g) = Quad( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
NamedNode("http://example.com/g"), |
|
||||||
) |
|
||||||
self.assertEqual(s, NamedNode("http://example.com/s")) |
|
||||||
self.assertEqual(p, NamedNode("http://example.com/p")) |
|
||||||
self.assertEqual(o, NamedNode("http://example.com/o")) |
|
||||||
self.assertEqual(g, NamedNode("http://example.com/g")) |
|
||||||
|
|
||||||
def test_string(self) -> None: |
|
||||||
self.assertEqual( |
|
||||||
str( |
|
||||||
Triple( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
) |
|
||||||
), |
|
||||||
"<http://example.com/s> <http://example.com/p> <http://example.com/o>", |
|
||||||
) |
|
||||||
|
|
||||||
def test_pickle(self) -> None: |
|
||||||
quad = Quad( |
|
||||||
NamedNode("http://example.com/s"), |
|
||||||
NamedNode("http://example.com/p"), |
|
||||||
NamedNode("http://example.com/o"), |
|
||||||
NamedNode("http://example.com/g"), |
|
||||||
) |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(quad)), quad) |
|
||||||
self.assertEqual(copy.copy(quad), quad) |
|
||||||
self.assertEqual(copy.deepcopy(quad), quad) |
|
||||||
|
|
||||||
def test_match(self) -> None: |
|
||||||
match_works( |
|
||||||
self, |
|
||||||
'Quad(NamedNode("http://example.com/s"), NamedNode("http://example.com/p"), ' |
|
||||||
'NamedNode("http://example.com/o"), NamedNode("http://example.com/g"))', |
|
||||||
'Quad(NamedNode("http://example.com/s"), NamedNode(p), o, NamedNode("http://example.com/g"))', |
|
||||||
) |
|
||||||
|
|
||||||
|
|
||||||
class TestVariable(unittest.TestCase): |
|
||||||
def test_constructor(self) -> None: |
|
||||||
self.assertEqual(Variable("foo").value, "foo") |
|
||||||
|
|
||||||
def test_string(self) -> None: |
|
||||||
self.assertEqual(str(Variable("foo")), "?foo") |
|
||||||
|
|
||||||
def test_equal(self) -> None: |
|
||||||
self.assertEqual(Variable("foo"), Variable("foo")) |
|
||||||
self.assertNotEqual(Variable("foo"), Variable("bar")) |
|
||||||
|
|
||||||
def test_pickle(self) -> None: |
|
||||||
v = Variable("foo") |
|
||||||
self.assertEqual(pickle.loads(pickle.dumps(v)), v) |
|
||||||
self.assertEqual(copy.copy(v), v) |
|
||||||
self.assertEqual(copy.deepcopy(v), v) |
|
||||||
|
|
||||||
def test_basic_match(self) -> None: |
|
||||||
match_works(self, 'Variable("foo")', 'Variable("foo")') |
|
||||||
|
|
||||||
def test_wildcard_match(self) -> None: |
|
||||||
match_works(self, 'Variable("foo")', "Variable(x)") |
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__": |
|
||||||
unittest.main() |
|
||||||
@ -1,418 +0,0 @@ |
|||||||
import gc |
|
||||||
import sys |
|
||||||
import unittest |
|
||||||
from io import BytesIO, StringIO, UnsupportedOperation |
|
||||||
from pathlib import Path |
|
||||||
from tempfile import NamedTemporaryFile, TemporaryDirectory, TemporaryFile |
|
||||||
from typing import Any |
|
||||||
|
|
||||||
from pyoxigraph import ( |
|
||||||
BlankNode, |
|
||||||
DefaultGraph, |
|
||||||
NamedNode, |
|
||||||
Quad, |
|
||||||
QueryBoolean, |
|
||||||
QueryResultsFormat, |
|
||||||
QuerySolution, |
|
||||||
QuerySolutions, |
|
||||||
QueryTriples, |
|
||||||
RdfFormat, |
|
||||||
Store, |
|
||||||
Triple, |
|
||||||
Variable, |
|
||||||
) |
|
||||||
|
|
||||||
foo = NamedNode("http://foo") |
|
||||||
bar = NamedNode("http://bar") |
|
||||||
baz = NamedNode("http://baz") |
|
||||||
triple = Triple(foo, foo, foo) |
|
||||||
graph = NamedNode("http://graph") |
|
||||||
is_wasm = sys.platform == "emscripten" |
|
||||||
|
|
||||||
|
|
||||||
class TestStore(unittest.TestCase): |
|
||||||
def test_add(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
store.add(Quad(foo, bar, baz, DefaultGraph())) |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
store.add(Quad(triple, bar, baz)) |
|
||||||
store.add(Quad(foo, bar, triple)) |
|
||||||
self.assertEqual(len(store), 4) |
|
||||||
|
|
||||||
def test_extend(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.extend( |
|
||||||
( |
|
||||||
Quad(foo, bar, baz), |
|
||||||
Quad(foo, bar, baz, graph), |
|
||||||
Quad(foo, bar, baz, DefaultGraph()), |
|
||||||
) |
|
||||||
) |
|
||||||
self.assertEqual(len(store), 2) |
|
||||||
|
|
||||||
@unittest.skipIf(is_wasm, "Not supported with WASM") |
|
||||||
def test_bulk_extend(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.bulk_extend( |
|
||||||
( |
|
||||||
Quad(foo, bar, baz), |
|
||||||
Quad(foo, bar, baz, graph), |
|
||||||
Quad(foo, bar, baz, DefaultGraph()), |
|
||||||
) |
|
||||||
) |
|
||||||
self.assertEqual(len(store), 2) |
|
||||||
|
|
||||||
def test_remove(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
store.add(Quad(foo, bar, baz, DefaultGraph())) |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
store.remove(Quad(foo, bar, baz)) |
|
||||||
self.assertEqual(len(store), 1) |
|
||||||
|
|
||||||
def test_len(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
self.assertEqual(len(store), 2) |
|
||||||
|
|
||||||
def test_in(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
store.add(Quad(foo, bar, baz, DefaultGraph())) |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
self.assertIn(Quad(foo, bar, baz), store) |
|
||||||
self.assertIn(Quad(foo, bar, baz, DefaultGraph()), store) |
|
||||||
self.assertIn(Quad(foo, bar, baz, graph), store) |
|
||||||
self.assertNotIn(Quad(foo, bar, baz, foo), store) |
|
||||||
|
|
||||||
def test_iter(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz, DefaultGraph())) |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
self.assertEqual( |
|
||||||
set(store), |
|
||||||
{Quad(foo, bar, baz, DefaultGraph()), Quad(foo, bar, baz, graph)}, |
|
||||||
) |
|
||||||
|
|
||||||
def test_quads_for_pattern(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz, DefaultGraph())) |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
self.assertEqual( |
|
||||||
set(store.quads_for_pattern(None, None, None)), |
|
||||||
{Quad(foo, bar, baz, DefaultGraph()), Quad(foo, bar, baz, graph)}, |
|
||||||
) |
|
||||||
self.assertEqual( |
|
||||||
set(store.quads_for_pattern(foo, None, None)), |
|
||||||
{Quad(foo, bar, baz, DefaultGraph()), Quad(foo, bar, baz, graph)}, |
|
||||||
) |
|
||||||
self.assertEqual( |
|
||||||
set(store.quads_for_pattern(None, None, None, graph)), |
|
||||||
{Quad(foo, bar, baz, graph)}, |
|
||||||
) |
|
||||||
self.assertEqual( |
|
||||||
set(store.quads_for_pattern(foo, None, None, DefaultGraph())), |
|
||||||
{Quad(foo, bar, baz, DefaultGraph())}, |
|
||||||
) |
|
||||||
|
|
||||||
def test_ask_query(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, foo, foo)) |
|
||||||
self.assertTrue(store.query("ASK { ?s ?s ?s }")) |
|
||||||
self.assertFalse(store.query("ASK { FILTER(false) }")) |
|
||||||
|
|
||||||
def test_construct_query(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
results: Any = store.query("CONSTRUCT { ?s ?p ?o } WHERE { ?s ?p ?o }") |
|
||||||
self.assertIsInstance(results, QueryTriples) |
|
||||||
self.assertEqual( |
|
||||||
set(results), |
|
||||||
{Triple(foo, bar, baz)}, |
|
||||||
) |
|
||||||
|
|
||||||
def test_select_query(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
solutions: Any = store.query("SELECT ?s ?o WHERE { ?s ?p ?o }") |
|
||||||
self.assertIsInstance(solutions, QuerySolutions) |
|
||||||
self.assertEqual(solutions.variables, [Variable("s"), Variable("o")]) |
|
||||||
solution = next(solutions) |
|
||||||
self.assertIsInstance(solution, QuerySolution) |
|
||||||
self.assertEqual(solution[0], foo) |
|
||||||
self.assertEqual(solution[1], baz) |
|
||||||
self.assertEqual(solution["s"], foo) |
|
||||||
self.assertEqual(solution["o"], baz) |
|
||||||
self.assertEqual(solution[Variable("s")], foo) |
|
||||||
self.assertEqual(solution[Variable("o")], baz) |
|
||||||
s, o = solution |
|
||||||
self.assertEqual(s, foo) |
|
||||||
self.assertEqual(o, baz) |
|
||||||
|
|
||||||
def test_select_query_union_default_graph(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
results: Any = store.query("SELECT ?s WHERE { ?s ?p ?o }") |
|
||||||
self.assertEqual(len(list(results)), 0) |
|
||||||
results = store.query("SELECT ?s WHERE { ?s ?p ?o }", use_default_graph_as_union=True) |
|
||||||
self.assertEqual(len(list(results)), 1) |
|
||||||
results = store.query( |
|
||||||
"SELECT ?s WHERE { ?s ?p ?o }", |
|
||||||
use_default_graph_as_union=True, |
|
||||||
named_graphs=[graph], |
|
||||||
) |
|
||||||
self.assertEqual(len(list(results)), 1) |
|
||||||
|
|
||||||
def test_select_query_with_default_graph(self) -> None: |
|
||||||
store = Store() |
|
||||||
graph_bnode = BlankNode("g") |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
store.add(Quad(foo, bar, foo)) |
|
||||||
store.add(Quad(foo, bar, bar, graph_bnode)) |
|
||||||
results: Any = store.query("SELECT ?s WHERE { ?s ?p ?o }") |
|
||||||
self.assertEqual(len(list(results)), 1) |
|
||||||
results = store.query("SELECT ?s WHERE { ?s ?p ?o }", default_graph=graph) |
|
||||||
self.assertEqual(len(list(results)), 1) |
|
||||||
results = store.query( |
|
||||||
"SELECT ?s WHERE { ?s ?p ?o }", |
|
||||||
default_graph=[DefaultGraph(), graph, graph_bnode], |
|
||||||
) |
|
||||||
self.assertEqual(len(list(results)), 3) |
|
||||||
|
|
||||||
def test_select_query_with_named_graph(self) -> None: |
|
||||||
store = Store() |
|
||||||
graph_bnode = BlankNode("g") |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
store.add(Quad(foo, bar, foo)) |
|
||||||
store.add(Quad(foo, bar, bar, graph_bnode)) |
|
||||||
store.add(Quad(foo, bar, bar, foo)) |
|
||||||
results: Any = store.query( |
|
||||||
"SELECT ?s WHERE { GRAPH ?g { ?s ?p ?o } }", |
|
||||||
named_graphs=[graph, graph_bnode], |
|
||||||
) |
|
||||||
self.assertEqual(len(list(results)), 2) |
|
||||||
|
|
||||||
def test_select_query_dump(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
results: QuerySolutions = store.query("SELECT ?s WHERE { ?s ?p ?o }") # type: ignore[assignment] |
|
||||||
self.assertIsInstance(results, QuerySolutions) |
|
||||||
output = BytesIO() |
|
||||||
results.serialize(output, QueryResultsFormat.CSV) |
|
||||||
self.assertEqual( |
|
||||||
output.getvalue().decode(), |
|
||||||
"s\r\nhttp://foo\r\n", |
|
||||||
) |
|
||||||
|
|
||||||
def test_ask_query_dump(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
results: QueryBoolean = store.query("ASK { ?s ?p ?o }") # type: ignore[assignment] |
|
||||||
self.assertIsInstance(results, QueryBoolean) |
|
||||||
output = BytesIO() |
|
||||||
results.serialize(output, QueryResultsFormat.CSV) |
|
||||||
self.assertEqual( |
|
||||||
output.getvalue().decode(), |
|
||||||
"true", |
|
||||||
) |
|
||||||
|
|
||||||
def test_construct_query_dump(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
results: QueryTriples = store.query("CONSTRUCT WHERE { ?s ?p ?o }") # type: ignore[assignment] |
|
||||||
self.assertIsInstance(results, QueryTriples) |
|
||||||
output = BytesIO() |
|
||||||
results.serialize(output, RdfFormat.N_TRIPLES) |
|
||||||
self.assertEqual( |
|
||||||
output.getvalue().decode(), |
|
||||||
"<http://foo> <http://bar> <http://baz> .\n", |
|
||||||
) |
|
||||||
|
|
||||||
def test_update_insert_data(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.update("INSERT DATA { <http://foo> <http://foo> <http://foo> }") |
|
||||||
self.assertEqual(len(store), 1) |
|
||||||
|
|
||||||
def test_update_delete_data(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, foo, foo)) |
|
||||||
store.update("DELETE DATA { <http://foo> <http://foo> <http://foo> }") |
|
||||||
self.assertEqual(len(store), 0) |
|
||||||
|
|
||||||
def test_update_delete_where(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, foo, foo)) |
|
||||||
store.update("DELETE WHERE { ?v ?v ?v }") |
|
||||||
self.assertEqual(len(store), 0) |
|
||||||
|
|
||||||
@unittest.skipIf(is_wasm, "Not supported with WASM") |
|
||||||
def test_update_load(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.update("LOAD <https://www.w3.org/1999/02/22-rdf-syntax-ns>") |
|
||||||
self.assertGreater(len(store), 100) |
|
||||||
|
|
||||||
def test_update_star(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.update("PREFIX : <http://www.example.org/> INSERT DATA { :alice :claims << :bob :age 23 >> }") |
|
||||||
results: Any = store.query( |
|
||||||
"PREFIX : <http://www.example.org/> SELECT ?p ?a WHERE { ?p :claims << :bob :age ?a >> }" |
|
||||||
) |
|
||||||
self.assertEqual(len(list(results)), 1) |
|
||||||
|
|
||||||
def test_load_ntriples_to_default_graph(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.load( |
|
||||||
b"<http://foo> <http://bar> <http://baz> .", |
|
||||||
RdfFormat.N_TRIPLES, |
|
||||||
) |
|
||||||
self.assertEqual(set(store), {Quad(foo, bar, baz, DefaultGraph())}) |
|
||||||
|
|
||||||
def test_load_ntriples_to_named_graph(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.load( |
|
||||||
"<http://foo> <http://bar> <http://baz> .", |
|
||||||
RdfFormat.N_TRIPLES, |
|
||||||
to_graph=graph, |
|
||||||
) |
|
||||||
self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) |
|
||||||
|
|
||||||
def test_load_turtle_with_base_iri(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.load( |
|
||||||
BytesIO(b"<http://foo> <http://bar> <> ."), |
|
||||||
RdfFormat.TURTLE, |
|
||||||
base_iri="http://baz", |
|
||||||
) |
|
||||||
self.assertEqual(set(store), {Quad(foo, bar, baz, DefaultGraph())}) |
|
||||||
|
|
||||||
def test_load_nquads(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.load( |
|
||||||
StringIO("<http://foo> <http://bar> <http://baz> <http://graph>."), |
|
||||||
RdfFormat.N_QUADS, |
|
||||||
) |
|
||||||
self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) |
|
||||||
|
|
||||||
def test_load_trig_with_base_iri(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.load( |
|
||||||
"<http://graph> { <http://foo> <http://bar> <> . }", |
|
||||||
RdfFormat.TRIG, |
|
||||||
base_iri="http://baz", |
|
||||||
) |
|
||||||
self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) |
|
||||||
|
|
||||||
def test_load_file(self) -> None: |
|
||||||
with NamedTemporaryFile(suffix=".nq") as fp: |
|
||||||
fp.write(b"<http://foo> <http://bar> <http://baz> <http://graph>.") |
|
||||||
fp.flush() |
|
||||||
store = Store() |
|
||||||
store.load(path=fp.name) |
|
||||||
self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) |
|
||||||
|
|
||||||
def test_load_with_io_error(self) -> None: |
|
||||||
with self.assertRaises(UnsupportedOperation) as _, TemporaryFile("wb") as fp: |
|
||||||
Store().load(fp, RdfFormat.N_TRIPLES) |
|
||||||
|
|
||||||
def test_dump_ntriples(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
output = BytesIO() |
|
||||||
store.dump(output, RdfFormat.N_TRIPLES, from_graph=graph) |
|
||||||
self.assertEqual( |
|
||||||
output.getvalue(), |
|
||||||
b"<http://foo> <http://bar> <http://baz> .\n", |
|
||||||
) |
|
||||||
|
|
||||||
def test_dump_nquads(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
self.assertEqual( |
|
||||||
store.dump(format=RdfFormat.N_QUADS), |
|
||||||
b"<http://foo> <http://bar> <http://baz> <http://graph> .\n", |
|
||||||
) |
|
||||||
|
|
||||||
def test_dump_trig(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
output = BytesIO() |
|
||||||
store.dump(output, RdfFormat.TRIG) |
|
||||||
self.assertEqual( |
|
||||||
output.getvalue(), |
|
||||||
b"<http://foo> <http://bar> <http://baz> .\n" |
|
||||||
b"<http://graph> {\n\t<http://foo> <http://bar> <http://baz> .\n}\n", |
|
||||||
) |
|
||||||
|
|
||||||
def test_dump_file(self) -> None: |
|
||||||
with NamedTemporaryFile(delete=False) as fp: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
file_name = Path(fp.name) |
|
||||||
store.dump(file_name, RdfFormat.N_QUADS) |
|
||||||
self.assertEqual( |
|
||||||
file_name.read_text(), |
|
||||||
"<http://foo> <http://bar> <http://baz> <http://graph> .\n", |
|
||||||
) |
|
||||||
|
|
||||||
def test_dump_with_io_error(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, bar)) |
|
||||||
with self.assertRaises(OSError) as _, TemporaryFile("rb") as fp: |
|
||||||
store.dump(fp, RdfFormat.TRIG) |
|
||||||
|
|
||||||
def test_write_in_read(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, bar)) |
|
||||||
store.add(Quad(foo, bar, baz)) |
|
||||||
for triple in store: |
|
||||||
store.add(Quad(triple.object, triple.predicate, triple.subject)) |
|
||||||
self.assertEqual(len(store), 4) |
|
||||||
|
|
||||||
def test_add_graph(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add_graph(graph) |
|
||||||
self.assertEqual(list(store.named_graphs()), [graph]) |
|
||||||
|
|
||||||
def test_remove_graph(self) -> None: |
|
||||||
store = Store() |
|
||||||
store.add(Quad(foo, bar, baz, graph)) |
|
||||||
store.add_graph(NamedNode("http://graph2")) |
|
||||||
store.remove_graph(graph) |
|
||||||
store.remove_graph(NamedNode("http://graph2")) |
|
||||||
self.assertEqual(list(store.named_graphs()), []) |
|
||||||
self.assertEqual(list(store), []) |
|
||||||
|
|
||||||
@unittest.skipIf(is_wasm, "Not supported with WASM") |
|
||||||
def test_read_only(self) -> None: |
|
||||||
quad = Quad(foo, bar, baz, graph) |
|
||||||
with TemporaryDirectory() as dir: |
|
||||||
store = Store(dir) |
|
||||||
store.add(quad) |
|
||||||
del store |
|
||||||
gc.collect() |
|
||||||
store = Store.read_only(dir) |
|
||||||
self.assertEqual(list(store), [quad]) |
|
||||||
|
|
||||||
@unittest.skipIf(is_wasm, "Not supported with WASM") |
|
||||||
def test_secondary(self) -> None: |
|
||||||
quad = Quad(foo, bar, baz, graph) |
|
||||||
with TemporaryDirectory() as dir: |
|
||||||
store = Store(dir) |
|
||||||
store.add(quad) |
|
||||||
store.flush() |
|
||||||
|
|
||||||
secondary_store = Store.secondary(dir) |
|
||||||
self.assertEqual(list(secondary_store), [quad]) |
|
||||||
|
|
||||||
store.remove(quad) |
|
||||||
store.flush() |
|
||||||
self.assertEqual(list(secondary_store), []) |
|
||||||
del secondary_store |
|
||||||
del store |
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__": |
|
||||||
unittest.main() |
|
||||||
Loading…
Reference in new issue