"1" .', format=RdfFormat.TURTLE, base_iri="http://example.com/"))
-/// [ predicate= object=> graph_name=>]
-#[pyfunction]
-#[pyo3(signature = (input = None, format = None, *, path = None, base_iri = None, without_named_graphs = false, rename_blank_nodes = false))]
-pub fn parse(
- input: Option,
- format: Option,
- path: Option,
- base_iri: Option<&str>,
- without_named_graphs: bool,
- rename_blank_nodes: bool,
- py: Python<'_>,
-) -> PyResult {
- let input = PyReadable::from_args(&path, input, py)?;
- let format = lookup_rdf_format(format, path.as_deref())?;
- let mut parser = RdfParser::from_format(format);
- if let Some(base_iri) = base_iri {
- parser = parser
- .with_base_iri(base_iri)
- .map_err(|e| PyValueError::new_err(e.to_string()))?;
- }
- if without_named_graphs {
- parser = parser.without_named_graphs();
- }
- if rename_blank_nodes {
- parser = parser.rename_blank_nodes();
- }
- Ok(PyQuadReader {
- inner: parser.parse_read(input),
- file_path: path,
- }
- .into_py(py))
-}
-
-/// Serializes an RDF graph or dataset.
-///
-/// It currently supports the following formats:
-///
-/// * `canonical `_ `N-Triples `_ (:py:attr:`RdfFormat.N_TRIPLES`)
-/// * `N-Quads `_ (:py:attr:`RdfFormat.N_QUADS`)
-/// * `Turtle `_ (:py:attr:`RdfFormat.TURTLE`)
-/// * `TriG `_ (:py:attr:`RdfFormat.TRIG`)
-/// * `N3 `_ (:py:attr:`RdfFormat.N3`)
-/// * `RDF/XML `_ (:py:attr:`RdfFormat.RDF_XML`)
-///
-/// It supports also some media type and extension aliases.
-/// For example, ``application/turtle`` could also be used for `Turtle `_
-/// and ``application/xml`` or ``xml`` for `RDF/XML `_.
-///
-/// :param input: the RDF triples and quads to serialize.
-/// :type input: collections.abc.Iterable[Triple] or collections.abc.Iterable[Quad]
-/// :param output: The binary I/O object or file path to write to. For example, it could be a file path as a string or a file writer opened in binary mode with ``open('my_file.ttl', 'wb')``. If :py:const:`None`, a :py:class:`bytes` buffer is returned with the serialized content.
-/// :type output: typing.IO[bytes] or str or os.PathLike[str] or None, optional
-/// :param format: the format of the RDF serialization. If :py:const:`None`, the format is guessed from the file name extension.
-/// :type format: RdfFormat or None, optional
-/// :return: :py:class:`bytes` with the serialization if the ``output`` parameter is :py:const:`None`, :py:const:`None` if ``output`` is set.
-/// :rtype: bytes or None
-/// :raises ValueError: if the format is not supported.
-/// :raises TypeError: if a triple is given during a quad format serialization or reverse.
-/// :raises OSError: if a system error happens while writing the file.
-///
-/// >>> serialize([Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'))], format=RdfFormat.TURTLE)
-/// b' "1" .\n'
-///
-/// >>> import io
-/// >>> output = io.BytesIO()
-/// >>> serialize([Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'))], output, RdfFormat.TURTLE)
-/// >>> output.getvalue()
-/// b' "1" .\n'
-#[pyfunction]
-#[pyo3(signature = (input, output = None, format = None))]
-pub fn serialize<'py>(
- input: &Bound<'py, PyAny>,
- output: Option,
- format: Option,
- py: Python<'py>,
-) -> PyResult>> {
- PyWritable::do_write(
- |output, file_path| {
- let format = lookup_rdf_format(format, file_path.as_deref())?;
- let mut writer = RdfSerializer::from_format(format).serialize_to_write(output);
- for i in input.iter()? {
- let i = i?;
- if let Ok(triple) = i.extract::>() {
- writer.write_triple(&*triple)
- } else {
- let quad = i.extract::>()?;
- let quad = QuadRef::from(&*quad);
- if !quad.graph_name.is_default_graph() && !format.supports_datasets() {
- return Err(PyValueError::new_err(
- "The {format} format does not support named graphs",
- ));
- }
- writer.write_quad(quad)
- }?;
- }
- Ok(writer.finish()?)
- },
- output,
- py,
- )
-}
-
-#[pyclass(name = "QuadReader", module = "pyoxigraph")]
-pub struct PyQuadReader {
- inner: FromReadQuadReader,
- file_path: Option,
-}
-
-#[pymethods]
-impl PyQuadReader {
- fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- fn __next__(&mut self, py: Python<'_>) -> PyResult> {
- py.allow_threads(|| {
- Ok(self
- .inner
- .next()
- .transpose()
- .map_err(|e| map_parse_error(e, self.file_path.clone()))?
- .map(PyQuad::from))
- })
- }
-}
-
-/// RDF serialization formats.
-///
-/// The following formats are supported:
-///
-/// * `N-Triples `_ (:py:attr:`RdfFormat.N_TRIPLES`)
-/// * `N-Quads `_ (:py:attr:`RdfFormat.N_QUADS`)
-/// * `Turtle `_ (:py:attr:`RdfFormat.TURTLE`)
-/// * `TriG `_ (:py:attr:`RdfFormat.TRIG`)
-/// * `N3 `_ (:py:attr:`RdfFormat.N3`)
-/// * `RDF/XML `_ (:py:attr:`RdfFormat.RDF_XML`)
-///
-/// >>> RdfFormat.N3.media_type
-/// 'text/n3'
-#[pyclass(name = "RdfFormat", module = "pyoxigraph")]
-#[derive(Clone)]
-pub struct PyRdfFormat {
- inner: RdfFormat,
-}
-
-#[pymethods]
-impl PyRdfFormat {
- /// `N3 `_
- #[classattr]
- const N3: Self = Self {
- inner: RdfFormat::N3,
- };
- /// `N-Quads `_
- #[classattr]
- const N_QUADS: Self = Self {
- inner: RdfFormat::NQuads,
- };
- /// `N-Triples `_
- #[classattr]
- const N_TRIPLES: Self = Self {
- inner: RdfFormat::NTriples,
- };
- /// `RDF/XML `_
- #[classattr]
- const RDF_XML: Self = Self {
- inner: RdfFormat::RdfXml,
- };
- /// `TriG `_
- #[classattr]
- const TRIG: Self = Self {
- inner: RdfFormat::TriG,
- };
- /// `Turtle `_
- #[classattr]
- const TURTLE: Self = Self {
- inner: RdfFormat::Turtle,
- };
-
- /// :return: the format canonical IRI according to the `Unique URIs for file formats registry `_.
- /// :rtype: str
- ///
- /// >>> RdfFormat.N_TRIPLES.iri
- /// 'http://www.w3.org/ns/formats/N-Triples'
- #[getter]
- fn iri(&self) -> &'static str {
- self.inner.iri()
- }
-
- /// :return: the format `IANA media type `_.
- /// :rtype: str
- ///
- /// >>> RdfFormat.N_TRIPLES.media_type
- /// 'application/n-triples'
- #[getter]
- fn media_type(&self) -> &'static str {
- self.inner.media_type()
- }
-
- /// :return: the format `IANA-registered `_ file extension.
- /// :rtype: str
- ///
- /// >>> RdfFormat.N_TRIPLES.file_extension
- /// 'nt'
- #[getter]
- pub fn file_extension(&self) -> &'static str {
- self.inner.file_extension()
- }
-
- /// :return: the format name.
- /// :rtype: str
- ///
- /// >>> RdfFormat.N_TRIPLES.name
- /// 'N-Triples'
- #[getter]
- pub const fn name(&self) -> &'static str {
- self.inner.name()
- }
-
- /// :return: if the formats supports `RDF datasets `_ and not only `RDF graphs `_.
- /// :rtype: bool
- ///
- /// >>> RdfFormat.N_TRIPLES.supports_datasets
- /// False
- /// >>> RdfFormat.N_QUADS.supports_datasets
- /// True
- #[getter]
- pub fn supports_datasets(&self) -> bool {
- self.inner.supports_datasets()
- }
-
- /// :return: if the formats supports `RDF-star quoted triples `_.
- /// :rtype: bool
- ///
- /// >>> RdfFormat.N_TRIPLES.supports_rdf_star
- /// True
- /// >>> RdfFormat.RDF_XML.supports_rdf_star
- /// False
- #[getter]
- pub const fn supports_rdf_star(&self) -> bool {
- self.inner.supports_rdf_star()
- }
-
- /// Looks for a known format from a media type.
- ///
- /// It supports some media type aliases.
- /// For example, "application/xml" is going to return RDF/XML even if it is not its canonical media type.
- ///
- /// :param media_type: the media type.
- /// :type media_type: str
- /// :return: :py:class:`RdfFormat` if the media type is known or :py:const:`None` if not.
- /// :rtype: RdfFormat or None
- ///
- /// >>> RdfFormat.from_media_type("text/turtle; charset=utf-8")
- ///
- #[staticmethod]
- pub fn from_media_type(media_type: &str) -> Option {
- Some(Self {
- inner: RdfFormat::from_media_type(media_type)?,
- })
- }
-
- /// Looks for a known format from an extension.
- ///
- /// It supports some aliases.
- ///
- /// :param extension: the extension.
- /// :type extension: str
- /// :return: :py:class:`RdfFormat` if the extension is known or :py:const:`None` if not.
- /// :rtype: RdfFormat or None
- ///
- /// >>> RdfFormat.from_extension("nt")
- ///
- #[staticmethod]
- pub fn from_extension(extension: &str) -> Option {
- Some(Self {
- inner: RdfFormat::from_extension(extension)?,
- })
- }
-
- fn __str__(&self) -> &'static str {
- self.inner.name()
- }
-
- fn __repr__(&self) -> String {
- format!("", self.inner.name())
- }
-
- fn __hash__(&self) -> u64 {
- hash(&self.inner)
- }
-
- fn __eq__(&self, other: &Self) -> bool {
- self.inner == other.inner
- }
-
- fn __ne__(&self, other: &Self) -> bool {
- self.inner != other.inner
- }
-
- /// :rtype: RdfFormat
- fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- /// :type memo: typing.Any
- /// :rtype: RdfFormat
- #[allow(unused_variables)]
- fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> {
- slf
- }
-}
-
-pub enum PyReadable {
- Bytes(Cursor>),
- Io(PyIo),
- File(File),
-}
-
-impl PyReadable {
- pub fn from_args(
- path: &Option,
- input: Option,
- py: Python<'_>,
- ) -> PyResult {
- match (path, input) {
- (Some(_), Some(_)) => Err(PyValueError::new_err(
- "input and file_path can't be both set at the same time",
- )),
- (Some(path), None) => Ok(Self::File(py.allow_threads(|| File::open(path))?)),
- (None, Some(input)) => Ok(input.into()),
- (None, None) => Err(PyValueError::new_err(
- "Either input or file_path must be set",
- )),
- }
- }
-}
-
-impl Read for PyReadable {
- fn read(&mut self, buf: &mut [u8]) -> io::Result {
- match self {
- Self::Bytes(bytes) => bytes.read(buf),
- Self::Io(io) => io.read(buf),
- Self::File(file) => file.read(buf),
- }
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PyReadableInput {
- String(String),
- Bytes(Vec),
- Io(PyObject),
-}
-
-impl From for PyReadable {
- fn from(input: PyReadableInput) -> Self {
- match input {
- PyReadableInput::String(string) => Self::Bytes(Cursor::new(string.into_bytes())),
- PyReadableInput::Bytes(bytes) => Self::Bytes(Cursor::new(bytes)),
- PyReadableInput::Io(io) => Self::Io(PyIo(io)),
- }
- }
-}
-
-pub enum PyWritable {
- Bytes(Vec),
- Io(PyIo),
- File(File),
-}
-
-impl PyWritable {
- pub fn do_write(
- write: impl FnOnce(BufWriter, Option) -> PyResult>,
- output: Option,
- py: Python<'_>,
- ) -> PyResult>> {
- let (output, file_path) = match output {
- Some(PyWritableOutput::Path(file_path)) => (
- Self::File(py.allow_threads(|| File::create(&file_path))?),
- Some(file_path),
- ),
- Some(PyWritableOutput::Io(object)) => (Self::Io(PyIo(object)), None),
- None => (Self::Bytes(Vec::new()), None),
- };
- let writer = write(BufWriter::new(output), file_path)?;
- py.allow_threads(|| writer.into_inner())?.close(py)
- }
-
- fn close(self, py: Python<'_>) -> PyResult>> {
- match self {
- Self::Bytes(bytes) => Ok(Some(PyBytes::new_bound(py, &bytes))),
- Self::File(mut file) => {
- py.allow_threads(|| {
- file.flush()?;
- file.sync_all()
- })?;
- Ok(None)
- }
- Self::Io(mut io) => {
- py.allow_threads(|| io.flush())?;
- Ok(None)
- }
- }
- }
-}
-
-impl Write for PyWritable {
- fn write(&mut self, buf: &[u8]) -> io::Result {
- match self {
- Self::Bytes(bytes) => bytes.write(buf),
- Self::Io(io) => io.write(buf),
- Self::File(file) => file.write(buf),
- }
- }
-
- fn flush(&mut self) -> io::Result<()> {
- match self {
- Self::Bytes(_) => Ok(()),
- Self::Io(io) => io.flush(),
- Self::File(file) => file.flush(),
- }
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PyWritableOutput {
- Path(PathBuf),
- Io(PyObject),
-}
-
-pub struct PyIo(PyObject);
-
-impl Read for PyIo {
- fn read(&mut self, buf: &mut [u8]) -> io::Result {
- Python::with_gil(|py| {
- if buf.is_empty() {
- return Ok(0);
- }
- let to_read = max(1, buf.len() / 4); // We divide by 4 because TextIO works with number of characters and not with number of bytes
- let read = self
- .0
- .bind(py)
- .call_method1(intern!(py, "read"), (to_read,))?;
- Ok(if let Ok(bytes) = read.extract::<&[u8]>() {
- buf[..bytes.len()].copy_from_slice(bytes);
- bytes.len()
- } else {
- // TODO: Python 3.10+ use directly .extract<&str>
- let string = read.extract::>()?;
- let str = string.to_cow()?;
- buf[..str.len()].copy_from_slice(str.as_bytes());
- str.len()
- })
- })
- }
-}
-
-impl Write for PyIo {
- fn write(&mut self, buf: &[u8]) -> io::Result {
- Python::with_gil(|py| {
- Ok(self
- .0
- .bind(py)
- .call_method1(intern!(py, "write"), (PyBytes::new_bound(py, buf),))?
- .extract::()?)
- })
- }
-
- fn flush(&mut self) -> io::Result<()> {
- Python::with_gil(|py| {
- self.0.bind(py).call_method0(intern!(py, "flush"))?;
- Ok(())
- })
- }
-}
-
-pub fn lookup_rdf_format(
- format: Option,
- path: Option<&Path>,
-) -> PyResult {
- if let Some(format) = format {
- return match format {
- PyRdfFormatInput::Object(format) => Ok(format.inner),
- PyRdfFormatInput::MediaType(media_type) => {
- deprecation_warning("Using string to specify a RDF format is deprecated, please use a RdfFormat object instead.")?;
- RdfFormat::from_media_type(&media_type).ok_or_else(|| {
- PyValueError::new_err(format!(
- "The media type {media_type} is not supported by pyoxigraph"
- ))
- })
- }
- };
- }
- let Some(path) = path else {
- return Err(PyValueError::new_err(
- "The format parameter is required when a file path is not given",
- ));
- };
- let Some(ext) = path.extension().and_then(OsStr::to_str) else {
- return Err(PyValueError::new_err(format!(
- "The file name {} has no extension to guess a file format from",
- path.display()
- )));
- };
- RdfFormat::from_extension(ext)
- .ok_or_else(|| PyValueError::new_err(format!("Not supported RDF format extension: {ext}")))
-}
-
-#[derive(FromPyObject)]
-pub enum PyRdfFormatInput {
- Object(PyRdfFormat),
- MediaType(String),
-}
-
-pub fn map_parse_error(error: RdfParseError, file_path: Option) -> PyErr {
- match error {
- RdfParseError::Syntax(error) => {
- // Python 3.9 does not support end line and end column
- if python_version() >= (3, 10) {
- let params = if let Some(location) = error.location() {
- (
- file_path,
- Some(location.start.line + 1),
- Some(location.start.column + 1),
- None::>,
- Some(location.end.line + 1),
- Some(location.end.column + 1),
- )
- } else {
- (None, None, None, None, None, None)
- };
- PySyntaxError::new_err((error.to_string(), params))
- } else {
- let params = if let Some(location) = error.location() {
- (
- file_path,
- Some(location.start.line + 1),
- Some(location.start.column + 1),
- None::>,
- )
- } else {
- (None, None, None, None)
- };
- PySyntaxError::new_err((error.to_string(), params))
- }
- }
- RdfParseError::Io(error) => error.into(),
- }
-}
-
-/// Release the GIL
-/// There should not be ANY use of pyo3 code inside of this method!!!
-///
-/// Code from pyo3: https://github.com/PyO3/pyo3/blob/a67180c8a42a0bc0fdc45b651b62c0644130cf47/src/python.rs#L366
-#[allow(unsafe_code)]
-pub fn allow_threads_unsafe(_py: Python<'_>, f: impl FnOnce() -> T) -> T {
- struct RestoreGuard {
- tstate: *mut pyo3::ffi::PyThreadState,
- }
-
- impl Drop for RestoreGuard {
- fn drop(&mut self) {
- // SAFETY: not cloned so called once
- unsafe {
- pyo3::ffi::PyEval_RestoreThread(self.tstate);
- }
- }
- }
-
- // SAFETY: we have the restore part in Drop to make sure it's properly executed
- let tstate = unsafe { pyo3::ffi::PyEval_SaveThread() };
- let _guard = RestoreGuard { tstate };
- f()
-}
-
-pub fn python_version() -> (u8, u8) {
- static VERSION: OnceLock<(u8, u8)> = OnceLock::new();
- *VERSION.get_or_init(|| {
- Python::with_gil(|py| {
- let v = py.version_info();
- (v.major, v.minor)
- })
- })
-}
-
-pub fn deprecation_warning(message: &str) -> PyResult<()> {
- Python::with_gil(|py| {
- PyErr::warn_bound(py, &py.get_type_bound::(), message, 0)
- })
-}
diff --git a/python/src/lib.rs b/python/src/lib.rs
deleted file mode 100644
index 89e3d502..00000000
--- a/python/src/lib.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-#![allow(
- clippy::unused_self,
- clippy::trivially_copy_pass_by_ref,
- unused_qualifications
-)]
-
-mod dataset;
-mod io;
-mod model;
-mod sparql;
-mod store;
-
-use crate::dataset::*;
-use crate::io::*;
-use crate::model::*;
-use crate::sparql::*;
-use crate::store::*;
-use pyo3::prelude::*;
-
-/// Oxigraph Python bindings
-#[pymodule]
-fn pyoxigraph(_py: Python<'_>, module: &Bound<'_, PyModule>) -> PyResult<()> {
- module.add("__package__", "pyoxigraph")?;
- module.add("__version__", env!("CARGO_PKG_VERSION"))?;
- module.add("__author__", env!("CARGO_PKG_AUTHORS").replace(':', "\n"))?;
-
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_class::()?;
- module.add_wrapped(wrap_pyfunction!(parse))?;
- module.add_wrapped(wrap_pyfunction!(parse_query_results))?;
- module.add_wrapped(wrap_pyfunction!(serialize))?;
- Ok(())
-}
diff --git a/python/src/model.rs b/python/src/model.rs
deleted file mode 100644
index a930db2c..00000000
--- a/python/src/model.rs
+++ /dev/null
@@ -1,1281 +0,0 @@
-use oxigraph::model::*;
-use pyo3::basic::CompareOp;
-use pyo3::exceptions::{PyIndexError, PyNotImplementedError, PyTypeError, PyValueError};
-use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyTuple};
-use pyo3::PyTypeInfo;
-use std::collections::hash_map::DefaultHasher;
-use std::hash::{Hash, Hasher};
-use std::vec::IntoIter;
-
-/// An RDF `node identified by an IRI `_.
-///
-/// :param value: the IRI as a string.
-/// :type value: str
-/// :raises ValueError: if the IRI is not valid according to `RFC 3987 `_.
-///
-/// The :py:class:`str` function provides a serialization compatible with NTriples, Turtle, and SPARQL:
-///
-/// >>> str(NamedNode('http://example.com'))
-/// ''
-#[pyclass(frozen, name = "NamedNode", module = "pyoxigraph")]
-#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Hash)]
-pub struct PyNamedNode {
- inner: NamedNode,
-}
-
-impl From for PyNamedNode {
- fn from(inner: NamedNode) -> Self {
- Self { inner }
- }
-}
-
-impl From for NamedNode {
- fn from(node: PyNamedNode) -> Self {
- node.inner
- }
-}
-
-impl From for NamedOrBlankNode {
- fn from(node: PyNamedNode) -> Self {
- node.inner.into()
- }
-}
-
-impl From for Subject {
- fn from(node: PyNamedNode) -> Self {
- node.inner.into()
- }
-}
-
-impl From for Term {
- fn from(node: PyNamedNode) -> Self {
- node.inner.into()
- }
-}
-
-impl From for GraphName {
- fn from(node: PyNamedNode) -> Self {
- node.inner.into()
- }
-}
-
-#[pymethods]
-impl PyNamedNode {
- #[new]
- fn new(value: String) -> PyResult {
- Ok(NamedNode::new(value)
- .map_err(|e| PyValueError::new_err(e.to_string()))?
- .into())
- }
-
- /// :return: the named node IRI.
- /// :rtype: str
- ///
- /// >>> NamedNode("http://example.com").value
- /// 'http://example.com'
- #[getter]
- fn value(&self) -> &str {
- self.inner.as_str()
- }
-
- fn __str__(&self) -> String {
- self.inner.to_string()
- }
-
- fn __repr__(&self) -> String {
- let mut buffer = String::new();
- named_node_repr(self.inner.as_ref(), &mut buffer);
- buffer
- }
-
- fn __hash__(&self) -> u64 {
- hash(&self.inner)
- }
-
- fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult {
- if let Ok(other) = other.extract::>() {
- Ok(op.matches(self.cmp(&other)))
- } else if PyBlankNode::is_type_of_bound(other)
- || PyLiteral::is_type_of_bound(other)
- || PyDefaultGraph::is_type_of_bound(other)
- {
- eq_compare_other_type(op)
- } else {
- Err(PyTypeError::new_err(
- "NamedNode could only be compared with RDF terms",
- ))
- }
- }
-
- /// :rtype: typing.Any
- fn __getnewargs__(&self) -> (&str,) {
- (self.value(),)
- }
-
- /// :rtype: NamedNode
- fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- /// :type memo: typing.Any
- /// :rtype: NamedNode
- #[allow(unused_variables)]
- fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> {
- slf
- }
-
- #[classattr]
- fn __match_args__() -> (&'static str,) {
- ("value",)
- }
-}
-
-/// An RDF `blank node `_.
-///
-/// :param value: the `blank node identifier `_ (if not present, a random blank node identifier is automatically generated).
-/// :type value: str or None, optional
-/// :raises ValueError: if the blank node identifier is invalid according to NTriples, Turtle, and SPARQL grammars.
-///
-/// The :py:class:`str` function provides a serialization compatible with NTriples, Turtle, and SPARQL:
-///
-/// >>> str(BlankNode('ex'))
-/// '_:ex'
-#[pyclass(frozen, name = "BlankNode", module = "pyoxigraph")]
-#[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct PyBlankNode {
- inner: BlankNode,
-}
-
-impl From for PyBlankNode {
- fn from(inner: BlankNode) -> Self {
- Self { inner }
- }
-}
-
-impl From for BlankNode {
- fn from(node: PyBlankNode) -> Self {
- node.inner
- }
-}
-
-impl From for NamedOrBlankNode {
- fn from(node: PyBlankNode) -> Self {
- node.inner.into()
- }
-}
-
-impl From for Subject {
- fn from(node: PyBlankNode) -> Self {
- node.inner.into()
- }
-}
-
-impl From for Term {
- fn from(node: PyBlankNode) -> Self {
- node.inner.into()
- }
-}
-
-impl From for GraphName {
- fn from(node: PyBlankNode) -> Self {
- node.inner.into()
- }
-}
-
-#[pymethods]
-impl PyBlankNode {
- #[new]
- #[pyo3(signature = (value = None))]
- fn new(value: Option) -> PyResult {
- Ok(if let Some(value) = value {
- BlankNode::new(value).map_err(|e| PyValueError::new_err(e.to_string()))?
- } else {
- BlankNode::default()
- }
- .into())
- }
-
- /// :return: the `blank node identifier `_.
- /// :rtype: str
- ///
- /// >>> BlankNode("ex").value
- /// 'ex'
- #[getter]
- fn value(&self) -> &str {
- self.inner.as_str()
- }
-
- fn __str__(&self) -> String {
- self.inner.to_string()
- }
-
- fn __repr__(&self) -> String {
- let mut buffer = String::new();
- blank_node_repr(self.inner.as_ref(), &mut buffer);
- buffer
- }
-
- fn __hash__(&self) -> u64 {
- hash(&self.inner)
- }
-
- fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult {
- if let Ok(other) = other.extract::>() {
- eq_compare(self, &other, op)
- } else if PyNamedNode::is_type_of_bound(other)
- || PyLiteral::is_type_of_bound(other)
- || PyDefaultGraph::is_type_of_bound(other)
- {
- eq_compare_other_type(op)
- } else {
- Err(PyTypeError::new_err(
- "BlankNode could only be compared with RDF terms",
- ))
- }
- }
-
- /// :rtype: typing.Any
- fn __getnewargs__(&self) -> (&str,) {
- (self.value(),)
- }
-
- /// :rtype: BlankNode
- fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- /// :type memo: typing.Any
- /// :rtype: BlankNode
- #[allow(unused_variables)]
- fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> {
- slf
- }
-
- #[classattr]
- fn __match_args__() -> (&'static str,) {
- ("value",)
- }
-}
-
-/// An RDF `literal `_.
-///
-/// :param value: the literal value or `lexical form `_.
-/// :type value: str
-/// :param datatype: the literal `datatype IRI `_.
-/// :type datatype: NamedNode or None, optional
-/// :param language: the literal `language tag `_.
-/// :type language: str or None, optional
-/// :raises ValueError: if the language tag is not valid according to `RFC 5646 `_ (`BCP 47 `_).
-///
-/// The :py:class:`str` function provides a serialization compatible with NTriples, Turtle, and SPARQL:
-///
-/// >>> str(Literal('example'))
-/// '"example"'
-/// >>> str(Literal('example', language='en'))
-/// '"example"@en'
-/// >>> str(Literal('11', datatype=NamedNode('http://www.w3.org/2001/XMLSchema#integer')))
-/// '"11"^^'
-#[pyclass(frozen, name = "Literal", module = "pyoxigraph")]
-#[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct PyLiteral {
- inner: Literal,
-}
-
-impl From for PyLiteral {
- fn from(inner: Literal) -> Self {
- Self { inner }
- }
-}
-
-impl From for Literal {
- fn from(literal: PyLiteral) -> Self {
- literal.inner
- }
-}
-
-impl From for Term {
- fn from(node: PyLiteral) -> Self {
- node.inner.into()
- }
-}
-
-#[pymethods]
-impl PyLiteral {
- #[new]
- #[pyo3(signature = (value, *, datatype = None, language = None))]
- fn new(
- value: String,
- datatype: Option,
- language: Option,
- ) -> PyResult {
- Ok(if let Some(language) = language {
- if let Some(datatype) = datatype {
- if datatype.value() != "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString" {
- return Err(PyValueError::new_err(
- "The literals with a language tag must use the rdf:langString datatype",
- ));
- }
- }
- Literal::new_language_tagged_literal(value, language)
- .map_err(|e| PyValueError::new_err(e.to_string()))?
- } else if let Some(datatype) = datatype {
- Literal::new_typed_literal(value, datatype)
- } else {
- Literal::new_simple_literal(value)
- }
- .into())
- }
-
- /// :return: the literal value or `lexical form `_.
- /// :rtype: str
- ///
- /// >>> Literal("example").value
- /// 'example'
- #[getter]
- fn value(&self) -> &str {
- self.inner.value()
- }
-
- /// :return: the literal `language tag `_.
- /// :rtype: str or None
- ///
- /// >>> Literal('example', language='en').language
- /// 'en'
- /// >>> Literal('example').language
- #[getter]
- fn language(&self) -> Option<&str> {
- self.inner.language()
- }
-
- /// :return: the literal `datatype IRI `_.
- /// :rtype: NamedNode
- ///
- /// >>> Literal('11', datatype=NamedNode('http://www.w3.org/2001/XMLSchema#integer')).datatype
- ///
- /// >>> Literal('example').datatype
- ///
- /// >>> Literal('example', language='en').datatype
- ///
- #[getter]
- fn datatype(&self) -> PyNamedNode {
- self.inner.datatype().into_owned().into()
- }
-
- fn __str__(&self) -> String {
- self.inner.to_string()
- }
-
- fn __repr__(&self) -> String {
- let mut buffer = String::new();
- literal_repr(self.inner.as_ref(), &mut buffer);
- buffer
- }
-
- fn __hash__(&self) -> u64 {
- hash(&self.inner)
- }
-
- fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult {
- if let Ok(other) = other.extract::>() {
- eq_compare(self, &other, op)
- } else if PyNamedNode::is_type_of_bound(other)
- || PyBlankNode::is_type_of_bound(other)
- || PyDefaultGraph::is_type_of_bound(other)
- {
- eq_compare_other_type(op)
- } else {
- Err(PyTypeError::new_err(
- "Literal could only be compared with RDF terms",
- ))
- }
- }
-
- /// :rtype: typing.Any
- fn __getnewargs_ex__<'a, 'py>(
- &'a self,
- py: Python<'py>,
- ) -> PyResult<((&'a str,), Bound<'py, PyDict>)> {
- let kwargs = PyDict::new_bound(py);
- if let Some(language) = self.language() {
- kwargs.set_item("language", language)?;
- } else {
- kwargs.set_item("datatype", self.datatype().into_py(py))?;
- }
- Ok(((self.value(),), kwargs))
- }
-
- /// :rtype: Literal
- fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- /// :type memo: typing.Any
- /// :rtype: Literal
- #[allow(unused_variables)]
- fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> {
- slf
- }
-
- #[classattr]
- fn __match_args__() -> (&'static str,) {
- ("value",)
- }
-}
-
-/// The RDF `default graph name `_.
-#[pyclass(frozen, name = "DefaultGraph", module = "pyoxigraph")]
-#[derive(Eq, PartialEq, Debug, Clone, Copy, Hash)]
-pub struct PyDefaultGraph;
-
-impl From for GraphName {
- fn from(_: PyDefaultGraph) -> Self {
- Self::DefaultGraph
- }
-}
-
-#[pymethods]
-impl PyDefaultGraph {
- #[new]
- fn new() -> Self {
- Self {}
- }
-
- fn __str__(&self) -> &str {
- "DEFAULT"
- }
-
- fn __repr__(&self) -> &str {
- ""
- }
-
- fn __hash__(&self) -> u64 {
- 0
- }
-
- fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult {
- if let Ok(other) = other.extract::>() {
- eq_compare(self, &other, op)
- } else if PyNamedNode::is_type_of_bound(other)
- || PyBlankNode::is_type_of_bound(other)
- || PyLiteral::is_type_of_bound(other)
- {
- eq_compare_other_type(op)
- } else {
- Err(PyTypeError::new_err(
- "DefaultGraph could only be compared with RDF terms",
- ))
- }
- }
-
- /// :rtype: typing.Any
- fn __getnewargs__<'py>(&self, py: Python<'py>) -> Bound<'py, PyTuple> {
- PyTuple::empty_bound(py)
- }
-
- /// :rtype: DefaultGraph
- fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- /// :type memo: typing.Any
- /// :rtype: DefaultGraph
- #[allow(unused_variables)]
- fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> {
- slf
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PyNamedOrBlankNode {
- NamedNode(PyNamedNode),
- BlankNode(PyBlankNode),
-}
-
-impl From for NamedOrBlankNode {
- fn from(node: PyNamedOrBlankNode) -> Self {
- match node {
- PyNamedOrBlankNode::NamedNode(node) => node.into(),
- PyNamedOrBlankNode::BlankNode(node) => node.into(),
- }
- }
-}
-
-impl From for PyNamedOrBlankNode {
- fn from(node: NamedOrBlankNode) -> Self {
- match node {
- NamedOrBlankNode::NamedNode(node) => Self::NamedNode(node.into()),
- NamedOrBlankNode::BlankNode(node) => Self::BlankNode(node.into()),
- }
- }
-}
-
-impl IntoPy for PyNamedOrBlankNode {
- fn into_py(self, py: Python<'_>) -> PyObject {
- match self {
- Self::NamedNode(node) => node.into_py(py),
- Self::BlankNode(node) => node.into_py(py),
- }
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PySubject {
- NamedNode(PyNamedNode),
- BlankNode(PyBlankNode),
- Triple(PyTriple),
-}
-
-impl From for Subject {
- fn from(node: PySubject) -> Self {
- match node {
- PySubject::NamedNode(node) => node.into(),
- PySubject::BlankNode(node) => node.into(),
- PySubject::Triple(triple) => triple.into(),
- }
- }
-}
-
-impl From for PySubject {
- fn from(node: Subject) -> Self {
- match node {
- Subject::NamedNode(node) => Self::NamedNode(node.into()),
- Subject::BlankNode(node) => Self::BlankNode(node.into()),
- Subject::Triple(triple) => Self::Triple(triple.as_ref().clone().into()),
- }
- }
-}
-
-impl IntoPy for PySubject {
- fn into_py(self, py: Python<'_>) -> PyObject {
- match self {
- Self::NamedNode(node) => node.into_py(py),
- Self::BlankNode(node) => node.into_py(py),
- Self::Triple(triple) => triple.into_py(py),
- }
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PyTerm {
- NamedNode(PyNamedNode),
- BlankNode(PyBlankNode),
- Literal(PyLiteral),
- Triple(PyTriple),
-}
-
-impl From for Term {
- fn from(term: PyTerm) -> Self {
- match term {
- PyTerm::NamedNode(node) => node.into(),
- PyTerm::BlankNode(node) => node.into(),
- PyTerm::Literal(literal) => literal.into(),
- PyTerm::Triple(triple) => triple.into(),
- }
- }
-}
-
-impl From for PyTerm {
- fn from(term: Term) -> Self {
- match term {
- Term::NamedNode(node) => Self::NamedNode(node.into()),
- Term::BlankNode(node) => Self::BlankNode(node.into()),
- Term::Literal(literal) => Self::Literal(literal.into()),
- Term::Triple(triple) => Self::Triple(triple.as_ref().clone().into()),
- }
- }
-}
-
-impl IntoPy for PyTerm {
- fn into_py(self, py: Python<'_>) -> PyObject {
- match self {
- Self::NamedNode(node) => node.into_py(py),
- Self::BlankNode(node) => node.into_py(py),
- Self::Literal(literal) => literal.into_py(py),
- Self::Triple(triple) => triple.into_py(py),
- }
- }
-}
-
-/// An RDF `triple `_.
-///
-/// :param subject: the triple subject.
-/// :type subject: NamedNode or BlankNode or Triple
-/// :param predicate: the triple predicate.
-/// :type predicate: NamedNode
-/// :param object: the triple object.
-/// :type object: NamedNode or BlankNode or Literal or Triple
-///
-/// The :py:class:`str` function provides a serialization compatible with NTriples, Turtle, and SPARQL:
-///
-/// >>> str(Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
-/// ' "1"'
-///
-/// A triple could also be easily destructed into its components:
-///
-/// >>> (s, p, o) = Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'))
-#[pyclass(frozen, sequence, name = "Triple", module = "pyoxigraph")]
-#[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct PyTriple {
- inner: Triple,
-}
-
-impl From for PyTriple {
- fn from(inner: Triple) -> Self {
- Self { inner }
- }
-}
-
-impl From for Triple {
- fn from(triple: PyTriple) -> Self {
- triple.inner
- }
-}
-
-impl<'a> From<&'a PyTriple> for TripleRef<'a> {
- fn from(triple: &'a PyTriple) -> Self {
- triple.inner.as_ref()
- }
-}
-
-impl From for Subject {
- fn from(triple: PyTriple) -> Self {
- triple.inner.into()
- }
-}
-
-impl From for Term {
- fn from(triple: PyTriple) -> Self {
- triple.inner.into()
- }
-}
-
-#[pymethods]
-impl PyTriple {
- #[new]
- fn new(subject: PySubject, predicate: PyNamedNode, object: PyTerm) -> Self {
- Triple::new(subject, predicate, object).into()
- }
-
- /// :return: the triple subject.
- /// :rtype: NamedNode or BlankNode or Triple
- ///
- /// >>> Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')).subject
- ///
- #[getter]
- fn subject(&self) -> PySubject {
- self.inner.subject.clone().into()
- }
-
- /// :return: the triple predicate.
- /// :rtype: NamedNode
- ///
- /// >>> Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')).predicate
- ///
- #[getter]
- fn predicate(&self) -> PyNamedNode {
- self.inner.predicate.clone().into()
- }
-
- /// :return: the triple object.
- /// :rtype: NamedNode or BlankNode or Literal or Triple
- ///
- /// >>> Triple(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')).object
- /// >
- #[getter]
- fn object(&self) -> PyTerm {
- self.inner.object.clone().into()
- }
-
- fn __str__(&self) -> String {
- self.inner.to_string()
- }
-
- fn __repr__(&self) -> String {
- let mut buffer = String::new();
- triple_repr(self.inner.as_ref(), &mut buffer);
- buffer
- }
-
- fn __hash__(&self) -> u64 {
- hash(&self.inner)
- }
-
- fn __richcmp__(&self, other: &Self, op: CompareOp) -> PyResult {
- eq_compare(self, other, op)
- }
-
- fn __len__(&self) -> usize {
- 3
- }
-
- fn __getitem__(&self, input: usize) -> PyResult {
- match input {
- 0 => Ok(Term::from(self.inner.subject.clone()).into()),
- 1 => Ok(Term::from(self.inner.predicate.clone()).into()),
- 2 => Ok(self.inner.object.clone().into()),
- _ => Err(PyIndexError::new_err("A triple has only 3 elements")),
- }
- }
-
- fn __iter__(&self) -> TripleComponentsIter {
- TripleComponentsIter {
- inner: vec![
- self.inner.subject.clone().into(),
- self.inner.predicate.clone().into(),
- self.inner.object.clone(),
- ]
- .into_iter(),
- }
- }
-
- /// :rtype: typing.Any
- fn __getnewargs__(&self) -> (PySubject, PyNamedNode, PyTerm) {
- (self.subject(), self.predicate(), self.object())
- }
-
- /// :rtype: Triple
- fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- /// :type memo: typing.Any
- /// :rtype: Triple
- #[allow(unused_variables)]
- fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> {
- slf
- }
-
- #[classattr]
- fn __match_args__() -> (&'static str, &'static str, &'static str) {
- ("subject", "predicate", "object")
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PyGraphName {
- NamedNode(PyNamedNode),
- BlankNode(PyBlankNode),
- DefaultGraph(PyDefaultGraph),
-}
-
-impl From for GraphName {
- fn from(graph_name: PyGraphName) -> Self {
- match graph_name {
- PyGraphName::NamedNode(node) => node.into(),
- PyGraphName::BlankNode(node) => node.into(),
- PyGraphName::DefaultGraph(default_graph) => default_graph.into(),
- }
- }
-}
-
-impl From for PyGraphName {
- fn from(graph_name: GraphName) -> Self {
- match graph_name {
- GraphName::NamedNode(node) => Self::NamedNode(node.into()),
- GraphName::BlankNode(node) => Self::BlankNode(node.into()),
- GraphName::DefaultGraph => Self::DefaultGraph(PyDefaultGraph::new()),
- }
- }
-}
-
-impl IntoPy for PyGraphName {
- fn into_py(self, py: Python<'_>) -> PyObject {
- match self {
- Self::NamedNode(node) => node.into_py(py),
- Self::BlankNode(node) => node.into_py(py),
- Self::DefaultGraph(node) => node.into_py(py),
- }
- }
-}
-
-/// An RDF `triple `_.
-/// in a `RDF dataset `_.
-///
-/// :param subject: the quad subject.
-/// :type subject: NamedNode or BlankNode or Triple
-/// :param predicate: the quad predicate.
-/// :type predicate: NamedNode
-/// :param object: the quad object.
-/// :type object: NamedNode or BlankNode or Literal or Triple
-/// :param graph_name: the quad graph name. If not present, the default graph is assumed.
-/// :type graph_name: NamedNode or BlankNode or DefaultGraph or None, optional
-///
-/// The :py:class:`str` function provides a serialization compatible with NTriples, Turtle, and SPARQL:
-///
-/// >>> str(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')))
-/// ' "1" '
-///
-/// >>> str(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), DefaultGraph()))
-/// ' "1"'
-///
-/// A quad could also be easily destructed into its components:
-///
-/// >>> (s, p, o, g) = Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g'))
-#[pyclass(frozen, sequence, name = "Quad", module = "pyoxigraph")]
-#[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct PyQuad {
- inner: Quad,
-}
-
-impl From for PyQuad {
- fn from(inner: Quad) -> Self {
- Self { inner }
- }
-}
-
-impl From for Quad {
- fn from(node: PyQuad) -> Self {
- node.inner
- }
-}
-
-impl<'a> From<&'a PyQuad> for QuadRef<'a> {
- fn from(node: &'a PyQuad) -> Self {
- node.inner.as_ref()
- }
-}
-
-#[pymethods]
-impl PyQuad {
- #[new]
- #[pyo3(signature = (subject, predicate, object, graph_name = None))]
- fn new(
- subject: PySubject,
- predicate: PyNamedNode,
- object: PyTerm,
- graph_name: Option,
- ) -> Self {
- Quad::new(
- subject,
- predicate,
- object,
- graph_name.unwrap_or(PyGraphName::DefaultGraph(PyDefaultGraph {})),
- )
- .into()
- }
-
- /// :return: the quad subject.
- /// :rtype: NamedNode or BlankNode or Triple
- ///
- /// >>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).subject
- ///
- #[getter]
- fn subject(&self) -> PySubject {
- self.inner.subject.clone().into()
- }
-
- /// :return: the quad predicate.
- /// :rtype: NamedNode
- ///
- /// >>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).predicate
- ///
- #[getter]
- fn predicate(&self) -> PyNamedNode {
- self.inner.predicate.clone().into()
- }
-
- /// :return: the quad object.
- /// :rtype: NamedNode or BlankNode or Literal or Triple
- ///
- /// >>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).object
- /// >
- #[getter]
- fn object(&self) -> PyTerm {
- self.inner.object.clone().into()
- }
-
- /// :return: the quad graph name.
- /// :rtype: NamedNode or BlankNode or DefaultGraph
- ///
- /// >>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).graph_name
- ///
- #[getter]
- fn graph_name(&self) -> PyGraphName {
- self.inner.graph_name.clone().into()
- }
-
- /// :return: the quad underlying triple.
- /// :rtype: Triple
- ///
- /// >>> Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1'), NamedNode('http://example.com/g')).triple
- /// predicate= object=>>
- #[getter]
- fn triple(&self) -> PyTriple {
- Triple::from(self.inner.clone()).into()
- }
-
- fn __str__(&self) -> String {
- self.inner.to_string()
- }
-
- fn __repr__(&self) -> String {
- let mut buffer = String::new();
- buffer.push_str(" QuadComponentsIter {
- QuadComponentsIter {
- inner: vec![
- Some(self.inner.subject.clone().into()),
- Some(self.inner.predicate.clone().into()),
- Some(self.inner.object.clone()),
- match self.inner.graph_name.clone() {
- GraphName::NamedNode(node) => Some(node.into()),
- GraphName::BlankNode(node) => Some(node.into()),
- GraphName::DefaultGraph => None,
- },
- ]
- .into_iter(),
- }
- }
-
- /// :rtype: typing.Any
- fn __getnewargs__(&self) -> (PySubject, PyNamedNode, PyTerm, PyGraphName) {
- (
- self.subject(),
- self.predicate(),
- self.object(),
- self.graph_name(),
- )
- }
-
- /// :rtype: Quad
- fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- /// :type memo: typing.Any
- /// :rtype: Quad
- #[allow(unused_variables)]
- fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> {
- slf
- }
-
- #[classattr]
- fn __match_args__() -> (&'static str, &'static str, &'static str, &'static str) {
- ("subject", "predicate", "object", "graph_name")
- }
-}
-
-/// A SPARQL query variable.
-///
-/// :param value: the variable name as a string.
-/// :type value: str
-/// :raises ValueError: if the variable name is invalid according to the SPARQL grammar.
-///
-/// The :py:class:`str` function provides a serialization compatible with SPARQL:
-///
-/// >>> str(Variable('foo'))
-/// '?foo'
-#[pyclass(frozen, name = "Variable", module = "pyoxigraph")]
-#[derive(Eq, PartialEq, Debug, Clone, Hash)]
-pub struct PyVariable {
- inner: Variable,
-}
-
-impl From for PyVariable {
- fn from(inner: Variable) -> Self {
- Self { inner }
- }
-}
-
-impl From for Variable {
- fn from(variable: PyVariable) -> Self {
- variable.inner
- }
-}
-
-impl<'a> From<&'a PyVariable> for &'a Variable {
- fn from(variable: &'a PyVariable) -> Self {
- &variable.inner
- }
-}
-
-#[pymethods]
-impl PyVariable {
- #[new]
- fn new(value: String) -> PyResult {
- Ok(Variable::new(value)
- .map_err(|e| PyValueError::new_err(e.to_string()))?
- .into())
- }
-
- /// :return: the variable name.
- /// :rtype: str
- ///
- /// >>> Variable("foo").value
- /// 'foo'
- #[getter]
- fn value(&self) -> &str {
- self.inner.as_str()
- }
-
- fn __str__(&self) -> String {
- self.inner.to_string()
- }
-
- fn __repr__(&self) -> String {
- format!("", self.inner.as_str())
- }
-
- fn __hash__(&self) -> u64 {
- hash(&self.inner)
- }
-
- fn __richcmp__(&self, other: &Self, op: CompareOp) -> PyResult {
- eq_compare(self, other, op)
- }
-
- /// :rtype: typing.Any
- fn __getnewargs__(&self) -> (&str,) {
- (self.value(),)
- }
-
- /// :rtype: Variable
- fn __copy__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- /// :type memo: typing.Any
- /// :rtype: Variable
- #[allow(unused_variables)]
- fn __deepcopy__<'a>(slf: PyRef<'a, Self>, memo: &'_ Bound<'_, PyAny>) -> PyRef<'a, Self> {
- slf
- }
-
- #[classattr]
- fn __match_args__() -> (&'static str,) {
- ("value",)
- }
-}
-
-#[derive(FromPyObject)]
-pub struct PyNamedNodeRef<'a>(PyRef<'a, PyNamedNode>);
-
-impl<'a> From<&'a PyNamedNodeRef<'a>> for NamedNodeRef<'a> {
- fn from(value: &'a PyNamedNodeRef<'a>) -> Self {
- value.0.inner.as_ref()
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PyNamedOrBlankNodeRef<'a> {
- NamedNode(PyRef<'a, PyNamedNode>),
- BlankNode(PyRef<'a, PyBlankNode>),
-}
-
-impl<'a> From<&'a PyNamedOrBlankNodeRef<'a>> for NamedOrBlankNodeRef<'a> {
- fn from(value: &'a PyNamedOrBlankNodeRef<'a>) -> Self {
- match value {
- PyNamedOrBlankNodeRef::NamedNode(value) => value.inner.as_ref().into(),
- PyNamedOrBlankNodeRef::BlankNode(value) => value.inner.as_ref().into(),
- }
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PySubjectRef<'a> {
- NamedNode(PyRef<'a, PyNamedNode>),
- BlankNode(PyRef<'a, PyBlankNode>),
- Triple(PyRef<'a, PyTriple>),
-}
-
-impl<'a> From<&'a PySubjectRef<'a>> for SubjectRef<'a> {
- fn from(value: &'a PySubjectRef<'a>) -> Self {
- match value {
- PySubjectRef::NamedNode(value) => value.inner.as_ref().into(),
- PySubjectRef::BlankNode(value) => value.inner.as_ref().into(),
- PySubjectRef::Triple(value) => (&value.inner).into(),
- }
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PyTermRef<'a> {
- NamedNode(PyRef<'a, PyNamedNode>),
- BlankNode(PyRef<'a, PyBlankNode>),
- Literal(PyRef<'a, PyLiteral>),
- Triple(PyRef<'a, PyTriple>),
-}
-
-impl<'a> From<&'a PyTermRef<'a>> for TermRef<'a> {
- fn from(value: &'a PyTermRef<'a>) -> Self {
- match value {
- PyTermRef::NamedNode(value) => value.inner.as_ref().into(),
- PyTermRef::BlankNode(value) => value.inner.as_ref().into(),
- PyTermRef::Literal(value) => value.inner.as_ref().into(),
- PyTermRef::Triple(value) => (&value.inner).into(),
- }
- }
-}
-
-impl<'a> From<&'a PyTermRef<'a>> for Term {
- fn from(value: &'a PyTermRef<'a>) -> Self {
- TermRef::from(value).into()
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PyGraphNameRef<'a> {
- NamedNode(PyRef<'a, PyNamedNode>),
- BlankNode(PyRef<'a, PyBlankNode>),
- DefaultGraph(PyRef<'a, PyDefaultGraph>),
-}
-
-impl<'a> From<&'a PyGraphNameRef<'a>> for GraphNameRef<'a> {
- fn from(value: &'a PyGraphNameRef<'a>) -> Self {
- match value {
- PyGraphNameRef::NamedNode(value) => value.inner.as_ref().into(),
- PyGraphNameRef::BlankNode(value) => value.inner.as_ref().into(),
- PyGraphNameRef::DefaultGraph(_) => Self::DefaultGraph,
- }
- }
-}
-
-fn eq_compare(a: &T, b: &T, op: CompareOp) -> PyResult {
- match op {
- CompareOp::Eq => Ok(a == b),
- CompareOp::Ne => Ok(a != b),
- _ => Err(PyNotImplementedError::new_err(
- "Ordering is not implemented",
- )),
- }
-}
-
-fn eq_compare_other_type(op: CompareOp) -> PyResult {
- match op {
- CompareOp::Eq => Ok(false),
- CompareOp::Ne => Ok(true),
- _ => Err(PyNotImplementedError::new_err(
- "Ordering is not implemented",
- )),
- }
-}
-
-pub(crate) fn hash(t: &impl Hash) -> u64 {
- let mut s = DefaultHasher::new();
- t.hash(&mut s);
- s.finish()
-}
-
-fn named_node_repr(node: NamedNodeRef<'_>, buffer: &mut String) {
- buffer.push_str(""),
- }
-}
-
-fn triple_repr(triple: TripleRef<'_>, buffer: &mut String) {
- buffer.push_str(",
-}
-
-#[pymethods]
-impl TripleComponentsIter {
- fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- fn __next__(&mut self) -> Option {
- self.inner.next().map(PyTerm::from)
- }
-}
-
-#[pyclass(module = "pyoxigraph")]
-pub struct QuadComponentsIter {
- inner: IntoIter>,
-}
-
-#[pymethods]
-impl QuadComponentsIter {
- fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- fn __next__(&mut self, py: Python<'_>) -> Option {
- self.inner.next().map(move |t| {
- if let Some(t) = t {
- PyTerm::from(t).into_py(py)
- } else {
- PyDefaultGraph {}.into_py(py)
- }
- })
- }
-}
diff --git a/python/src/sparql.rs b/python/src/sparql.rs
deleted file mode 100644
index f2a40c85..00000000
--- a/python/src/sparql.rs
+++ /dev/null
@@ -1,740 +0,0 @@
-use crate::io::*;
-use crate::model::*;
-use crate::store::map_storage_error;
-use oxigraph::io::RdfSerializer;
-use oxigraph::model::Term;
-use oxigraph::sparql::results::{
- FromReadQueryResultsReader, FromReadSolutionsReader, QueryResultsFormat,
- QueryResultsParseError, QueryResultsParser, QueryResultsSerializer,
-};
-use oxigraph::sparql::{
- EvaluationError, Query, QueryResults, QuerySolution, QuerySolutionIter, QueryTripleIter,
- Variable,
-};
-use pyo3::basic::CompareOp;
-use pyo3::exceptions::{PyRuntimeError, PySyntaxError, PyValueError};
-use pyo3::prelude::*;
-use pyo3::types::{PyBytes, PyString};
-use std::ffi::OsStr;
-use std::io;
-use std::path::{Path, PathBuf};
-use std::vec::IntoIter;
-
-pub fn parse_query(
- query: &str,
- base_iri: Option<&str>,
- use_default_graph_as_union: bool,
- default_graph: Option<&Bound<'_, PyAny>>,
- named_graphs: Option<&Bound<'_, PyAny>>,
- py: Python<'_>,
-) -> PyResult {
- let mut query = allow_threads_unsafe(py, || Query::parse(query, base_iri))
- .map_err(|e| map_evaluation_error(e.into()))?;
-
- if use_default_graph_as_union && default_graph.is_some() {
- return Err(PyValueError::new_err(
- "The query() method use_default_graph_as_union and default_graph arguments should not be set at the same time",
- ));
- }
-
- if use_default_graph_as_union {
- query.dataset_mut().set_default_graph_as_union();
- }
-
- if let Some(default_graph) = default_graph {
- if let Ok(default_graphs) = default_graph.iter() {
- query.dataset_mut().set_default_graph(
- default_graphs
- .map(|graph| Ok(graph?.extract::()?.into()))
- .collect::>()?,
- )
- } else if let Ok(default_graph) = default_graph.extract::() {
- 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::()?.into()))
- .collect::>()?,
- )
- }
-
- Ok(query)
-}
-
-pub fn query_results_to_python(py: Python<'_>, results: QueryResults) -> PyObject {
- match results {
- QueryResults::Solutions(inner) => PyQuerySolutions {
- inner: PyQuerySolutionsVariant::Query(inner),
- }
- .into_py(py),
- QueryResults::Graph(inner) => PyQueryTriples { inner }.into_py(py),
- QueryResults::Boolean(inner) => PyQueryBoolean { inner }.into_py(py),
- }
-}
-
-/// Tuple associating variables and terms that are the result of a SPARQL ``SELECT`` query.
-///
-/// It is the equivalent of a row in SQL.
-///
-/// It could be indexes by variable name (:py:class:`Variable` or :py:class:`str`) or position in the tuple (:py:class:`int`).
-/// Unpacking also works.
-///
-/// >>> store = Store()
-/// >>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
-/// >>> solution = next(store.query('SELECT ?s ?p ?o WHERE { ?s ?p ?o }'))
-/// >>> solution[Variable('s')]
-///
-/// >>> solution['s']
-///
-/// >>> solution[0]
-///
-/// >>> s, p, o = solution
-/// >>> s
-///
-#[pyclass(frozen, name = "QuerySolution", module = "pyoxigraph")]
-pub struct PyQuerySolution {
- inner: QuerySolution,
-}
-
-#[pymethods]
-impl PyQuerySolution {
- fn __repr__(&self) -> String {
- let mut buffer = String::new();
- buffer.push_str("');
- buffer
- }
-
- fn __eq__(&self, other: &Self) -> bool {
- self.inner == other.inner
- }
-
- fn __ne__(&self, other: &Self) -> bool {
- self.inner != other.inner
- }
-
- fn __len__(&self) -> usize {
- self.inner.len()
- }
-
- fn __getitem__(&self, key: PySolutionKey<'_>) -> PyResult> {
- Ok(match key {
- PySolutionKey::Usize(key) => self.inner.get(key),
- PySolutionKey::Str(key) => self.inner.get(key.to_cow()?.as_ref()),
- PySolutionKey::Variable(key) => self.inner.get(<&Variable>::from(&*key)),
- }
- .map(|term| PyTerm::from(term.clone())))
- }
-
- #[allow(clippy::unnecessary_to_owned)]
- fn __iter__(&self) -> SolutionValueIter {
- SolutionValueIter {
- inner: self.inner.values().to_vec().into_iter(),
- }
- }
-}
-
-#[derive(FromPyObject)]
-pub enum PySolutionKey<'a> {
- Usize(usize),
- Str(Bound<'a, PyString>), // TODO: Python 3.10+: use &str
- Variable(PyRef<'a, PyVariable>),
-}
-
-#[pyclass(module = "pyoxigraph")]
-pub struct SolutionValueIter {
- inner: IntoIter>,
-}
-
-#[pymethods]
-impl SolutionValueIter {
- fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- fn __next__(&mut self) -> Option> {
- 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 }'))
-/// [>]
-#[pyclass(unsendable, name = "QuerySolutions", module = "pyoxigraph")]
-pub struct PyQuerySolutions {
- inner: PyQuerySolutionsVariant,
-}
-enum PyQuerySolutionsVariant {
- Query(QuerySolutionIter),
- Reader {
- iter: FromReadSolutionsReader,
- file_path: Option,
- },
-}
-
-#[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
- /// []
- #[getter]
- fn variables(&self) -> Vec {
- match &self.inner {
- PyQuerySolutionsVariant::Query(inner) => {
- inner.variables().iter().map(|v| v.clone().into()).collect()
- }
- PyQuerySolutionsVariant::Reader { iter, .. } => {
- iter.variables().iter().map(|v| v.clone().into()).collect()
- }
- }
- }
-
- /// Writes the query results into a file.
- ///
- /// It currently supports the following formats:
- ///
- /// * `XML `_ (:py:attr:`QueryResultsFormat.XML`)
- /// * `JSON `_ (:py:attr:`QueryResultsFormat.JSON`)
- /// * `CSV `_ (:py:attr:`QueryResultsFormat.CSV`)
- /// * `TSV `_ (:py:attr:`QueryResultsFormat.TSV`)
- ///
- /// It supports also some media type and extension aliases.
- /// For example, ``application/json`` could also be used for `JSON `_.
- ///
- /// :param output: The binary I/O object or file path to write to. For example, it could be a file path as a string or a file writer opened in binary mode with ``open('my_file.ttl', 'wb')``. If :py:const:`None`, a :py:class:`bytes` buffer is returned with the serialized content.
- /// :type output: typing.IO[bytes] or str or os.PathLike[str] or None, optional
- /// :param format: the format of the query results serialization. If :py:const:`None`, the format is guessed from the file name extension.
- /// :type format: QueryResultsFormat or None, optional
- /// :rtype: bytes or None
- /// :raises ValueError: if the format is not supported.
- /// :raises OSError: if a system error happens while writing the file.
- ///
- /// >>> store = Store()
- /// >>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
- /// >>> results = store.query("SELECT ?s ?p ?o WHERE { ?s ?p ?o }")
- /// >>> results.serialize(format=QueryResultsFormat.JSON)
- /// b'{"head":{"vars":["s","p","o"]},"results":{"bindings":[{"s":{"type":"uri","value":"http://example.com"},"p":{"type":"uri","value":"http://example.com/p"},"o":{"type":"literal","value":"1"}}]}}'
- #[pyo3(signature = (output = None, format = None))]
- fn serialize<'py>(
- &mut self,
- output: Option,
- format: Option,
- py: Python<'py>,
- ) -> PyResult>> {
- PyWritable::do_write(
- |output, file_path| {
- let format = lookup_query_results_format(format, file_path.as_deref())?;
- let mut writer = QueryResultsSerializer::from_format(format)
- .serialize_solutions_to_write(
- output,
- match &self.inner {
- PyQuerySolutionsVariant::Query(inner) => inner.variables().to_vec(),
- PyQuerySolutionsVariant::Reader { iter, .. } => {
- iter.variables().to_vec()
- }
- },
- )?;
- match &mut self.inner {
- PyQuerySolutionsVariant::Query(inner) => {
- for solution in inner {
- writer.write(&solution.map_err(map_evaluation_error)?)?;
- }
- }
- PyQuerySolutionsVariant::Reader { iter, file_path } => {
- for solution in iter {
- writer.write(&solution.map_err(|e| {
- map_query_results_parse_error(e, file_path.clone())
- })?)?;
- }
- }
- }
-
- Ok(writer.finish()?)
- },
- output,
- py,
- )
- }
-
- fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
- slf
- }
-
- fn __next__(&mut self, py: Python<'_>) -> PyResult> {
- Ok(match &mut self.inner {
- PyQuerySolutionsVariant::Query(inner) => allow_threads_unsafe(py, || {
- inner.next().transpose().map_err(map_evaluation_error)
- }),
- PyQuerySolutionsVariant::Reader { iter, file_path } => iter
- .next()
- .transpose()
- .map_err(|e| map_query_results_parse_error(e, file_path.clone())),
- }?
- .map(move |inner| PyQuerySolution { inner }))
- }
-}
-
-/// A boolean returned by a SPARQL ``ASK`` query.
-///
-/// It can be easily casted to a regular boolean using the :py:func:`bool` function.
-///
-/// >>> store = Store()
-/// >>> store.add(Quad(NamedNode('http://example.com'), NamedNode('http://example.com/p'), Literal('1')))
-/// >>> bool(store.query('ASK { ?s ?p ?o }'))
-/// True
-#[pyclass(unsendable, name = "QueryBoolean", module = "pyoxigraph")]
-pub struct PyQueryBoolean {
- inner: bool,
-}
-
-#[pymethods]
-impl PyQueryBoolean {
- /// Writes the query results into a file.
- ///
- /// It currently supports the following formats:
- ///
- /// * `XML