parent
e963387b02
commit
86a8100121
@ -1 +0,0 @@ |
||||
../Cargo.lock |
||||
@ -1,23 +0,0 @@ |
||||
[package] |
||||
name = "pyoxigraph" |
||||
version = "0.3.22" |
||||
authors = ["Tpt"] |
||||
license = "MIT OR Apache-2.0" |
||||
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 = "2021" |
||||
|
||||
[lib] |
||||
crate-type = ["cdylib"] |
||||
name = "pyoxigraph" |
||||
doctest = false |
||||
|
||||
[features] |
||||
abi3 = ["pyo3/abi3-py37"] |
||||
|
||||
[dependencies] |
||||
oxigraph = { version = "0.3.22", path="../lib", features = ["http_client"] } |
||||
pyo3 = { version = "0.19", features = ["extension-module"] } |
||||
@ -1,80 +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?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) |
||||
|
||||
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). |
||||
|
||||
## 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,14 +0,0 @@ |
||||
RDF Parsing and Serialization |
||||
============================= |
||||
|
||||
Oxigraph provides functions to parse and serialize RDF files: |
||||
|
||||
|
||||
Parsing |
||||
""""""" |
||||
.. autofunction:: pyoxigraph.parse |
||||
|
||||
|
||||
Serialization |
||||
""""""""""""" |
||||
.. autofunction:: pyoxigraph.serialize |
||||
@ -1,34 +0,0 @@ |
||||
Migration Guide |
||||
=============== |
||||
|
||||
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,37 +0,0 @@ |
||||
RDF Model |
||||
========= |
||||
|
||||
Oxigraph provides python classes to represents basic RDF concepts: |
||||
|
||||
|
||||
`IRIs <https://www.w3.org/TR/rdf11-concepts/#dfn-iri>`_ |
||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
||||
.. autoclass:: pyoxigraph.NamedNode |
||||
:members: |
||||
|
||||
|
||||
`Blank Nodes <https://www.w3.org/TR/rdf11-concepts/#dfn-blank-node>`_ |
||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
||||
.. autoclass:: pyoxigraph.BlankNode |
||||
:members: |
||||
|
||||
|
||||
`Literals <https://www.w3.org/TR/rdf11-concepts/#dfn-literal>`_ |
||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
||||
.. autoclass:: pyoxigraph.Literal |
||||
:members: |
||||
|
||||
|
||||
`Triples <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple>`_ |
||||
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" |
||||
.. autoclass:: pyoxigraph.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:: pyoxigraph.Quad |
||||
:members: |
||||
|
||||
.. autoclass:: pyoxigraph.DefaultGraph |
||||
:members: |
||||
@ -1,23 +0,0 @@ |
||||
SPARQL utility objects |
||||
============================= |
||||
|
||||
Oxigraph provides also some utilities related to SPARQL queries: |
||||
|
||||
|
||||
Variable |
||||
"""""""" |
||||
.. autoclass:: pyoxigraph.Variable |
||||
:members: |
||||
|
||||
|
||||
``SELECT`` solutions |
||||
"""""""""""""""""""" |
||||
.. autoclass:: pyoxigraph.QuerySolutions |
||||
:members: |
||||
.. autoclass:: pyoxigraph.QuerySolution |
||||
:members: |
||||
|
||||
``CONSTRUCT`` results |
||||
""""""""""""""""""""" |
||||
.. autoclass:: pyoxigraph.QueryTriples |
||||
:members: |
||||
@ -1,5 +0,0 @@ |
||||
RDF Store |
||||
========= |
||||
|
||||
.. autoclass:: pyoxigraph.Store |
||||
:members: |
||||
@ -1,506 +0,0 @@ |
||||
import argparse |
||||
import ast |
||||
import importlib |
||||
import inspect |
||||
import logging |
||||
import re |
||||
import subprocess |
||||
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 |
||||
|
||||
|
||||
AST_LOAD = ast.Load() |
||||
AST_ELLIPSIS = ast.Ellipsis() |
||||
AST_STORE = ast.Store() |
||||
AST_TYPING_ANY = _path_to_type("typing", "Any") |
||||
GENERICS = { |
||||
"iterable": _path_to_type("typing", "Iterable"), |
||||
"iterator": _path_to_type("typing", "Iterator"), |
||||
"list": _path_to_type("typing", "List"), |
||||
"io": _path_to_type("typing", "IO"), |
||||
} |
||||
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__": ([AST_TYPING_ANY], _path_to_type("bool")), |
||||
"__del__": None, |
||||
"__delattr__": ([_path_to_type("str")], _path_to_type("None")), |
||||
"__delitem__": ([AST_TYPING_ANY], AST_TYPING_ANY), |
||||
"__dict__": None, |
||||
"__dir__": None, |
||||
"__doc__": None, |
||||
"__eq__": ([AST_TYPING_ANY], _path_to_type("bool")), |
||||
"__format__": ([_path_to_type("str")], _path_to_type("str")), |
||||
"__ge__": ([AST_TYPING_ANY], _path_to_type("bool")), |
||||
"__getattribute__": ([_path_to_type("str")], AST_TYPING_ANY), |
||||
"__getitem__": ([AST_TYPING_ANY], AST_TYPING_ANY), |
||||
"__gt__": ([AST_TYPING_ANY], _path_to_type("bool")), |
||||
"__hash__": ([], _path_to_type("int")), |
||||
"__init__": ([], _path_to_type("None")), |
||||
"__init_subclass__": None, |
||||
"__iter__": ([], AST_TYPING_ANY), |
||||
"__le__": ([AST_TYPING_ANY], _path_to_type("bool")), |
||||
"__len__": ([], _path_to_type("int")), |
||||
"__lt__": ([AST_TYPING_ANY], _path_to_type("bool")), |
||||
"__module__": None, |
||||
"__ne__": ([AST_TYPING_ANY], _path_to_type("bool")), |
||||
"__new__": None, |
||||
"__next__": ([], AST_TYPING_ANY), |
||||
"__reduce__": None, |
||||
"__reduce_ex__": None, |
||||
"__repr__": ([], _path_to_type("str")), |
||||
"__setattr__": ([_path_to_type("str"), AST_TYPING_ANY], _path_to_type("None")), |
||||
"__setitem__": ([AST_TYPING_ANY, AST_TYPING_ANY], AST_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("typing", "Tuple"), |
||||
slice=ast.Tuple( |
||||
elts=[_path_to_type("str"), ast.Ellipsis()], ctx=AST_LOAD |
||||
), |
||||
ctx=AST_LOAD, |
||||
), |
||||
value=ast.Constant(member_value), |
||||
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 AST_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): |
||||
parts = group[0].split(".") |
||||
if any(not p for p in parts): |
||||
raise ValueError( |
||||
f"Not able to parse type '{type_str}' used by {'.'.join(element_path)}" |
||||
) |
||||
if len(parts) > 1: |
||||
types_to_import.add(parts[0]) |
||||
new_elements.append(_path_to_type(*parts)) |
||||
elif ( |
||||
len(group) == 2 |
||||
and isinstance(group[0], str) |
||||
and isinstance(group[1], list) |
||||
): |
||||
if group[0] not in GENERICS: |
||||
raise ValueError( |
||||
f"Constructor {group[0]} is not supported in type '{type_str}' used by {'.'.join(element_path)}" |
||||
) |
||||
new_elements.append( |
||||
ast.Subscript( |
||||
value=GENERICS[group[0]], |
||||
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 ( |
||||
ast.Subscript( |
||||
value=_path_to_type("typing", "Union"), |
||||
slice=ast.Tuple(elts=new_elements, ctx=AST_LOAD), |
||||
ctx=AST_LOAD, |
||||
) |
||||
if len(new_elements) > 1 |
||||
else new_elements[0] |
||||
) |
||||
|
||||
return parse_sequence(stack[0]) |
||||
|
||||
|
||||
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_black(code: str) -> str: |
||||
result = subprocess.run( |
||||
["python", "-m", "black", "-t", "py37", "--pyi", "-"], |
||||
input=code.encode(), |
||||
capture_output=True, |
||||
) |
||||
result.check_returncode() |
||||
return result.stdout.decode() |
||||
|
||||
|
||||
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( |
||||
"--black", help="Formats the generated stubs using Black", action="store_true" |
||||
) |
||||
args = parser.parse_args() |
||||
stub_content = ast.unparse(module_stubs(importlib.import_module(args.module_name))) |
||||
stub_content = stub_content.replace( |
||||
", /", "" |
||||
) # TODO: remove when targeting Python 3.8+ |
||||
if args.black: |
||||
stub_content = format_with_black(stub_content) |
||||
args.out.write(stub_content) |
||||
@ -1,2 +0,0 @@ |
||||
pyoxigraph.pyoxigraph |
||||
pyoxigraph.DefaultGraph.__init__ |
||||
@ -1,56 +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.7", |
||||
"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.7" |
||||
|
||||
[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.ruff] |
||||
line-length = 120 |
||||
select = [ |
||||
"ARG", |
||||
"B", |
||||
"C40", |
||||
"E", |
||||
"F", |
||||
"FBT", |
||||
"I", |
||||
"ICN", |
||||
"ISC", |
||||
"N", |
||||
"PIE", |
||||
"PTH", |
||||
"RET", |
||||
"RUF", |
||||
"SIM", |
||||
"T10", |
||||
"TCH", |
||||
"TID", |
||||
"UP", |
||||
"W", |
||||
"YTT" |
||||
] |
||||
@ -1,6 +0,0 @@ |
||||
black~=23.1 |
||||
furo |
||||
maturin~=1.0 |
||||
mypy~=1.0 |
||||
ruff~=0.0.255 |
||||
sphinx~=5.3 |
||||
@ -1,372 +0,0 @@ |
||||
#![allow(clippy::needless_option_as_deref)] |
||||
|
||||
use crate::model::{PyQuad, PyTriple}; |
||||
use oxigraph::io::read::{ParseError, QuadReader, TripleReader}; |
||||
use oxigraph::io::{ |
||||
DatasetFormat, DatasetParser, DatasetSerializer, GraphFormat, GraphParser, GraphSerializer, |
||||
}; |
||||
use pyo3::exceptions::{PyIOError, PySyntaxError, PyValueError}; |
||||
use pyo3::prelude::*; |
||||
use pyo3::types::PyBytes; |
||||
use pyo3::{intern, wrap_pyfunction}; |
||||
use std::cmp::max; |
||||
use std::error::Error; |
||||
use std::fs::File; |
||||
use std::io::{self, BufRead, BufReader, BufWriter, Cursor, Read, Write}; |
||||
use std::path::{Path, PathBuf}; |
||||
|
||||
pub fn add_to_module(module: &PyModule) -> PyResult<()> { |
||||
module.add_wrapped(wrap_pyfunction!(parse))?; |
||||
module.add_wrapped(wrap_pyfunction!(serialize)) |
||||
} |
||||
|
||||
/// Parses RDF graph and dataset serialization formats.
|
||||
///
|
||||
/// It currently supports the following formats:
|
||||
///
|
||||
/// * `N-Triples <https://www.w3.org/TR/n-triples/>`_ (``application/n-triples``)
|
||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (``application/n-quads``)
|
||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (``text/turtle``)
|
||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (``application/trig``)
|
||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (``application/rdf+xml``)
|
||||
///
|
||||
/// It supports also some MIME type aliases.
|
||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
||||
/// and ``application/xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
||||
///
|
||||
/// :param input: The binary I/O object or file path to read from. For example, it could be a file path as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``.
|
||||
/// :type input: io(bytes) or io(str) or str or pathlib.Path
|
||||
/// :param mime_type: the MIME type of the RDF serialization.
|
||||
/// :type mime_type: str
|
||||
/// :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
|
||||
/// :return: an iterator of RDF triples or quads depending on the format.
|
||||
/// :rtype: iterator(Triple) or iterator(Quad)
|
||||
/// :raises ValueError: if the MIME type is not supported.
|
||||
/// :raises SyntaxError: if the provided data is invalid.
|
||||
///
|
||||
/// >>> input = io.BytesIO(b'<foo> <p> "1" .')
|
||||
/// >>> list(parse(input, "text/turtle", base_iri="http://example.com/"))
|
||||
/// [<Triple 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>>>]
|
||||
#[pyfunction] |
||||
#[pyo3(signature = (input, mime_type, *, base_iri = None))] |
||||
pub fn parse( |
||||
input: PyObject, |
||||
mime_type: &str, |
||||
base_iri: Option<&str>, |
||||
py: Python<'_>, |
||||
) -> PyResult<PyObject> { |
||||
let input = if let Ok(path) = input.extract::<PathBuf>(py) { |
||||
PyReadable::from_file(&path, py).map_err(map_io_err)? |
||||
} else { |
||||
PyReadable::from_data(input, py) |
||||
}; |
||||
if let Some(graph_format) = GraphFormat::from_media_type(mime_type) { |
||||
let mut parser = GraphParser::from_format(graph_format); |
||||
if let Some(base_iri) = base_iri { |
||||
parser = parser |
||||
.with_base_iri(base_iri) |
||||
.map_err(|e| PyValueError::new_err(e.to_string()))?; |
||||
} |
||||
Ok(PyTripleReader { |
||||
inner: py.allow_threads(|| parser.read_triples(input).map_err(map_parse_error))?, |
||||
} |
||||
.into_py(py)) |
||||
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { |
||||
let mut parser = DatasetParser::from_format(dataset_format); |
||||
if let Some(base_iri) = base_iri { |
||||
parser = parser |
||||
.with_base_iri(base_iri) |
||||
.map_err(|e| PyValueError::new_err(e.to_string()))?; |
||||
} |
||||
Ok(PyQuadReader { |
||||
inner: py.allow_threads(|| parser.read_quads(input).map_err(map_parse_error))?, |
||||
} |
||||
.into_py(py)) |
||||
} else { |
||||
Err(PyValueError::new_err(format!( |
||||
"Not supported MIME type: {mime_type}" |
||||
))) |
||||
} |
||||
} |
||||
|
||||
/// Serializes an RDF graph or dataset.
|
||||
///
|
||||
/// It currently supports the following formats:
|
||||
///
|
||||
/// * `N-Triples <https://www.w3.org/TR/n-triples/>`_ (``application/n-triples``)
|
||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (``application/n-quads``)
|
||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (``text/turtle``)
|
||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (``application/trig``)
|
||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (``application/rdf+xml``)
|
||||
///
|
||||
/// It supports also some MIME type aliases.
|
||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
||||
/// and ``application/xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
||||
///
|
||||
/// :param input: the RDF triples and quads to serialize.
|
||||
/// :type input: iterable(Triple) or 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')``.
|
||||
/// :type output: io(bytes) or str or pathlib.Path
|
||||
/// :param mime_type: the MIME type of the RDF serialization.
|
||||
/// :type mime_type: str
|
||||
/// :rtype: None
|
||||
/// :raises ValueError: if the MIME type is not supported.
|
||||
/// :raises TypeError: if a triple is given during a quad format serialization or reverse.
|
||||
///
|
||||
/// >>> output = io.BytesIO()
|
||||
/// >>> serialize([Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'))], output, "text/turtle")
|
||||
/// >>> output.getvalue()
|
||||
/// b'<http://example.com> <http://example.com/p> "1" .\n'
|
||||
#[pyfunction] |
||||
pub fn serialize(input: &PyAny, output: PyObject, mime_type: &str, py: Python<'_>) -> PyResult<()> { |
||||
let output = if let Ok(path) = output.extract::<PathBuf>(py) { |
||||
PyWritable::from_file(&path, py).map_err(map_io_err)? |
||||
} else { |
||||
PyWritable::from_data(output) |
||||
}; |
||||
if let Some(graph_format) = GraphFormat::from_media_type(mime_type) { |
||||
let mut writer = GraphSerializer::from_format(graph_format) |
||||
.triple_writer(output) |
||||
.map_err(map_io_err)?; |
||||
for i in input.iter()? { |
||||
writer |
||||
.write(&*i?.extract::<PyRef<PyTriple>>()?) |
||||
.map_err(map_io_err)?; |
||||
} |
||||
writer.finish().map_err(map_io_err)?; |
||||
Ok(()) |
||||
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { |
||||
let mut writer = DatasetSerializer::from_format(dataset_format) |
||||
.quad_writer(output) |
||||
.map_err(map_io_err)?; |
||||
for i in input.iter()? { |
||||
writer |
||||
.write(&*i?.extract::<PyRef<PyQuad>>()?) |
||||
.map_err(map_io_err)?; |
||||
} |
||||
writer.finish().map_err(map_io_err)?; |
||||
Ok(()) |
||||
} else { |
||||
Err(PyValueError::new_err(format!( |
||||
"Not supported MIME type: {mime_type}" |
||||
))) |
||||
} |
||||
} |
||||
|
||||
#[pyclass(name = "TripleReader", module = "pyoxigraph")] |
||||
pub struct PyTripleReader { |
||||
inner: TripleReader<PyReadable>, |
||||
} |
||||
|
||||
#[pymethods] |
||||
impl PyTripleReader { |
||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<Self> { |
||||
slf |
||||
} |
||||
|
||||
fn __next__(&mut self, py: Python<'_>) -> PyResult<Option<PyTriple>> { |
||||
py.allow_threads(|| { |
||||
self.inner |
||||
.next() |
||||
.map(|q| Ok(q.map_err(map_parse_error)?.into())) |
||||
.transpose() |
||||
}) |
||||
} |
||||
} |
||||
|
||||
#[pyclass(name = "QuadReader", module = "pyoxigraph")] |
||||
pub struct PyQuadReader { |
||||
inner: QuadReader<PyReadable>, |
||||
} |
||||
|
||||
#[pymethods] |
||||
impl PyQuadReader { |
||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<Self> { |
||||
slf |
||||
} |
||||
|
||||
fn __next__(&mut self, py: Python<'_>) -> PyResult<Option<PyQuad>> { |
||||
py.allow_threads(|| { |
||||
self.inner |
||||
.next() |
||||
.map(|q| Ok(q.map_err(map_parse_error)?.into())) |
||||
.transpose() |
||||
}) |
||||
} |
||||
} |
||||
|
||||
pub enum PyReadable { |
||||
Bytes(Cursor<Vec<u8>>), |
||||
Io(BufReader<PyIo>), |
||||
File(BufReader<File>), |
||||
} |
||||
|
||||
impl PyReadable { |
||||
pub fn from_file(file: &Path, py: Python<'_>) -> io::Result<Self> { |
||||
Ok(Self::File(BufReader::new( |
||||
py.allow_threads(|| File::open(file))?, |
||||
))) |
||||
} |
||||
|
||||
pub fn from_data(data: PyObject, py: Python<'_>) -> Self { |
||||
if let Ok(bytes) = data.extract::<Vec<u8>>(py) { |
||||
Self::Bytes(Cursor::new(bytes)) |
||||
} else if let Ok(string) = data.extract::<String>(py) { |
||||
Self::Bytes(Cursor::new(string.into_bytes())) |
||||
} else { |
||||
Self::Io(BufReader::new(PyIo(data))) |
||||
} |
||||
} |
||||
} |
||||
|
||||
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), |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl BufRead for PyReadable { |
||||
fn fill_buf(&mut self) -> io::Result<&[u8]> { |
||||
match self { |
||||
Self::Bytes(bytes) => bytes.fill_buf(), |
||||
Self::Io(io) => io.fill_buf(), |
||||
Self::File(file) => file.fill_buf(), |
||||
} |
||||
} |
||||
|
||||
fn consume(&mut self, amt: usize) { |
||||
match self { |
||||
Self::Bytes(bytes) => bytes.consume(amt), |
||||
Self::Io(io) => io.consume(amt), |
||||
Self::File(file) => file.consume(amt), |
||||
} |
||||
} |
||||
} |
||||
|
||||
pub enum PyWritable { |
||||
Io(BufWriter<PyIo>), |
||||
File(BufWriter<File>), |
||||
} |
||||
|
||||
impl PyWritable { |
||||
pub fn from_file(file: &Path, py: Python<'_>) -> io::Result<Self> { |
||||
Ok(Self::File(BufWriter::new( |
||||
py.allow_threads(|| File::create(file))?, |
||||
))) |
||||
} |
||||
|
||||
pub fn from_data(data: PyObject) -> Self { |
||||
Self::Io(BufWriter::new(PyIo(data))) |
||||
} |
||||
} |
||||
|
||||
impl Write for PyWritable { |
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
||||
match self { |
||||
Self::Io(io) => io.write(buf), |
||||
Self::File(file) => file.write(buf), |
||||
} |
||||
} |
||||
|
||||
fn flush(&mut self) -> io::Result<()> { |
||||
match self { |
||||
Self::Io(io) => io.flush(), |
||||
Self::File(file) => file.flush(), |
||||
} |
||||
} |
||||
} |
||||
|
||||
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 |
||||
.as_ref(py) |
||||
.call_method1(intern!(py, "read"), (to_read,)) |
||||
.map_err(to_io_err)?; |
||||
let bytes = read |
||||
.extract::<&[u8]>() |
||||
.or_else(|e| read.extract::<&str>().map(str::as_bytes).map_err(|_| e)) |
||||
.map_err(to_io_err)?; |
||||
buf[..bytes.len()].copy_from_slice(bytes); |
||||
Ok(bytes.len()) |
||||
}) |
||||
} |
||||
} |
||||
|
||||
impl Write for PyIo { |
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> { |
||||
Python::with_gil(|py| { |
||||
self.0 |
||||
.as_ref(py) |
||||
.call_method1(intern!(py, "write"), (PyBytes::new(py, buf),)) |
||||
.map_err(to_io_err)? |
||||
.extract::<usize>() |
||||
.map_err(to_io_err) |
||||
}) |
||||
} |
||||
|
||||
fn flush(&mut self) -> io::Result<()> { |
||||
Python::with_gil(|py| { |
||||
self.0.as_ref(py).call_method0(intern!(py, "flush"))?; |
||||
Ok(()) |
||||
}) |
||||
} |
||||
} |
||||
|
||||
fn to_io_err(error: impl Into<PyErr>) -> io::Error { |
||||
io::Error::new(io::ErrorKind::Other, error.into()) |
||||
} |
||||
|
||||
pub fn map_io_err(error: io::Error) -> PyErr { |
||||
if error |
||||
.get_ref() |
||||
.map_or(false, <(dyn Error + Send + Sync + 'static)>::is::<PyErr>) |
||||
{ |
||||
*error.into_inner().unwrap().downcast().unwrap() |
||||
} else { |
||||
PyIOError::new_err(error.to_string()) |
||||
} |
||||
} |
||||
|
||||
pub fn map_parse_error(error: ParseError) -> PyErr { |
||||
match error { |
||||
ParseError::Syntax(error) => PySyntaxError::new_err(error.to_string()), |
||||
ParseError::Io(error) => map_io_err(error), |
||||
} |
||||
} |
||||
|
||||
/// 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>(f: impl FnOnce() -> T) -> T { |
||||
struct RestoreGuard { |
||||
tstate: *mut pyo3::ffi::PyThreadState, |
||||
} |
||||
|
||||
impl Drop for RestoreGuard { |
||||
fn drop(&mut self) { |
||||
unsafe { |
||||
pyo3::ffi::PyEval_RestoreThread(self.tstate); |
||||
} |
||||
} |
||||
} |
||||
|
||||
let _guard = RestoreGuard { |
||||
tstate: unsafe { pyo3::ffi::PyEval_SaveThread() }, |
||||
}; |
||||
f() |
||||
} |
||||
@ -1,30 +0,0 @@ |
||||
mod io; |
||||
mod model; |
||||
mod sparql; |
||||
mod store; |
||||
|
||||
use crate::model::*; |
||||
use crate::sparql::*; |
||||
use crate::store::*; |
||||
use pyo3::prelude::*; |
||||
|
||||
/// Oxigraph Python bindings
|
||||
#[pymodule] |
||||
fn pyoxigraph(_py: Python<'_>, module: &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::<PyStore>()?; |
||||
module.add_class::<PyVariable>()?; |
||||
module.add_class::<PyQuerySolutions>()?; |
||||
module.add_class::<PyQuerySolution>()?; |
||||
module.add_class::<PyQueryTriples>()?; |
||||
io::add_to_module(module) |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,241 +0,0 @@ |
||||
use crate::io::{allow_threads_unsafe, map_io_err, map_parse_error}; |
||||
use crate::map_storage_error; |
||||
use crate::model::*; |
||||
use oxigraph::model::Term; |
||||
use oxigraph::sparql::*; |
||||
use pyo3::basic::CompareOp; |
||||
use pyo3::exceptions::{ |
||||
PyNotImplementedError, PyRuntimeError, PySyntaxError, PyTypeError, PyValueError, |
||||
}; |
||||
|
||||
use pyo3::prelude::*; |
||||
use std::vec::IntoIter; |
||||
|
||||
pub fn parse_query( |
||||
query: &str, |
||||
base_iri: Option<&str>, |
||||
use_default_graph_as_union: bool, |
||||
default_graph: Option<&PyAny>, |
||||
named_graphs: Option<&PyAny>, |
||||
) -> PyResult<Query> { |
||||
let mut query = allow_threads_unsafe(|| 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 }.into_py(py), |
||||
QueryResults::Graph(inner) => PyQueryTriples { inner }.into_py(py), |
||||
QueryResults::Boolean(b) => b.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, unsendable, 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 __richcmp__(&self, other: &Self, op: CompareOp) -> PyResult<bool> { |
||||
match op { |
||||
CompareOp::Eq => Ok(self.inner == other.inner), |
||||
CompareOp::Ne => Ok(self.inner != other.inner), |
||||
_ => Err(PyNotImplementedError::new_err( |
||||
"Ordering is not implemented", |
||||
)), |
||||
} |
||||
} |
||||
|
||||
fn __len__(&self) -> usize { |
||||
self.inner.len() |
||||
} |
||||
|
||||
fn __getitem__(&self, input: &PyAny) -> PyResult<Option<PyTerm>> { |
||||
if let Ok(key) = usize::extract(input) { |
||||
Ok(self.inner.get(key).map(|term| PyTerm::from(term.clone()))) |
||||
} else if let Ok(key) = <&str>::extract(input) { |
||||
Ok(self.inner.get(key).map(|term| PyTerm::from(term.clone()))) |
||||
} else if let Ok(key) = input.extract::<PyRef<PyVariable>>() { |
||||
Ok(self |
||||
.inner |
||||
.get(<&Variable>::from(&*key)) |
||||
.map(|term| PyTerm::from(term.clone()))) |
||||
} else { |
||||
Err(PyTypeError::new_err(format!( |
||||
"{} is not an integer of a string", |
||||
input.get_type().name()?, |
||||
))) |
||||
} |
||||
} |
||||
|
||||
#[allow(clippy::unnecessary_to_owned)] |
||||
fn __iter__(&self) -> SolutionValueIter { |
||||
SolutionValueIter { |
||||
inner: self.inner.values().to_vec().into_iter(), |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[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: QuerySolutionIter, |
||||
} |
||||
|
||||
#[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> { |
||||
self.inner |
||||
.variables() |
||||
.iter() |
||||
.map(|v| v.clone().into()) |
||||
.collect() |
||||
} |
||||
|
||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<Self> { |
||||
slf |
||||
} |
||||
|
||||
fn __next__(&mut self) -> PyResult<Option<PyQuerySolution>> { |
||||
Ok(allow_threads_unsafe(|| self.inner.next()) |
||||
.transpose() |
||||
.map_err(map_evaluation_error)? |
||||
.map(move |inner| PyQuerySolution { 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 { |
||||
fn __iter__(slf: PyRef<'_, Self>) -> PyRef<Self> { |
||||
slf |
||||
} |
||||
|
||||
fn __next__(&mut self) -> PyResult<Option<PyTriple>> { |
||||
Ok(allow_threads_unsafe(|| self.inner.next()) |
||||
.transpose() |
||||
.map_err(map_evaluation_error)? |
||||
.map(Into::into)) |
||||
} |
||||
} |
||||
|
||||
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::Io(error) => map_io_err(error), |
||||
EvaluationError::GraphParsing(error) => map_parse_error(error), |
||||
EvaluationError::Query(error) => PyValueError::new_err(error.to_string()), |
||||
_ => PyRuntimeError::new_err(error.to_string()), |
||||
} |
||||
} |
||||
@ -1,907 +0,0 @@ |
||||
#![allow(clippy::needless_option_as_deref)] |
||||
|
||||
use crate::io::{allow_threads_unsafe, map_io_err, map_parse_error, PyReadable, PyWritable}; |
||||
use crate::model::*; |
||||
use crate::sparql::*; |
||||
use oxigraph::io::{DatasetFormat, GraphFormat}; |
||||
use oxigraph::model::{GraphName, GraphNameRef}; |
||||
use oxigraph::sparql::Update; |
||||
use oxigraph::store::{self, LoaderError, SerializerError, StorageError, Store}; |
||||
use pyo3::exceptions::{PyIOError, PyRuntimeError, PyValueError}; |
||||
use pyo3::prelude::*; |
||||
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 pathlib.Path or None, optional
|
||||
/// :raises IOError: if the target directory contains invalid data or could not be accessed.
|
||||
///
|
||||
/// The :py:func:`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 { |
||||
#[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)?, |
||||
}) |
||||
}) |
||||
} |
||||
|
||||
/// 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 IOError: if the target directory contains invalid data or could not be accessed.
|
||||
#[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 IOError: if the target directories contain invalid data or could not be accessed.
|
||||
#[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 IOError: if an I/O 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: iterable(Quad)
|
||||
/// :rtype: None
|
||||
/// :raises IOError: if an I/O 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: &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: iterable(Quad)
|
||||
/// :rtype: None
|
||||
/// :raises IOError: if an I/O 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>>]
|
||||
fn bulk_extend(&self, quads: &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 IOError: if an I/O 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: iterator(Quad)
|
||||
/// :raises IOError: if an I/O 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>>]
|
||||
#[pyo3(signature = (subject, predicate, object, graph_name = None))] |
||||
fn quads_for_pattern( |
||||
&self, |
||||
subject: &PyAny, |
||||
predicate: &PyAny, |
||||
object: &PyAny, |
||||
graph_name: Option<&PyAny>, |
||||
) -> PyResult<QuadIter> { |
||||
let (subject, predicate, object, graph_name) = |
||||
extract_quads_pattern(subject, predicate, object, graph_name)?; |
||||
Ok(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 QueryTriples or bool
|
||||
/// :raises SyntaxError: if the provided query is invalid.
|
||||
/// :raises IOError: if an I/O 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')))
|
||||
/// >>> 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<&PyAny>, |
||||
named_graphs: Option<&PyAny>, |
||||
py: Python<'_>, |
||||
) -> PyResult<PyObject> { |
||||
let query = parse_query( |
||||
query, |
||||
base_iri, |
||||
use_default_graph_as_union, |
||||
default_graph, |
||||
named_graphs, |
||||
)?; |
||||
let results = |
||||
allow_threads_unsafe(|| 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 IOError: if an I/O 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/>`_ (``application/n-triples``)
|
||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (``application/n-quads``)
|
||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (``text/turtle``)
|
||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (``application/trig``)
|
||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (``application/rdf+xml``)
|
||||
///
|
||||
/// It supports also some MIME type aliases.
|
||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
||||
/// and ``application/xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
||||
///
|
||||
/// :param input: The binary I/O object or file path to read from. For example, it could be a file path as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``.
|
||||
/// :type input: io(bytes) or io(str) or str or pathlib.Path
|
||||
/// :param mime_type: the MIME type of the RDF serialization.
|
||||
/// :type mime_type: str
|
||||
/// :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 MIME type is not supported or the `to_graph` parameter is given with a quad file.
|
||||
/// :raises SyntaxError: if the provided data is invalid.
|
||||
/// :raises IOError: if an I/O error happens during a quad insertion.
|
||||
///
|
||||
/// >>> store = Store()
|
||||
/// >>> store.load(io.BytesIO(b'<foo> <p> "1" .'), "text/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>>]
|
||||
#[pyo3(signature = (input, mime_type, *, base_iri = None, to_graph = None))] |
||||
fn load( |
||||
&self, |
||||
input: PyObject, |
||||
mime_type: &str, |
||||
base_iri: Option<&str>, |
||||
to_graph: Option<&PyAny>, |
||||
py: Python<'_>, |
||||
) -> PyResult<()> { |
||||
let to_graph_name = if let Some(graph_name) = to_graph { |
||||
Some(GraphName::from(&PyGraphNameRef::try_from(graph_name)?)) |
||||
} else { |
||||
None |
||||
}; |
||||
let input = if let Ok(path) = input.extract::<PathBuf>(py) { |
||||
PyReadable::from_file(&path, py).map_err(map_io_err)? |
||||
} else { |
||||
PyReadable::from_data(input, py) |
||||
}; |
||||
py.allow_threads(|| { |
||||
if let Some(graph_format) = GraphFormat::from_media_type(mime_type) { |
||||
self.inner |
||||
.load_graph( |
||||
input, |
||||
graph_format, |
||||
to_graph_name.as_ref().unwrap_or(&GraphName::DefaultGraph), |
||||
base_iri, |
||||
) |
||||
.map_err(map_loader_error) |
||||
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { |
||||
if to_graph_name.is_some() { |
||||
return Err(PyValueError::new_err( |
||||
"The target graph name parameter is not available for dataset formats", |
||||
)); |
||||
} |
||||
self.inner |
||||
.load_dataset(input, dataset_format, base_iri) |
||||
.map_err(map_loader_error) |
||||
} else { |
||||
Err(PyValueError::new_err(format!( |
||||
"Not supported MIME type: {mime_type}" |
||||
))) |
||||
} |
||||
}) |
||||
} |
||||
|
||||
/// 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/>`_ (``application/n-triples``)
|
||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (``application/n-quads``)
|
||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (``text/turtle``)
|
||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (``application/trig``)
|
||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (``application/rdf+xml``)
|
||||
///
|
||||
/// It supports also some MIME type aliases.
|
||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
||||
/// and ``application/xml`` for `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_.
|
||||
///
|
||||
/// :param input: The binary I/O object or file path to read from. For example, it could be a file path as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``.
|
||||
/// :type input: io(bytes) or io(str) or str or pathlib.Path
|
||||
/// :param mime_type: the MIME type of the RDF serialization.
|
||||
/// :type mime_type: str
|
||||
/// :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 MIME type is not supported or the `to_graph` parameter is given with a quad file.
|
||||
/// :raises SyntaxError: if the provided data is invalid.
|
||||
/// :raises IOError: if an I/O error happens during a quad insertion.
|
||||
///
|
||||
/// >>> store = Store()
|
||||
/// >>> store.bulk_load(io.BytesIO(b'<foo> <p> "1" .'), "text/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>>]
|
||||
#[pyo3(signature = (input, mime_type, *, base_iri = None, to_graph = None))] |
||||
fn bulk_load( |
||||
&self, |
||||
input: PyObject, |
||||
mime_type: &str, |
||||
base_iri: Option<&str>, |
||||
to_graph: Option<&PyAny>, |
||||
py: Python<'_>, |
||||
) -> PyResult<()> { |
||||
let to_graph_name = if let Some(graph_name) = to_graph { |
||||
Some(GraphName::from(&PyGraphNameRef::try_from(graph_name)?)) |
||||
} else { |
||||
None |
||||
}; |
||||
let input = if let Ok(path) = input.extract::<PathBuf>(py) { |
||||
PyReadable::from_file(&path, py).map_err(map_io_err)? |
||||
} else { |
||||
PyReadable::from_data(input, py) |
||||
}; |
||||
py.allow_threads(|| { |
||||
if let Some(graph_format) = GraphFormat::from_media_type(mime_type) { |
||||
self.inner |
||||
.bulk_loader() |
||||
.load_graph( |
||||
input, |
||||
graph_format, |
||||
&to_graph_name.unwrap_or(GraphName::DefaultGraph), |
||||
base_iri, |
||||
) |
||||
.map_err(map_loader_error) |
||||
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { |
||||
if to_graph_name.is_some() { |
||||
return Err(PyValueError::new_err( |
||||
"The target graph name parameter is not available for dataset formats", |
||||
)); |
||||
} |
||||
self.inner |
||||
.bulk_loader() |
||||
.load_dataset(input, dataset_format, base_iri) |
||||
.map_err(map_loader_error) |
||||
} else { |
||||
Err(PyValueError::new_err(format!( |
||||
"Not supported MIME type: {mime_type}" |
||||
))) |
||||
} |
||||
}) |
||||
} |
||||
|
||||
/// Dumps the store quads or triples into a file.
|
||||
///
|
||||
/// It currently supports the following formats:
|
||||
///
|
||||
/// * `N-Triples <https://www.w3.org/TR/n-triples/>`_ (``application/n-triples``)
|
||||
/// * `N-Quads <https://www.w3.org/TR/n-quads/>`_ (``application/n-quads``)
|
||||
/// * `Turtle <https://www.w3.org/TR/turtle/>`_ (``text/turtle``)
|
||||
/// * `TriG <https://www.w3.org/TR/trig/>`_ (``application/trig``)
|
||||
/// * `RDF/XML <https://www.w3.org/TR/rdf-syntax-grammar/>`_ (``application/rdf+xml``)
|
||||
///
|
||||
/// It supports also some MIME type aliases.
|
||||
/// For example, ``application/turtle`` could also be used for `Turtle <https://www.w3.org/TR/turtle/>`_
|
||||
/// and ``application/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')``.
|
||||
/// :type output: io(bytes) or str or pathlib.Path
|
||||
/// :param mime_type: the MIME type of the RDF serialization.
|
||||
/// :type mime_type: str
|
||||
/// :param from_graph: if a triple based format is requested, the store graph from which dump the triples. By default, the default graph is used.
|
||||
/// :type from_graph: NamedNode or BlankNode or DefaultGraph or None, optional
|
||||
/// :rtype: None
|
||||
/// :raises ValueError: if the MIME type is not supported or the `from_graph` parameter is given with a quad syntax.
|
||||
/// :raises IOError: if an I/O error happens during a quad lookup
|
||||
///
|
||||
/// >>> 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, "text/turtle", from_graph=NamedNode("http://example.com/g"))
|
||||
/// >>> output.getvalue()
|
||||
/// b'<http://example.com> <http://example.com/p> "1" .\n'
|
||||
#[pyo3(signature = (output, mime_type, *, from_graph = None))] |
||||
fn dump( |
||||
&self, |
||||
output: PyObject, |
||||
mime_type: &str, |
||||
from_graph: Option<&PyAny>, |
||||
py: Python<'_>, |
||||
) -> PyResult<()> { |
||||
let output = if let Ok(path) = output.extract::<PathBuf>(py) { |
||||
PyWritable::from_file(&path, py).map_err(map_io_err)? |
||||
} else { |
||||
PyWritable::from_data(output) |
||||
}; |
||||
let from_graph_name = if let Some(graph_name) = from_graph { |
||||
Some(GraphName::from(&PyGraphNameRef::try_from(graph_name)?)) |
||||
} else { |
||||
None |
||||
}; |
||||
py.allow_threads(|| { |
||||
if let Some(graph_format) = GraphFormat::from_media_type(mime_type) { |
||||
self.inner |
||||
.dump_graph( |
||||
output, |
||||
graph_format, |
||||
&from_graph_name.unwrap_or(GraphName::DefaultGraph), |
||||
) |
||||
.map_err(map_serializer_error) |
||||
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { |
||||
if from_graph_name.is_some() { |
||||
return Err(PyValueError::new_err( |
||||
"The target graph name parameter is not available for dataset formats", |
||||
)); |
||||
} |
||||
self.inner |
||||
.dump_dataset(output, dataset_format) |
||||
.map_err(map_serializer_error) |
||||
} else { |
||||
Err(PyValueError::new_err(format!( |
||||
"Not supported MIME type: {mime_type}" |
||||
))) |
||||
} |
||||
}) |
||||
} |
||||
|
||||
/// Returns an iterator over all the store named graphs.
|
||||
///
|
||||
/// :return: an iterator of the store graph names.
|
||||
/// :rtype: iterator(NamedNode or BlankNode)
|
||||
/// :raises IOError: if an I/O 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 IOError: if an I/O 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
|
||||
fn contains_named_graph(&self, graph_name: &PyAny) -> PyResult<bool> { |
||||
let graph_name = GraphName::from(&PyGraphNameRef::try_from(graph_name)?); |
||||
match graph_name { |
||||
GraphName::DefaultGraph => Ok(true), |
||||
GraphName::NamedNode(graph_name) => self.inner.contains_named_graph(&graph_name), |
||||
GraphName::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 IOError: if an I/O 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>]
|
||||
fn add_graph(&self, graph_name: &PyAny, py: Python<'_>) -> PyResult<()> { |
||||
let graph_name = GraphName::from(&PyGraphNameRef::try_from(graph_name)?); |
||||
py.allow_threads(|| { |
||||
match graph_name { |
||||
GraphName::DefaultGraph => Ok(()), |
||||
GraphName::NamedNode(graph_name) => { |
||||
self.inner.insert_named_graph(&graph_name).map(|_| ()) |
||||
} |
||||
GraphName::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 IOError: if an I/O 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>]
|
||||
fn clear_graph(&self, graph_name: &PyAny, py: Python<'_>) -> PyResult<()> { |
||||
let graph_name = GraphName::from(&PyGraphNameRef::try_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 IOError: if an I/O 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())
|
||||
/// []
|
||||
fn remove_graph(&self, graph_name: &PyAny, py: Python<'_>) -> PyResult<()> { |
||||
let graph_name = GraphName::from(&PyGraphNameRef::try_from(graph_name)?); |
||||
py.allow_threads(|| { |
||||
match graph_name { |
||||
GraphName::DefaultGraph => self.inner.clear_graph(GraphNameRef::DefaultGraph), |
||||
GraphName::NamedNode(graph_name) => { |
||||
self.inner.remove_named_graph(&graph_name).map(|_| ()) |
||||
} |
||||
GraphName::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 IOError: if an I/O 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 IOError: if an I/O error happens during the flush.
|
||||
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 IOError: if an I/O error happens during the optimization.
|
||||
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
|
||||
/// :rtype: None
|
||||
/// :raises IOError: if an I/O error happens during the backup.
|
||||
fn backup(&self, target_directory: &str, 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 extract_quads_pattern<'a>( |
||||
subject: &'a PyAny, |
||||
predicate: &'a PyAny, |
||||
object: &'a PyAny, |
||||
graph_name: Option<&'a PyAny>, |
||||
) -> PyResult<( |
||||
Option<PySubjectRef<'a>>, |
||||
Option<PyNamedNodeRef<'a>>, |
||||
Option<PyTermRef<'a>>, |
||||
Option<PyGraphNameRef<'a>>, |
||||
)> { |
||||
Ok(( |
||||
if subject.is_none() { |
||||
None |
||||
} else { |
||||
Some(TryFrom::try_from(subject)?) |
||||
}, |
||||
if predicate.is_none() { |
||||
None |
||||
} else { |
||||
Some(TryFrom::try_from(predicate)?) |
||||
}, |
||||
if object.is_none() { |
||||
None |
||||
} else { |
||||
Some(TryFrom::try_from(object)?) |
||||
}, |
||||
if let Some(graph_name) = graph_name { |
||||
if graph_name.is_none() { |
||||
None |
||||
} else { |
||||
Some(TryFrom::try_from(graph_name)?) |
||||
} |
||||
} else { |
||||
None |
||||
}, |
||||
)) |
||||
} |
||||
|
||||
pub fn map_storage_error(error: StorageError) -> PyErr { |
||||
match error { |
||||
StorageError::Io(error) => PyIOError::new_err(error.to_string()), |
||||
_ => PyRuntimeError::new_err(error.to_string()), |
||||
} |
||||
} |
||||
|
||||
pub fn map_loader_error(error: LoaderError) -> PyErr { |
||||
match error { |
||||
LoaderError::Storage(error) => map_storage_error(error), |
||||
LoaderError::Parsing(error) => map_parse_error(error), |
||||
} |
||||
} |
||||
|
||||
pub fn map_serializer_error(error: SerializerError) -> PyErr { |
||||
match error { |
||||
SerializerError::Storage(error) => map_storage_error(error), |
||||
SerializerError::Io(error) => PyIOError::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,114 +0,0 @@ |
||||
import unittest |
||||
from io import BytesIO, StringIO, UnsupportedOperation |
||||
from tempfile import NamedTemporaryFile, TemporaryFile |
||||
|
||||
from pyoxigraph import Literal, NamedNode, Quad, Triple, parse, serialize |
||||
|
||||
EXAMPLE_TRIPLE = Triple( |
||||
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() as fp: |
||||
fp.write('<foo> <p> "éù" .'.encode()) |
||||
fp.flush() |
||||
self.assertEqual( |
||||
list(parse(fp.name, "text/turtle", base_iri="http://example.com/")), |
||||
[EXAMPLE_TRIPLE], |
||||
) |
||||
|
||||
def test_parse_not_existing_file(self) -> None: |
||||
with self.assertRaises(IOError) as _: |
||||
parse("/tmp/not-existing-oxigraph-file.ttl", "text/turtle") |
||||
|
||||
def test_parse_str_io(self) -> None: |
||||
self.assertEqual( |
||||
list( |
||||
parse( |
||||
StringIO('<foo> <p> "éù" .'), |
||||
"text/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), |
||||
"text/turtle", |
||||
base_iri="http://example.com/", |
||||
) |
||||
), |
||||
[EXAMPLE_TRIPLE] * 1024, |
||||
) |
||||
|
||||
def test_parse_bytes_io(self) -> None: |
||||
self.assertEqual( |
||||
list( |
||||
parse( |
||||
BytesIO('<foo> <p> "éù" .'.encode()), |
||||
"text/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, mime_type="application/n-triples")) |
||||
|
||||
def test_parse_quad(self) -> None: |
||||
self.assertEqual( |
||||
list( |
||||
parse( |
||||
StringIO('<g> { <foo> <p> "1" }'), |
||||
"application/trig", |
||||
base_iri="http://example.com/", |
||||
) |
||||
), |
||||
[EXAMPLE_QUAD], |
||||
) |
||||
|
||||
|
||||
class TestSerialize(unittest.TestCase): |
||||
def test_serialize_to_bytes_io(self) -> None: |
||||
output = BytesIO() |
||||
serialize([EXAMPLE_TRIPLE], output, "text/turtle") |
||||
self.assertEqual( |
||||
output.getvalue().decode(), |
||||
'<http://example.com/foo> <http://example.com/p> "éù" .\n', |
||||
) |
||||
|
||||
def test_serialize_to_file(self) -> None: |
||||
with NamedTemporaryFile() as fp: |
||||
serialize([EXAMPLE_TRIPLE], fp.name, "text/turtle") |
||||
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, "text/turtle") |
||||
|
||||
def test_serialize_quad(self) -> None: |
||||
output = BytesIO() |
||||
serialize([EXAMPLE_QUAD], output, "application/trig") |
||||
self.assertEqual( |
||||
output.getvalue(), |
||||
b'<http://example.com/g> { <http://example.com/foo> <http://example.com/p> "1" }\n', |
||||
) |
||||
@ -1,380 +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,375 +0,0 @@ |
||||
import unittest |
||||
from io import BytesIO, UnsupportedOperation |
||||
from pathlib import Path |
||||
from tempfile import NamedTemporaryFile, TemporaryDirectory, TemporaryFile |
||||
from typing import Any |
||||
|
||||
from pyoxigraph import ( |
||||
BlankNode, |
||||
DefaultGraph, |
||||
NamedNode, |
||||
Quad, |
||||
QuerySolution, |
||||
QuerySolutions, |
||||
QueryTriples, |
||||
Store, |
||||
Triple, |
||||
Variable, |
||||
) |
||||
|
||||
foo = NamedNode("http://foo") |
||||
bar = NamedNode("http://bar") |
||||
baz = NamedNode("http://baz") |
||||
triple = Triple(foo, foo, foo) |
||||
graph = NamedNode("http://graph") |
||||
|
||||
|
||||
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) |
||||
|
||||
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_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) |
||||
|
||||
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( |
||||
BytesIO(b"<http://foo> <http://bar> <http://baz> ."), |
||||
mime_type="application/n-triples", |
||||
) |
||||
self.assertEqual(set(store), {Quad(foo, bar, baz, DefaultGraph())}) |
||||
|
||||
def test_load_ntriples_to_named_graph(self) -> None: |
||||
store = Store() |
||||
store.load( |
||||
BytesIO(b"<http://foo> <http://bar> <http://baz> ."), |
||||
mime_type="application/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> <> ."), |
||||
mime_type="text/turtle", |
||||
base_iri="http://baz", |
||||
) |
||||
self.assertEqual(set(store), {Quad(foo, bar, baz, DefaultGraph())}) |
||||
|
||||
def test_load_nquads(self) -> None: |
||||
store = Store() |
||||
store.load( |
||||
BytesIO(b"<http://foo> <http://bar> <http://baz> <http://graph>."), |
||||
mime_type="application/n-quads", |
||||
) |
||||
self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) |
||||
|
||||
def test_load_trig_with_base_iri(self) -> None: |
||||
store = Store() |
||||
store.load( |
||||
BytesIO(b"<http://graph> { <http://foo> <http://bar> <> . }"), |
||||
mime_type="application/trig", |
||||
base_iri="http://baz", |
||||
) |
||||
self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) |
||||
|
||||
def test_load_file(self) -> None: |
||||
with NamedTemporaryFile(delete=False) as fp: |
||||
file_name = Path(fp.name) |
||||
fp.write(b"<http://foo> <http://bar> <http://baz> <http://graph>.") |
||||
store = Store() |
||||
store.load(file_name, mime_type="application/n-quads") |
||||
file_name.unlink() |
||||
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, mime_type="application/n-triples") |
||||
|
||||
def test_dump_ntriples(self) -> None: |
||||
store = Store() |
||||
store.add(Quad(foo, bar, baz, graph)) |
||||
output = BytesIO() |
||||
store.dump(output, "application/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)) |
||||
output = BytesIO() |
||||
store.dump(output, "application/n-quads") |
||||
self.assertEqual( |
||||
output.getvalue(), |
||||
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, "application/trig") |
||||
self.assertEqual( |
||||
output.getvalue(), |
||||
b"<http://foo> <http://bar> <http://baz> .\n<http://graph> { <http://foo> <http://bar> <http://baz> }\n", |
||||
) |
||||
|
||||
def test_dump_file(self) -> None: |
||||
with NamedTemporaryFile(delete=False) as fp: |
||||
file_name = Path(fp.name) |
||||
store = Store() |
||||
store.add(Quad(foo, bar, baz, graph)) |
||||
store.dump(file_name, "application/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: |
||||
with self.assertRaises(OSError) as _, TemporaryFile("rb") as fp: |
||||
Store().dump(fp, mime_type="application/rdf+xml") |
||||
|
||||
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), []) |
||||
|
||||
def test_read_only(self) -> None: |
||||
quad = Quad(foo, bar, baz, graph) |
||||
with TemporaryDirectory() as dir: |
||||
store = Store(dir) |
||||
store.add(quad) |
||||
del store |
||||
store = Store.read_only(dir) |
||||
self.assertEqual(list(store), [quad]) |
||||
|
||||
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