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

Improves RDF I/O ParseError

Browse Source
pull/190/head
Tpt 3 years ago
parent 375fef1e22
commit ec5c7c86be
10 changed files with 189 additions and 196 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. 140
      lib/src/io/error.rs
  2. 1
      lib/src/io/mod.rs
  3. 174
      lib/src/io/read.rs
  4. 16
      lib/src/sparql/error.rs
  5. 4
      lib/src/sparql/update.rs
  6. 16
      lib/src/storage/error.rs
  7. 10
      lib/src/store.rs
  8. 16
      python/src/io.rs
  9. 4
      python/src/sparql.rs
  10. 4
      python/src/store.rs

140
lib/src/io/error.rs
Unescape View File

@ -0,0 +1,140 @@
use oxiri::IriParseError;
use rio_turtle::TurtleError;
use rio_xml::RdfXmlError;
use std::error::Error;
use std::{fmt, io};
/// Error returned during RDF format parsing.
#[derive(Debug)]
pub enum ParseError {
/// I/O error during parsing (file not found...).
Io(io::Error),
/// An error in the file syntax.
Syntax(SyntaxError),
}
impl ParseError {
pub(crate) fn invalid_base_iri(iri: &str, error: IriParseError) -> Self {
Self::Syntax(SyntaxError {
inner: SyntaxErrorKind::InvalidBaseIri {
iri: iri.to_owned(),
error,
},
})
}
}
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Io(e) => e.fmt(f),
Self::Syntax(e) => e.fmt(f),
}
}
}
impl Error for ParseError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Io(e) => Some(e),
Self::Syntax(e) => Some(e),
}
}
}
#[allow(clippy::fallible_impl_from)]
impl From<TurtleError> for ParseError {
fn from(error: TurtleError) -> Self {
let error = io::Error::from(error);
if error.get_ref().map_or(false, |e| e.is::<TurtleError>()) {
Self::Syntax(SyntaxError {
inner: SyntaxErrorKind::Turtle(*error.into_inner().unwrap().downcast().unwrap()),
})
} else {
Self::Io(error)
}
}
}
#[allow(clippy::fallible_impl_from)]
impl From<RdfXmlError> for ParseError {
fn from(error: RdfXmlError) -> Self {
let error = io::Error::from(error);
if error.get_ref().map_or(false, |e| e.is::<RdfXmlError>()) {
Self::Syntax(SyntaxError {
inner: SyntaxErrorKind::RdfXml(*error.into_inner().unwrap().downcast().unwrap()),
})
} else {
Self::Io(error)
}
}
}
impl From<io::Error> for ParseError {
fn from(error: io::Error) -> Self {
Self::Io(error)
}
}
impl From<SyntaxError> for ParseError {
fn from(error: SyntaxError) -> Self {
Self::Syntax(error)
}
}
impl From<ParseError> for io::Error {
fn from(error: ParseError) -> Self {
match error {
ParseError::Io(error) => error,
ParseError::Syntax(error) => error.into(),
}
}
}
/// An error in the syntax of the parsed file.
#[derive(Debug)]
pub struct SyntaxError {
inner: SyntaxErrorKind,
}
#[derive(Debug)]
enum SyntaxErrorKind {
Turtle(TurtleError),
RdfXml(RdfXmlError),
InvalidBaseIri { iri: String, error: IriParseError },
}
impl fmt::Display for SyntaxError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.inner {
SyntaxErrorKind::Turtle(e) => e.fmt(f),
SyntaxErrorKind::RdfXml(e) => e.fmt(f),
SyntaxErrorKind::InvalidBaseIri { iri, error } => {
write!(f, "Invalid base IRI '{}': {}", iri, error)
}
}
}
}
impl Error for SyntaxError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match &self.inner {
SyntaxErrorKind::Turtle(e) => Some(e),
SyntaxErrorKind::RdfXml(e) => Some(e),
SyntaxErrorKind::InvalidBaseIri { .. } => None,
}
}
}
impl From<SyntaxError> for io::Error {
fn from(error: SyntaxError) -> Self {
match error.inner {
SyntaxErrorKind::Turtle(error) => error.into(),
SyntaxErrorKind::RdfXml(error) => error.into(),
SyntaxErrorKind::InvalidBaseIri { iri, error } => Self::new(
io::ErrorKind::InvalidInput,
format!("Invalid IRI '{}': {}", iri, error),
),
}
}
}

