NextGraph
/
oxigraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Migrates pyo3 to 0.12

Browse Source
pull/60/head
Tpt 4 years ago
parent 56bdf21c4c
commit 55f1152f35
7 changed files with 122 additions and 84 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      python/Cargo.toml
  2. 14
      python/src/io.rs
  3. 14
      python/src/memory_store.rs
  4. 129
      python/src/model.rs
  5. 12
      python/src/sled_store.rs
  6. 27
      python/src/sparql.rs
  7. 8
      python/src/store_utils.rs

2
python/Cargo.toml
Unescape View File

@ -16,7 +16,7 @@ doctest = false
[dependencies] [dependencies]
oxigraph = {version = "0.1.1", path="../lib", features = ["sled", "http_client"]} oxigraph = {version = "0.1.1", path="../lib", features = ["sled", "http_client"]}
pyo3 = {version = "0.11", features = ["extension-module"]} pyo3 = {version = "0.12", features = ["extension-module"]}
[package.metadata.maturin] [package.metadata.maturin]
classifier = [ classifier = [

14
python/src/io.rs
Unescape View File

@ -4,7 +4,7 @@ use oxigraph::io::read::{QuadReader, TripleReader};
use oxigraph::io::{ use oxigraph::io::{
DatasetFormat, DatasetParser, DatasetSerializer, GraphFormat, GraphParser, GraphSerializer, DatasetFormat, DatasetParser, DatasetSerializer, GraphFormat, GraphParser, GraphSerializer,
}; };
use pyo3::exceptions::ValueError; use pyo3::exceptions::PyValueError;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::types::PyBytes; use pyo3::types::PyBytes;
use pyo3::wrap_pyfunction; use pyo3::wrap_pyfunction;
@ -59,7 +59,7 @@ pub fn parse(
if let Some(base_iri) = base_iri { if let Some(base_iri) = base_iri {
parser = parser parser = parser
.with_base_iri(base_iri) .with_base_iri(base_iri)
.map_err(|e| ValueError::py_err(e.to_string()))?; .map_err(|e| PyValueError::new_err(e.to_string()))?;
} }
Ok(PyTripleReader { Ok(PyTripleReader {
inner: parser.read_triples(input).map_err(map_io_err)?, inner: parser.read_triples(input).map_err(map_io_err)?,
@ -70,14 +70,14 @@ pub fn parse(
if let Some(base_iri) = base_iri { if let Some(base_iri) = base_iri {
parser = parser parser = parser
.with_base_iri(base_iri) .with_base_iri(base_iri)
.map_err(|e| ValueError::py_err(e.to_string()))?; .map_err(|e| PyValueError::new_err(e.to_string()))?;
} }
Ok(PyQuadReader { Ok(PyQuadReader {
inner: parser.read_quads(input).map_err(map_io_err)?, inner: parser.read_quads(input).map_err(map_io_err)?,
} }
.into_py(py)) .into_py(py))
} else { } else {
Err(ValueError::py_err(format!( Err(PyValueError::new_err(format!(
"Not supported MIME type: {}", "Not supported MIME type: {}",
mime_type mime_type
))) )))
@ -138,14 +138,14 @@ pub fn serialize(input: &PyAny, output: &PyAny, mime_type: &str, py: Python<'_>)
writer.finish().map_err(map_io_err)?; writer.finish().map_err(map_io_err)?;
Ok(()) Ok(())
} else { } else {
Err(ValueError::py_err(format!( Err(PyValueError::new_err(format!(
"Not supported MIME type: {}", "Not supported MIME type: {}",
mime_type mime_type
))) )))
} }
} }
#[pyclass(unsendable, name= TripleReader)] #[pyclass(name = TripleReader)]
pub struct PyTripleReader { pub struct PyTripleReader {
inner: TripleReader<BufReader<PyFileLike>>, inner: TripleReader<BufReader<PyFileLike>>,
} }
@ -164,7 +164,7 @@ impl PyIterProtocol for PyTripleReader {
} }
} }
#[pyclass(unsendable, name= QuadReader)] #[pyclass(name = QuadReader)]
pub struct PyQuadReader { pub struct PyQuadReader {
inner: QuadReader<BufReader<PyFileLike>>, inner: QuadReader<BufReader<PyFileLike>>,
} }

14
python/src/memory_store.rs
Unescape View File

@ -5,7 +5,7 @@ use crate::store_utils::*;
use oxigraph::io::{DatasetFormat, GraphFormat}; use oxigraph::io::{DatasetFormat, GraphFormat};
use oxigraph::store::memory::*; use oxigraph::store::memory::*;
use pyo3::basic::CompareOp; use pyo3::basic::CompareOp;
use pyo3::exceptions::{NotImplementedError, ValueError}; use pyo3::exceptions::{PyNotImplementedError, PyValueError};
use pyo3::prelude::{ use pyo3::prelude::{
pyclass, pymethods, pyproto, Py, PyAny, PyCell, PyObject, PyRef, PyRefMut, PyResult, Python, pyclass, pymethods, pyproto, Py, PyAny, PyCell, PyObject, PyRef, PyRefMut, PyResult, Python,
ToPyObject, ToPyObject,
@ -257,7 +257,7 @@ impl PyMemoryStore {
.map_err(map_io_err) .map_err(map_io_err)
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { } else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) {
if to_graph_name.is_some() { if to_graph_name.is_some() {
return Err(ValueError::py_err( return Err(PyValueError::new_err(
"The target graph name parameter is not available for dataset formats", "The target graph name parameter is not available for dataset formats",
)); ));
} }
@ -265,7 +265,7 @@ impl PyMemoryStore {
.load_dataset(input, dataset_format, base_iri) .load_dataset(input, dataset_format, base_iri)
.map_err(map_io_err) .map_err(map_io_err)
} else { } else {
Err(ValueError::py_err(format!( Err(PyValueError::new_err(format!(
"Not supported MIME type: {}", "Not supported MIME type: {}",
mime_type mime_type
))) )))
@ -325,7 +325,7 @@ impl PyMemoryStore {
.map_err(map_io_err) .map_err(map_io_err)
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { } else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) {
if from_graph_name.is_some() { if from_graph_name.is_some() {
return Err(ValueError::py_err( return Err(PyValueError::new_err(
"The target graph name parameter is not available for dataset formats", "The target graph name parameter is not available for dataset formats",
)); ));
} }
@ -333,7 +333,7 @@ impl PyMemoryStore {
.dump_dataset(output, dataset_format) .dump_dataset(output, dataset_format)
.map_err(map_io_err) .map_err(map_io_err)
} else { } else {
Err(ValueError::py_err(format!( Err(PyValueError::new_err(format!(
"Not supported MIME type: {}", "Not supported MIME type: {}",
mime_type mime_type
))) )))
@ -352,7 +352,9 @@ impl PyObjectProtocol for PyMemoryStore {
match op { match op {
CompareOp::Eq => Ok(self == other), CompareOp::Eq => Ok(self == other),
CompareOp::Ne => Ok(self != other), CompareOp::Ne => Ok(self != other),
_ => Err(NotImplementedError::py_err("Ordering is not implemented")), _ => Err(PyNotImplementedError::new_err(
"Ordering is not implemented",
)),
} }
} }

129
python/src/model.rs
Unescape View File

@ -1,7 +1,7 @@
use oxigraph::model::*; use oxigraph::model::*;
use oxigraph::sparql::Variable; use oxigraph::sparql::Variable;
use pyo3::basic::CompareOp; use pyo3::basic::CompareOp;
use pyo3::exceptions::{IndexError, NotImplementedError, TypeError, ValueError}; use pyo3::exceptions::{PyIndexError, PyNotImplementedError, PyTypeError, PyValueError};
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::{PyIterProtocol, PyMappingProtocol, PyObjectProtocol, PyTypeInfo}; use pyo3::{PyIterProtocol, PyMappingProtocol, PyObjectProtocol, PyTypeInfo};
use std::collections::hash_map::DefaultHasher; use std::collections::hash_map::DefaultHasher;
@ -62,7 +62,7 @@ impl PyNamedNode {
#[new] #[new]
fn new(value: String) -> PyResult<Self> { fn new(value: String) -> PyResult<Self> {
Ok(NamedNode::new(value) Ok(NamedNode::new(value)
.map_err(|e| ValueError::py_err(e.to_string()))? .map_err(|e| PyValueError::new_err(e.to_string()))?
.into()) .into())
} }
@ -102,7 +102,7 @@ impl PyObjectProtocol for PyNamedNode {
{ {
eq_compare_other_type(op) eq_compare_other_type(op)
} else { } else {
Err(TypeError::py_err( Err(PyTypeError::new_err(
"NamedNode could only be compared with RDF terms", "NamedNode could only be compared with RDF terms",
)) ))
} }
@ -161,7 +161,7 @@ impl PyBlankNode {
#[new] #[new]
fn new(value: Option<String>) -> PyResult<Self> { fn new(value: Option<String>) -> PyResult<Self> {
Ok(if let Some(value) = value { Ok(if let Some(value) = value {
BlankNode::new(value).map_err(|e| ValueError::py_err(e.to_string()))? BlankNode::new(value).map_err(|e| PyValueError::new_err(e.to_string()))?
} else { } else {
BlankNode::default() BlankNode::default()
} }
@ -204,7 +204,7 @@ impl PyObjectProtocol for PyBlankNode {
{ {
eq_compare_other_type(op) eq_compare_other_type(op)
} else { } else {
Err(TypeError::py_err( Err(PyTypeError::new_err(
"BlankNode could only be compared with RDF terms", "BlankNode could only be compared with RDF terms",
)) ))
} }
@ -266,13 +266,13 @@ impl PyLiteral {
Ok(if let Some(language) = language { Ok(if let Some(language) = language {
if let Some(datatype) = datatype { if let Some(datatype) = datatype {
if datatype.value() != "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString" { if datatype.value() != "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString" {
return Err(ValueError::py_err( return Err(PyValueError::new_err(
"The literals with a language tag must use the rdf:langString datatype", "The literals with a language tag must use the rdf:langString datatype",
)); ));
} }
} }
Literal::new_language_tagged_literal(value, language) Literal::new_language_tagged_literal(value, language)
.map_err(|e| ValueError::py_err(e.to_string()))? .map_err(|e| PyValueError::new_err(e.to_string()))?
} else if let Some(datatype) = datatype { } else if let Some(datatype) = datatype {
Literal::new_typed_literal(value, datatype) Literal::new_typed_literal(value, datatype)
} else { } else {
@ -343,7 +343,7 @@ impl PyObjectProtocol for PyLiteral {
{ {
eq_compare_other_type(op) eq_compare_other_type(op)
} else { } else {
Err(TypeError::py_err( Err(PyTypeError::new_err(
"Literal could only be compared with RDF terms", "Literal could only be compared with RDF terms",
)) ))
} }
@ -397,13 +397,45 @@ impl PyObjectProtocol for PyDefaultGraph {
{ {
eq_compare_other_type(op) eq_compare_other_type(op)
} else { } else {
Err(TypeError::py_err( Err(PyTypeError::new_err(
"DefaultGraph could only be compared with RDF terms", "DefaultGraph could only be compared with RDF terms",
)) ))
} }
} }
} }
#[derive(FromPyObject)]
pub enum PyNamedOrBlankNode {
NamedNode(PyNamedNode),
BlankNode(PyBlankNode),
}
impl From<PyNamedOrBlankNode> for NamedOrBlankNode {
fn from(node: PyNamedOrBlankNode) -> Self {
match node {
PyNamedOrBlankNode::NamedNode(node) => node.into(),
PyNamedOrBlankNode::BlankNode(node) => node.into(),
}
}
}
#[derive(FromPyObject)]
enum PyTerm {
NamedNode(PyNamedNode),
BlankNode(PyBlankNode),
Literal(PyLiteral),
}
impl From<PyTerm> for Term {
fn from(term: PyTerm) -> Self {
match term {
PyTerm::NamedNode(node) => node.into(),
PyTerm::BlankNode(node) => node.into(),
PyTerm::Literal(literal) => literal.into(),
}
}
}
/// An RDF `triple <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple>`_ /// An RDF `triple <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple>`_
/// ///
/// :param subject: the triple subject /// :param subject: the triple subject
@ -449,13 +481,8 @@ impl<'a> From<&'a PyTriple> for TripleRef<'a> {
#[pymethods] #[pymethods]
impl PyTriple { impl PyTriple {
#[new] #[new]
fn new(subject: &PyAny, predicate: PyNamedNode, object: &PyAny) -> PyResult<Self> { fn new(subject: PyNamedOrBlankNode, predicate: PyNamedNode, object: PyTerm) -> Self {
Ok(Triple::new( Triple::new(subject, predicate, object).into()
&PyNamedOrBlankNodeRef::try_from(subject)?,
predicate,
&PyTermRef::try_from(object)?,
)
.into())
} }
/// :return: the triple subject /// :return: the triple subject
@ -531,7 +558,7 @@ impl PyMappingProtocol<'p> for PyTriple {
)), )),
1 => Ok(PyNamedNode::from(self.inner.predicate.clone()).into_py(gil.python())), 1 => Ok(PyNamedNode::from(self.inner.predicate.clone()).into_py(gil.python())),
2 => Ok(term_to_python(gil.python(), self.inner.object.clone())), 2 => Ok(term_to_python(gil.python(), self.inner.object.clone())),
_ => Err(IndexError::py_err("A triple has only 3 elements")), _ => Err(PyIndexError::new_err("A triple has only 3 elements")),
} }
} }
} }
@ -550,6 +577,22 @@ impl PyIterProtocol for PyTriple {
} }
} }
#[derive(FromPyObject)]
pub enum PyGraphName {
NamedNode(PyNamedNode),
BlankNode(PyBlankNode),
DefaultGraph(PyDefaultGraph),
}
impl From<PyGraphName> 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(),
}
}
}
/// An RDF `triple <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple>`_ /// An RDF `triple <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple>`_
/// in a `RDF dataset <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset>`_ /// in a `RDF dataset <https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset>`_
/// ///
@ -602,22 +645,18 @@ impl<'a> From<&'a PyQuad> for QuadRef<'a> {
impl PyQuad { impl PyQuad {
#[new] #[new]
fn new( fn new(
subject: &PyAny, subject: PyNamedOrBlankNode,
predicate: PyNamedNode, predicate: PyNamedNode,
object: &PyAny, object: PyTerm,
graph_name: Option<&PyAny>, graph_name: Option<PyGraphName>,
) -> PyResult<Self> { ) -> Self {
Ok(Quad::new( Quad::new(
&PyNamedOrBlankNodeRef::try_from(subject)?, subject,
predicate, predicate,
&PyTermRef::try_from(object)?, object,
&if let Some(graph_name) = graph_name { graph_name.unwrap_or_else(|| PyGraphName::DefaultGraph(PyDefaultGraph {})),
PyGraphNameRef::try_from(graph_name)?
} else {
PyGraphNameRef::DefaultGraph
},
) )
.into()) .into()
} }
/// :return: the quad subject /// :return: the quad subject
@ -719,7 +758,7 @@ impl PyMappingProtocol<'p> for PyQuad {
gil.python(), gil.python(),
self.inner.graph_name.clone(), self.inner.graph_name.clone(),
)), )),
_ => Err(IndexError::py_err("A quad has only 4 elements")), _ => Err(PyIndexError::new_err("A quad has only 4 elements")),
} }
} }
} }
@ -783,7 +822,7 @@ impl PyVariable {
#[new] #[new]
fn new(value: String) -> PyResult<Self> { fn new(value: String) -> PyResult<Self> {
Ok(Variable::new(value) Ok(Variable::new(value)
.map_err(|e| ValueError::py_err(e.to_string()))? .map_err(|e| PyValueError::new_err(e.to_string()))?
.into()) .into())
} }
@ -832,7 +871,7 @@ impl<'a> TryFrom<&'a PyAny> for PyNamedNodeRef<'a> {
if let Ok(node) = value.downcast::<PyCell<PyNamedNode>>() { if let Ok(node) = value.downcast::<PyCell<PyNamedNode>>() {
Ok(Self(node.borrow())) Ok(Self(node.borrow()))
} else { } else {
Err(TypeError::py_err(format!( Err(PyTypeError::new_err(format!(
"{} is not an RDF named node", "{} is not an RDF named node",
value.get_type().name(), value.get_type().name(),
))) )))
@ -854,12 +893,6 @@ impl<'a> From<&'a PyNamedOrBlankNodeRef<'a>> for NamedOrBlankNodeRef<'a> {
} }
} }
impl<'a> From<&'a PyNamedOrBlankNodeRef<'a>> for NamedOrBlankNode {
fn from(value: &'a PyNamedOrBlankNodeRef<'a>) -> Self {
NamedOrBlankNodeRef::from(value).into()
}
}
impl<'a> TryFrom<&'a PyAny> for PyNamedOrBlankNodeRef<'a> { impl<'a> TryFrom<&'a PyAny> for PyNamedOrBlankNodeRef<'a> {
type Error = PyErr; type Error = PyErr;
@ -869,7 +902,7 @@ impl<'a> TryFrom<&'a PyAny> for PyNamedOrBlankNodeRef<'a> {
} else if let Ok(node) = value.downcast::<PyCell<PyBlankNode>>() { } else if let Ok(node) = value.downcast::<PyCell<PyBlankNode>>() {
Ok(Self::BlankNode(node.borrow())) Ok(Self::BlankNode(node.borrow()))
} else { } else {
Err(TypeError::py_err(format!( Err(PyTypeError::new_err(format!(
"{} is not an RDF named or blank node", "{} is not an RDF named or blank node",
value.get_type().name(), value.get_type().name(),
))) )))
@ -917,7 +950,7 @@ impl<'a> TryFrom<&'a PyAny> for PyTermRef<'a> {
} else if let Ok(node) = value.downcast::<PyCell<PyLiteral>>() { } else if let Ok(node) = value.downcast::<PyCell<PyLiteral>>() {
Ok(Self::Literal(node.borrow())) Ok(Self::Literal(node.borrow()))
} else { } else {
Err(TypeError::py_err(format!( Err(PyTypeError::new_err(format!(
"{} is not an RDF term", "{} is not an RDF term",
value.get_type().name(), value.get_type().name(),
))) )))
@ -966,7 +999,7 @@ impl<'a> TryFrom<&'a PyAny> for PyGraphNameRef<'a> {
} else if value.downcast::<PyCell<PyDefaultGraph>>().is_ok() { } else if value.downcast::<PyCell<PyDefaultGraph>>().is_ok() {
Ok(Self::DefaultGraph) Ok(Self::DefaultGraph)
} else { } else {
Err(TypeError::py_err(format!( Err(PyTypeError::new_err(format!(
"{} is not an RDF graph name", "{} is not an RDF graph name",
value.get_type().name(), value.get_type().name(),
))) )))
@ -986,7 +1019,9 @@ fn eq_compare<T: Eq>(a: &T, b: &T, op: CompareOp) -> PyResult<bool> {
match op { match op {
CompareOp::Eq => Ok(a == b), CompareOp::Eq => Ok(a == b),
CompareOp::Ne => Ok(a != b), CompareOp::Ne => Ok(a != b),
_ => Err(NotImplementedError::py_err("Ordering is not implemented")), _ => Err(PyNotImplementedError::new_err(
"Ordering is not implemented",
)),
} }
} }
@ -994,7 +1029,9 @@ fn eq_compare_other_type(op: CompareOp) -> PyResult<bool> {
match op { match op {
CompareOp::Eq => Ok(false), CompareOp::Eq => Ok(false),
CompareOp::Ne => Ok(true), CompareOp::Ne => Ok(true),
_ => Err(NotImplementedError::py_err("Ordering is not implemented")), _ => Err(PyNotImplementedError::new_err(
"Ordering is not implemented",
)),
} }
} }
@ -1056,7 +1093,7 @@ fn graph_name_repr(term: GraphNameRef<'_>, buffer: &mut String) {
} }
} }
#[pyclass(unsendable)] #[pyclass]
pub struct TripleComponentsIter { pub struct TripleComponentsIter {
inner: IntoIter<Term>, inner: IntoIter<Term>,
} }
@ -1072,7 +1109,7 @@ impl PyIterProtocol for TripleComponentsIter {
} }
} }
#[pyclass(unsendable)] #[pyclass]
pub struct QuadComponentsIter { pub struct QuadComponentsIter {
inner: IntoIter<Option<Term>>, inner: IntoIter<Option<Term>>,
} }

12
python/src/sled_store.rs
Unescape View File

@ -4,7 +4,7 @@ use crate::sparql::*;
use crate::store_utils::*; use crate::store_utils::*;
use oxigraph::io::{DatasetFormat, GraphFormat}; use oxigraph::io::{DatasetFormat, GraphFormat};
use oxigraph::store::sled::*; use oxigraph::store::sled::*;
use pyo3::exceptions::ValueError; use pyo3::exceptions::PyValueError;
use pyo3::prelude::{ use pyo3::prelude::{
pyclass, pymethods, pyproto, Py, PyAny, PyObject, PyRef, PyRefMut, PyResult, Python, ToPyObject, pyclass, pymethods, pyproto, Py, PyAny, PyObject, PyRef, PyRefMut, PyResult, Python, ToPyObject,
}; };
@ -273,7 +273,7 @@ impl PySledStore {
.map_err(map_io_err) .map_err(map_io_err)
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { } else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) {
if to_graph_name.is_some() { if to_graph_name.is_some() {
return Err(ValueError::py_err( return Err(PyValueError::new_err(
"The target graph name parameter is not available for dataset formats", "The target graph name parameter is not available for dataset formats",
)); ));
} }
@ -281,7 +281,7 @@ impl PySledStore {
.load_dataset(input, dataset_format, base_iri) .load_dataset(input, dataset_format, base_iri)
.map_err(map_io_err) .map_err(map_io_err)
} else { } else {
Err(ValueError::py_err(format!( Err(PyValueError::new_err(format!(
"Not supported MIME type: {}", "Not supported MIME type: {}",
mime_type mime_type
))) )))
@ -342,7 +342,7 @@ impl PySledStore {
.map_err(map_io_err) .map_err(map_io_err)
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { } else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) {
if from_graph_name.is_some() { if from_graph_name.is_some() {
return Err(ValueError::py_err( return Err(PyValueError::new_err(
"The target graph name parameter is not available for dataset formats", "The target graph name parameter is not available for dataset formats",
)); ));
} }
@ -350,7 +350,7 @@ impl PySledStore {
.dump_dataset(output, dataset_format) .dump_dataset(output, dataset_format)
.map_err(map_io_err) .map_err(map_io_err)
} else { } else {
Err(ValueError::py_err(format!( Err(PyValueError::new_err(format!(
"Not supported MIME type: {}", "Not supported MIME type: {}",
mime_type mime_type
))) )))
@ -389,7 +389,7 @@ impl PyIterProtocol for PySledStore {
} }
} }
#[pyclass(unsendable)] #[pyclass]
pub struct QuadIter { pub struct QuadIter {
inner: SledQuadIter, inner: SledQuadIter,
} }

27
python/src/sparql.rs
Unescape View File

@ -2,13 +2,12 @@ use crate::model::*;
use crate::store_utils::*; use crate::store_utils::*;
use oxigraph::model::Term; use oxigraph::model::Term;
use oxigraph::sparql::*; use oxigraph::sparql::*;
use pyo3::exceptions::{RuntimeError, SyntaxError, TypeError, ValueError}; use pyo3::exceptions::{PyRuntimeError, PySyntaxError, PyTypeError, PyValueError};
use pyo3::prelude::{ use pyo3::prelude::{
pyclass, pymethods, pyproto, FromPyObject, IntoPy, Py, PyAny, PyCell, PyErr, PyObject, PyRef, pyclass, pymethods, pyproto, FromPyObject, IntoPy, Py, PyAny, PyCell, PyErr, PyObject, PyRef,
PyRefMut, PyResult, Python, PyRefMut, PyResult, Python,
}; };
use pyo3::{PyIterProtocol, PyMappingProtocol, PyNativeType, PyObjectProtocol}; use pyo3::{PyIterProtocol, PyMappingProtocol, PyNativeType, PyObjectProtocol};
use std::convert::TryFrom;
use std::vec::IntoIter; use std::vec::IntoIter;
pub fn build_query_options( pub fn build_query_options(
@ -24,17 +23,17 @@ pub fn build_query_options(
if let Some(default_graph) = default_graph { if let Some(default_graph) = default_graph {
if let Ok(default_graphs) = default_graph.iter() { if let Ok(default_graphs) = default_graph.iter() {
if default_graph.is_empty()? { if default_graph.is_empty()? {
return Err(ValueError::py_err( return Err(PyValueError::new_err(
"The query() method default_graph argument cannot be empty list", "The query() method default_graph argument cannot be empty list",
)); ));
} }
for default_graph in default_graphs { for default_graph in default_graphs {
options = options.with_default_graph(&PyGraphNameRef::try_from(default_graph?)?); options = options.with_default_graph(default_graph?.extract::<PyGraphName>()?);
} }
} else if let Ok(default_graph) = PyGraphNameRef::try_from(default_graph) { } else if let Ok(default_graph) = default_graph.extract::<PyGraphName>() {
options = options.with_default_graph(&default_graph); options = options.with_default_graph(default_graph);
} else { } else {
return Err(ValueError::py_err( 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() 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()
))); )));
} }
@ -42,12 +41,12 @@ pub fn build_query_options(
if let Some(named_graphs) = named_graphs { if let Some(named_graphs) = named_graphs {
if named_graphs.is_empty()? { if named_graphs.is_empty()? {
return Err(ValueError::py_err( return Err(PyValueError::new_err(
"The query() method named_graphs argument cannot be empty", "The query() method named_graphs argument cannot be empty",
)); ));
} }
for named_graph in named_graphs.iter()? { for named_graph in named_graphs.iter()? {
options = options.with_named_graph(&PyNamedOrBlankNodeRef::try_from(named_graph?)?); options = options.with_named_graph(named_graph?.extract::<PyNamedOrBlankNode>()?);
} }
} }
@ -126,7 +125,7 @@ impl PyMappingProtocol for PyQuerySolution {
.get(<&Variable>::from(key)) .get(<&Variable>::from(key))
.map(|term| term_to_python(input.py(), term.clone()))) .map(|term| term_to_python(input.py(), term.clone())))
} else { } else {
Err(TypeError::py_err(format!( Err(PyTypeError::new_err(format!(
"{} is not an integer of a string", "{} is not an integer of a string",
input.get_type().name(), input.get_type().name(),
))) )))
@ -148,7 +147,7 @@ impl PyIterProtocol for PyQuerySolution {
} }
} }
#[pyclass(unsendable)] #[pyclass]
pub struct SolutionValueIter { pub struct SolutionValueIter {
inner: IntoIter<Option<Term>>, inner: IntoIter<Option<Term>>,
} }
@ -240,9 +239,9 @@ impl PyIterProtocol for PyQueryTriples {
pub fn map_evaluation_error(error: EvaluationError) -> PyErr { pub fn map_evaluation_error(error: EvaluationError) -> PyErr {
match error { match error {
EvaluationError::Parsing(error) => SyntaxError::py_err(error.to_string()), EvaluationError::Parsing(error) => PySyntaxError::new_err(error.to_string()),
EvaluationError::Io(error) => map_io_err(error), EvaluationError::Io(error) => map_io_err(error),
EvaluationError::Query(error) => ValueError::py_err(error.to_string()), EvaluationError::Query(error) => PyValueError::new_err(error.to_string()),
_ => RuntimeError::py_err(error.to_string()), _ => PyRuntimeError::new_err(error.to_string()),
} }
} }

8
python/src/store_utils.rs
Unescape View File

@ -1,5 +1,5 @@
use crate::model::*; use crate::model::*;
use pyo3::exceptions::{IOError, SyntaxError, ValueError}; use pyo3::exceptions::{PyIOError, PySyntaxError, PyValueError};
use pyo3::{PyAny, PyErr, PyResult}; use pyo3::{PyAny, PyErr, PyResult};
use std::convert::TryInto; use std::convert::TryInto;
use std::io; use std::io;
@ -45,10 +45,10 @@ pub fn extract_quads_pattern<'a>(
pub fn map_io_err(error: io::Error) -> PyErr { pub fn map_io_err(error: io::Error) -> PyErr {
match error.kind() { match error.kind() {
io::ErrorKind::InvalidInput => ValueError::py_err(error.to_string()), io::ErrorKind::InvalidInput => PyValueError::new_err(error.to_string()),
io::ErrorKind::InvalidData | io::ErrorKind::UnexpectedEof => { io::ErrorKind::InvalidData | io::ErrorKind::UnexpectedEof => {
SyntaxError::py_err(error.to_string()) PySyntaxError::new_err(error.to_string())
} }
_ => IOError::py_err(error.to_string()), _ => PyIOError::new_err(error.to_string()),
} }
} }

Write Preview
Loading…
Cancel
Save