1
lib/src/io/mod.rs
Unescape View File

@ -1,5 +1,6 @@
//! Utilities to read and write RDF graphs and datasets. //! Utilities to read and write RDF graphs and datasets.
mod error;
mod format; mod format;
pub mod read; pub mod read;
pub mod write; pub mod write;

174
lib/src/io/read.rs
Unescape View File

@ -1,16 +1,15 @@
//! Utilities to read RDF graphs and datasets. //! Utilities to read RDF graphs and datasets.
pub use crate::io::error::{ParseError, SyntaxError};
use crate::io::{DatasetFormat, GraphFormat}; use crate::io::{DatasetFormat, GraphFormat};
use crate::model::*; use crate::model::*;
use oxiri::{Iri, IriParseError}; use oxiri::{Iri, IriParseError};
use rio_api::model as rio; use rio_api::model as rio;
use rio_api::parser::{QuadsParser, TriplesParser}; use rio_api::parser::{QuadsParser, TriplesParser};
use rio_turtle::{NQuadsParser, NTriplesParser, TriGParser, TurtleError, TurtleParser}; use rio_turtle::{NQuadsParser, NTriplesParser, TriGParser, TurtleParser};
use rio_xml::{RdfXmlError, RdfXmlParser}; use rio_xml::RdfXmlParser;
use std::collections::HashMap; use std::collections::HashMap;
use std::error::Error;
use std::io::BufRead; use std::io::BufRead;
use std::{fmt, io};
/// Parsers for RDF graph serialization formats. /// Parsers for RDF graph serialization formats.
/// ///
@ -68,7 +67,7 @@ impl GraphParser {
/// Executes the parsing itself on a [`BufRead`](std::io::BufRead) implementation and returns an iterator of triples. /// Executes the parsing itself on a [`BufRead`](std::io::BufRead) implementation and returns an iterator of triples.
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
pub fn read_triples<R: BufRead>(&self, reader: R) -> Result<TripleReader<R>, ParserError> { pub fn read_triples<R: BufRead>(&self, reader: R) -> Result<TripleReader<R>, ParseError> {
Ok(TripleReader { Ok(TripleReader {
mapper: RioMapper::default(), mapper: RioMapper::default(),
parser: match self.format { parser: match self.format {
@ -115,9 +114,9 @@ enum TripleReaderKind<R: BufRead> {
} }
impl<R: BufRead> Iterator for TripleReader<R> { impl<R: BufRead> Iterator for TripleReader<R> {
type Item = Result<Triple, ParserError>; type Item = Result<Triple, ParseError>;
fn next(&mut self) -> Option<Result<Triple, ParserError>> { fn next(&mut self) -> Option<Result<Triple, ParseError>> {
loop { loop {
if let Some(r) = self.buffer.pop() { if let Some(r) = self.buffer.pop() {
return Some(Ok(r)); return Some(Ok(r));
@ -145,9 +144,9 @@ impl<R: BufRead> TripleReader<R> {
parser: &mut P, parser: &mut P,
buffer: &mut Vec<Triple>, buffer: &mut Vec<Triple>,
mapper: &mut RioMapper, mapper: &mut RioMapper,
) -> Option<Result<(), ParserError>> ) -> Option<Result<(), ParseError>>
where where
ParserError: From<P::Error>, ParseError: From<P::Error>,
{ {
if parser.is_end() { if parser.is_end() {
None None
@ -217,7 +216,7 @@ impl DatasetParser {
/// Executes the parsing itself on a [`BufRead`](std::io::BufRead) implementation and returns an iterator of quads. /// Executes the parsing itself on a [`BufRead`](std::io::BufRead) implementation and returns an iterator of quads.
#[allow(clippy::unnecessary_wraps)] #[allow(clippy::unnecessary_wraps)]
pub fn read_quads<R: BufRead>(&self, reader: R) -> Result<QuadReader<R>, ParserError> { pub fn read_quads<R: BufRead>(&self, reader: R) -> Result<QuadReader<R>, ParseError> {
Ok(QuadReader { Ok(QuadReader {
mapper: RioMapper::default(), mapper: RioMapper::default(),
parser: match self.format { parser: match self.format {
@ -260,9 +259,9 @@ enum QuadReaderKind<R: BufRead> {
} }
impl<R: BufRead> Iterator for QuadReader<R> { impl<R: BufRead> Iterator for QuadReader<R> {
type Item = Result<Quad, ParserError>; type Item = Result<Quad, ParseError>;
fn next(&mut self) -> Option<Result<Quad, ParserError>> { fn next(&mut self) -> Option<Result<Quad, ParseError>> {
loop { loop {
if let Some(r) = self.buffer.pop() { if let Some(r) = self.buffer.pop() {
return Some(Ok(r)); return Some(Ok(r));
@ -287,9 +286,9 @@ impl<R: BufRead> QuadReader<R> {
parser: &mut P, parser: &mut P,
buffer: &mut Vec<Quad>, buffer: &mut Vec<Quad>,
mapper: &mut RioMapper, mapper: &mut RioMapper,
) -> Option<Result<(), ParserError>> ) -> Option<Result<(), ParseError>>
where where
ParserError: From<P::Error>, ParseError: From<P::Error>,
{ {
if parser.is_end() { if parser.is_end() {
None None
@ -375,150 +374,3 @@ impl<'a> RioMapper {
} }
} }
} }
/// Error returned during RDF format parsing.
#[derive(Debug)]
pub enum ParserError {
/// I/O error during parsing (file not found...).
Io(io::Error),
/// An error in the file syntax.
Syntax(SyntaxError),
}
impl ParserError {
pub(crate) fn invalid_base_iri(iri: &str, error: IriParseError) -> Self {
Self::Syntax(SyntaxError {
inner: SyntaxErrorKind::InvalidBaseIri {
iri: iri.to_owned(),
error,
},
})
}
}
impl fmt::Display for ParserError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Io(e) => e.fmt(f),
Self::Syntax(e) => e.fmt(f),
}
}
}
impl Error for ParserError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Io(e) => Some(e),
Self::Syntax(e) => Some(e),
}
}
}
#[allow(clippy::fallible_impl_from)]
impl From<TurtleError> for ParserError {
fn from(error: TurtleError) -> Self {
let error = io::Error::from(error);
if error.get_ref().map_or(false, |e| e.is::<TurtleError>()) {
Self::Syntax(SyntaxError {
inner: SyntaxErrorKind::Turtle(*error.into_inner().unwrap().downcast().unwrap()),
})
} else {
Self::Io(error)
}
}
}
#[allow(clippy::fallible_impl_from)]
impl From<RdfXmlError> for ParserError {
fn from(error: RdfXmlError) -> Self {
let error = io::Error::from(error);
if error.get_ref().map_or(false, |e| e.is::<RdfXmlError>()) {
Self::Syntax(SyntaxError {
inner: SyntaxErrorKind::RdfXml(*error.into_inner().unwrap().downcast().unwrap()),
})
} else {
Self::Io(error)
}
}
}
impl From<TermParseError> for ParserError {
fn from(error: TermParseError) -> Self {
Self::Syntax(SyntaxError {
inner: SyntaxErrorKind::Term(error),
})
}
}
impl From<io::Error> for ParserError {
fn from(error: io::Error) -> Self {
Self::Io(error)
}
}
impl From<SyntaxError> for ParserError {
fn from(error: SyntaxError) -> Self {
Self::Syntax(error)
}
}
impl From<ParserError> for io::Error {
fn from(error: ParserError) -> Self {
match error {
ParserError::Io(error) => error,
ParserError::Syntax(error) => error.into(),
}
}
}
/// An error in the syntax of the parsed file.
#[derive(Debug)]
pub struct SyntaxError {
pub(crate) inner: SyntaxErrorKind,
}
#[derive(Debug)]
pub(crate) enum SyntaxErrorKind {
Turtle(TurtleError),
RdfXml(RdfXmlError),
InvalidBaseIri { iri: String, error: IriParseError },
Term(TermParseError),
}
impl fmt::Display for SyntaxError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.inner {
SyntaxErrorKind::Turtle(e) => e.fmt(f),
SyntaxErrorKind::RdfXml(e) => e.fmt(f),
SyntaxErrorKind::InvalidBaseIri { iri, error } => {
write!(f, "Invalid base IRI '{}': {}", iri, error)
}
SyntaxErrorKind::Term(e) => e.fmt(f),
}
}
}
impl Error for SyntaxError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match &self.inner {
SyntaxErrorKind::Turtle(e) => Some(e),
SyntaxErrorKind::RdfXml(e) => Some(e),
SyntaxErrorKind::Term(e) => Some(e),
SyntaxErrorKind::InvalidBaseIri { .. } => None,
}
}
}
impl From<SyntaxError> for io::Error {
fn from(error: SyntaxError) -> Self {
match error.inner {
SyntaxErrorKind::Turtle(error) => error.into(),
SyntaxErrorKind::RdfXml(error) => error.into(),
SyntaxErrorKind::InvalidBaseIri { iri, error } => Self::new(
io::ErrorKind::InvalidInput,
format!("Invalid IRI '{}': {}", iri, error),
),
SyntaxErrorKind::Term(error) => Self::new(io::ErrorKind::InvalidData, error),
}
}
}

16
lib/src/sparql/error.rs
Unescape View File

@ -1,4 +1,4 @@
use crate::io::read::ParserError; use crate::io::read::ParseError;
use crate::storage::StorageError; use crate::storage::StorageError;
use std::convert::Infallible; use std::convert::Infallible;
use std::error; use std::error;
@ -14,7 +14,7 @@ pub enum EvaluationError {
/// An error from the storage /// An error from the storage
Storage(StorageError), Storage(StorageError),
/// An error while parsing an external RDF file /// An error while parsing an external RDF file
ExternalParser(ParserError), GraphParsing(ParseError),
/// An error while parsing an external result file (likely from a federated query) /// An error while parsing an external result file (likely from a federated query)
ResultsParsing(sparesults::ParseError), ResultsParsing(sparesults::ParseError),
/// An error returned during store IOs or during results write /// An error returned during store IOs or during results write
@ -39,7 +39,7 @@ impl fmt::Display for EvaluationError {
match self { match self {
Self::Parsing(error) => error.fmt(f), Self::Parsing(error) => error.fmt(f),
Self::Storage(error) => error.fmt(f), Self::Storage(error) => error.fmt(f),
Self::ExternalParser(error) => error.fmt(f), Self::GraphParsing(error) => error.fmt(f),
Self::ResultsParsing(error) => error.fmt(f), Self::ResultsParsing(error) => error.fmt(f),
Self::Io(error) => error.fmt(f), Self::Io(error) => error.fmt(f),
Self::Query(error) => error.fmt(f), Self::Query(error) => error.fmt(f),
@ -61,7 +61,7 @@ impl error::Error for EvaluationError {
match self { match self {
Self::Parsing(e) => Some(e), Self::Parsing(e) => Some(e),
Self::Storage(e) => Some(e), Self::Storage(e) => Some(e),
Self::ExternalParser(e) => Some(e), Self::GraphParsing(e) => Some(e),
Self::ResultsParsing(e) => Some(e), Self::ResultsParsing(e) => Some(e),
Self::Io(e) => Some(e), Self::Io(e) => Some(e),
Self::Query(e) => Some(e), Self::Query(e) => Some(e),
@ -118,9 +118,9 @@ impl From<io::Error> for EvaluationError {
} }
} }
impl From<ParserError> for EvaluationError { impl From<ParseError> for EvaluationError {
fn from(error: ParserError) -> Self { fn from(error: ParseError) -> Self {
Self::ExternalParser(error) Self::GraphParsing(error)
} }
} }
@ -134,7 +134,7 @@ impl From<EvaluationError> for io::Error {
fn from(error: EvaluationError) -> Self { fn from(error: EvaluationError) -> Self {
match error { match error {
EvaluationError::Parsing(error) => Self::new(io::ErrorKind::InvalidData, error), EvaluationError::Parsing(error) => Self::new(io::ErrorKind::InvalidData, error),
EvaluationError::ExternalParser(error) => error.into(), EvaluationError::GraphParsing(error) => error.into(),
EvaluationError::ResultsParsing(error) => error.into(), EvaluationError::ResultsParsing(error) => error.into(),
EvaluationError::Io(error) => error, EvaluationError::Io(error) => error,
EvaluationError::Storage(error) => error.into(), EvaluationError::Storage(error) => error.into(),

4
lib/src/sparql/update.rs
Unescape View File

@ -1,4 +1,4 @@
use crate::io::read::ParserError; use crate::io::read::ParseError;
use crate::io::{GraphFormat, GraphParser}; use crate::io::{GraphFormat, GraphParser};
use crate::model::{GraphName as OxGraphName, GraphNameRef, Quad as OxQuad}; use crate::model::{GraphName as OxGraphName, GraphNameRef, Quad as OxQuad};
use crate::sparql::algebra::QueryDataset; use crate::sparql::algebra::QueryDataset;
@ -172,7 +172,7 @@ impl SimpleUpdateEvaluator<'_> {
if let Some(base_iri) = &self.base_iri { if let Some(base_iri) = &self.base_iri {
parser = parser parser = parser
.with_base_iri(base_iri.as_str()) .with_base_iri(base_iri.as_str())
.map_err(|e| ParserError::invalid_base_iri(base_iri, e))?; .map_err(|e| ParseError::invalid_base_iri(base_iri, e))?;
} }
for t in parser.read_triples(BufReader::new(body))? { for t in parser.read_triples(BufReader::new(body))? {
self.transaction self.transaction

16
lib/src/storage/error.rs
Unescape View File

@ -1,4 +1,4 @@
use crate::io::read::ParserError; use crate::io::read::ParseError;
use std::error::Error; use std::error::Error;
use std::fmt; use std::fmt;
use std::io; use std::io;
@ -113,7 +113,7 @@ impl From<CorruptionError> for io::Error {
#[derive(Debug)] #[derive(Debug)]
pub enum LoaderError { pub enum LoaderError {
/// An error raised while reading the file. /// An error raised while reading the file.
Parser(ParserError), Parsing(ParseError),
/// An error raised during the insertion in the store. /// An error raised during the insertion in the store.
Storage(StorageError), Storage(StorageError),
} }
@ -121,7 +121,7 @@ pub enum LoaderError {
impl fmt::Display for LoaderError { impl fmt::Display for LoaderError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match self {
Self::Parser(e) => e.fmt(f), Self::Parsing(e) => e.fmt(f),
Self::Storage(e) => e.fmt(f), Self::Storage(e) => e.fmt(f),
} }
} }
@ -130,15 +130,15 @@ impl fmt::Display for LoaderError {
impl Error for LoaderError { impl Error for LoaderError {
fn source(&self) -> Option<&(dyn Error + 'static)> { fn source(&self) -> Option<&(dyn Error + 'static)> {
match self { match self {
Self::Parser(e) => Some(e), Self::Parsing(e) => Some(e),
Self::Storage(e) => Some(e), Self::Storage(e) => Some(e),
} }
} }
} }
impl From<ParserError> for LoaderError { impl From<ParseError> for LoaderError {
fn from(error: ParserError) -> Self { fn from(error: ParseError) -> Self {
Self::Parser(error) Self::Parsing(error)
} }
} }
@ -152,7 +152,7 @@ impl From<LoaderError> for io::Error {
fn from(error: LoaderError) -> Self { fn from(error: LoaderError) -> Self {
match error { match error {
LoaderError::Storage(error) => error.into(), LoaderError::Storage(error) => error.into(),
LoaderError::Parser(error) => error.into(), LoaderError::Parsing(error) => error.into(),
} }
} }
} }

10
lib/src/store.rs
Unescape View File

@ -23,7 +23,7 @@
//! }; //! };
//! # Result::<_,Box<dyn std::error::Error>>::Ok(()) //! # Result::<_,Box<dyn std::error::Error>>::Ok(())
//! ``` //! ```
use crate::io::read::ParserError; use crate::io::read::ParseError;
use crate::io::{ use crate::io::{
DatasetFormat, DatasetParser, DatasetSerializer, GraphFormat, GraphParser, GraphSerializer, DatasetFormat, DatasetParser, DatasetSerializer, GraphFormat, GraphParser, GraphSerializer,
}; };
@ -274,7 +274,7 @@ impl Store {
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| ParserError::invalid_base_iri(base_iri, e))?; .map_err(|e| ParseError::invalid_base_iri(base_iri, e))?;
} }
let quads = parser let quads = parser
.read_triples(reader)? .read_triples(reader)?
@ -323,7 +323,7 @@ impl Store {
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| ParserError::invalid_base_iri(base_iri, e))?; .map_err(|e| ParseError::invalid_base_iri(base_iri, e))?;
} }
let quads = parser.read_quads(reader)?.collect::<Result<Vec<_>, _>>()?; let quads = parser.read_quads(reader)?.collect::<Result<Vec<_>, _>>()?;
self.storage.transaction(move |mut t| { self.storage.transaction(move |mut t| {
@ -660,7 +660,7 @@ impl Store {
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| ParserError::invalid_base_iri(base_iri, e))?; .map_err(|e| ParseError::invalid_base_iri(base_iri, e))?;
} }
bulk_load(&self.storage, parser.read_quads(reader)?) bulk_load(&self.storage, parser.read_quads(reader)?)
} }
@ -708,7 +708,7 @@ impl Store {
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| ParserError::invalid_base_iri(base_iri, e))?; .map_err(|e| ParseError::invalid_base_iri(base_iri, e))?;
} }
let to_graph_name = to_graph_name.into(); let to_graph_name = to_graph_name.into();
bulk_load( bulk_load(

16
python/src/io.rs
Unescape View File

@ -1,7 +1,7 @@
#![allow(clippy::needless_option_as_deref)] #![allow(clippy::needless_option_as_deref)]
use crate::model::{PyQuad, PyTriple}; use crate::model::{PyQuad, PyTriple};
use oxigraph::io::read::{ParserError, QuadReader, TripleReader}; use oxigraph::io::read::{ParseError, QuadReader, TripleReader};
use oxigraph::io::{ use oxigraph::io::{
DatasetFormat, DatasetParser, DatasetSerializer, GraphFormat, GraphParser, GraphSerializer, DatasetFormat, DatasetParser, DatasetSerializer, GraphFormat, GraphParser, GraphSerializer,
}; };
@ -61,7 +61,7 @@ pub fn parse(
.map_err(|e| PyValueError::new_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_parser_error)?, inner: parser.read_triples(input).map_err(map_parse_error)?,
} }
.into_py(py)) .into_py(py))
} else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) { } else if let Some(dataset_format) = DatasetFormat::from_media_type(mime_type) {
@ -72,7 +72,7 @@ pub fn parse(
.map_err(|e| PyValueError::new_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_parser_error)?, inner: parser.read_quads(input).map_err(map_parse_error)?,
} }
.into_py(py)) .into_py(py))
} else { } else {
@ -158,7 +158,7 @@ impl PyTripleReader {
fn __next__(&mut self) -> PyResult<Option<PyTriple>> { fn __next__(&mut self) -> PyResult<Option<PyTriple>> {
self.inner self.inner
.next() .next()
.map(|q| Ok(q.map_err(map_parser_error)?.into())) .map(|q| Ok(q.map_err(map_parse_error)?.into()))
.transpose() .transpose()
} }
} }
@ -177,7 +177,7 @@ impl PyQuadReader {
fn __next__(&mut self) -> PyResult<Option<PyQuad>> { fn __next__(&mut self) -> PyResult<Option<PyQuad>> {
self.inner self.inner
.next() .next()
.map(|q| Ok(q.map_err(map_parser_error)?.into())) .map(|q| Ok(q.map_err(map_parse_error)?.into()))
.transpose() .transpose()
} }
} }
@ -247,9 +247,9 @@ pub(crate) fn map_io_err(error: io::Error) -> PyErr {
PyIOError::new_err(error.to_string()) PyIOError::new_err(error.to_string())
} }
pub(crate) fn map_parser_error(error: ParserError) -> PyErr { pub(crate) fn map_parse_error(error: ParseError) -> PyErr {
match error { match error {
ParserError::Syntax(error) => PySyntaxError::new_err(error.to_string()), ParseError::Syntax(error) => PySyntaxError::new_err(error.to_string()),
ParserError::Io(error) => map_io_err(error), ParseError::Io(error) => map_io_err(error),
} }
} }

4
python/src/sparql.rs
Unescape View File

@ -1,4 +1,4 @@
use crate::io::{map_io_err, map_parser_error}; use crate::io::{map_io_err, map_parse_error};
use crate::map_storage_error; use crate::map_storage_error;
use crate::model::*; use crate::model::*;
use oxigraph::model::Term; use oxigraph::model::Term;
@ -224,7 +224,7 @@ pub(crate) fn map_evaluation_error(error: EvaluationError) -> PyErr {
EvaluationError::Parsing(error) => PySyntaxError::new_err(error.to_string()), EvaluationError::Parsing(error) => PySyntaxError::new_err(error.to_string()),
EvaluationError::Storage(error) => map_storage_error(error), EvaluationError::Storage(error) => map_storage_error(error),
EvaluationError::Io(error) => map_io_err(error), EvaluationError::Io(error) => map_io_err(error),
EvaluationError::ExternalParser(error) => map_parser_error(error), EvaluationError::GraphParsing(error) => map_parse_error(error),
EvaluationError::Query(error) => PyValueError::new_err(error.to_string()), EvaluationError::Query(error) => PyValueError::new_err(error.to_string()),
_ => PyRuntimeError::new_err(error.to_string()), _ => PyRuntimeError::new_err(error.to_string()),
} }

4
python/src/store.rs
Unescape View File

@ -1,6 +1,6 @@
#![allow(clippy::needless_option_as_deref)] #![allow(clippy::needless_option_as_deref)]
use crate::io::{map_parser_error, PyFileLike}; use crate::io::{map_parse_error, PyFileLike};
use crate::model::*; use crate::model::*;
use crate::sparql::*; use crate::sparql::*;
use oxigraph::io::{DatasetFormat, GraphFormat}; use oxigraph::io::{DatasetFormat, GraphFormat};
@ -633,7 +633,7 @@ pub(crate) fn map_storage_error(error: StorageError) -> PyErr {
pub(crate) fn map_loader_error(error: LoaderError) -> PyErr { pub(crate) fn map_loader_error(error: LoaderError) -> PyErr {
match error { match error {
LoaderError::Storage(error) => map_storage_error(error), LoaderError::Storage(error) => map_storage_error(error),
LoaderError::Parser(error) => map_parser_error(error), LoaderError::Parsing(error) => map_parse_error(error),
} }
} }

Write Preview
Loading…
Cancel
Save