From c9ec5f7c0cd8cd6240aabab14194ac2049a01bbd Mon Sep 17 00:00:00 2001 From: Tpt Date: Mon, 21 Aug 2023 21:31:11 +0200 Subject: [PATCH] Python and & JS: Renames "mime_type" parameter to "format" - adds support of extensions - MIME type is a deprecated wording --- js/README.md | 30 ++++++------ js/src/store.rs | 22 +++++---- python/src/io.rs | 72 +++++++++++++++------------- python/src/store.rs | 98 +++++++++++++++++--------------------- python/tests/test_io.py | 2 +- python/tests/test_store.py | 20 ++++---- 6 files changed, 125 insertions(+), 119 deletions(-) diff --git a/js/README.md b/js/README.md index 576c9739..0ee92e9b 100644 --- a/js/README.md +++ b/js/README.md @@ -197,40 +197,42 @@ Example of update: store.update("DELETE WHERE { ?p ?o }") ``` -#### `Store.prototype.load(String data, String mimeType, NamedNode|String? baseIRI, NamedNode|BlankNode|DefaultGraph? toNamedGraph)` +#### `Store.prototype.load(String data, String format, NamedNode|String? baseIRI, NamedNode|BlankNode|DefaultGraph? toNamedGraph)` Loads serialized RDF triples or quad into the store. The method arguments are: 1. `data`: the serialized RDF triples or quads. -2. `mimeType`: the MIME type of the serialization. See below for the supported mime types. +2. `format`: the format of the serialization. See below for the supported formats. 3. `baseIRI`: the base IRI to use to resolve the relative IRIs in the serialization. 4. `toNamedGraph`: for triple serialization formats, the name of the named graph the triple should be loaded to. The available formats are: -* [Turtle](https://www.w3.org/TR/turtle/): `text/turtle` -* [TriG](https://www.w3.org/TR/trig/): `application/trig` -* [N-Triples](https://www.w3.org/TR/n-triples/): `application/n-triples` -* [N-Quads](https://www.w3.org/TR/n-quads/): `application/n-quads` -* [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/): `application/rdf+xml` +* [Turtle](https://www.w3.org/TR/turtle/): `text/turtle` or `ttl` +* [TriG](https://www.w3.org/TR/trig/): `application/trig` or `trig` +* [N-Triples](https://www.w3.org/TR/n-triples/): `application/n-triples` or `nt` +* [N-Quads](https://www.w3.org/TR/n-quads/): `application/n-quads` or `nq` +* [N3](https://w3c.github.io/N3/spec/): `text/n3` or `n3` +* [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/): `application/rdf+xml` or `rdf` Example of loading a Turtle file into the named graph `` with the base IRI `http://example.com`: ```js store.load(" <> .", "text/turtle", "http://example.com", oxigraph.namedNode("http://example.com/graph")); ``` -#### `Store.prototype.dump(String mimeType, NamedNode|BlankNode|DefaultGraph? fromNamedGraph)` +#### `Store.prototype.dump(String format, NamedNode|BlankNode|DefaultGraph? fromNamedGraph)` Returns serialized RDF triples or quad from the store. The method arguments are: -1. `mimeType`: the MIME type of the serialization. See below for the supported mime types. +1. `format`: the format type of the serialization. See below for the supported types. 2. `fromNamedGraph`: for triple serialization formats, the name of the named graph the triple should be loaded from. The available formats are: -* [Turtle](https://www.w3.org/TR/turtle/): `text/turtle` -* [TriG](https://www.w3.org/TR/trig/): `application/trig` -* [N-Triples](https://www.w3.org/TR/n-triples/): `application/n-triples` -* [N-Quads](https://www.w3.org/TR/n-quads/): `application/n-quads` -* [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/): `application/rdf+xml` +* [Turtle](https://www.w3.org/TR/turtle/): `text/turtle` or `ttl` +* [TriG](https://www.w3.org/TR/trig/): `application/trig` or `trig` +* [N-Triples](https://www.w3.org/TR/n-triples/): `application/n-triples` or `nt` +* [N-Quads](https://www.w3.org/TR/n-quads/): `application/n-quads` or `nq` +* [N3](https://w3c.github.io/N3/spec/): `text/n3` or `n3` +* [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/): `application/rdf+xml` or `rdf` Example of building a Turtle file from the named graph ``: ```js diff --git a/js/src/store.rs b/js/src/store.rs index bffac273..008f24f0 100644 --- a/js/src/store.rs +++ b/js/src/store.rs @@ -144,13 +144,11 @@ impl JsStore { pub fn load( &self, data: &str, - mime_type: &str, + format: &str, base_iri: &JsValue, to_graph_name: &JsValue, ) -> Result<(), JsValue> { - let Some(format) = RdfFormat::from_media_type(mime_type) else { - return Err(format_err!("Not supported MIME type: {mime_type}")); - }; + let format = rdf_format(format)?; let base_iri = if base_iri.is_null() || base_iri.is_undefined() { None } else if base_iri.is_string() { @@ -177,10 +175,8 @@ impl JsStore { .map_err(to_err) } - pub fn dump(&self, mime_type: &str, from_graph_name: &JsValue) -> Result { - let Some(format) = RdfFormat::from_media_type(mime_type) else { - return Err(format_err!("Not supported MIME type: {mime_type}")); - }; + pub fn dump(&self, format: &str, from_graph_name: &JsValue) -> Result { + let format = rdf_format(format)?; let buffer = if let Some(from_graph_name) = FROM_JS.with(|c| c.to_optional_term(from_graph_name))? { self.store @@ -192,3 +188,13 @@ impl JsStore { String::from_utf8(buffer).map_err(to_err) } } + +fn rdf_format(format: &str) -> Result { + if format.contains('/') { + RdfFormat::from_media_type(format) + .ok_or_else(|| format_err!("Not supported RDF format media type: {format}")) + } else { + RdfFormat::from_extension(format) + .ok_or_else(|| format_err!("Not supported RDF format extension: {format}")) + } +} diff --git a/python/src/io.rs b/python/src/io.rs index 9585dcdc..f365af50 100644 --- a/python/src/io.rs +++ b/python/src/io.rs @@ -22,20 +22,21 @@ pub fn add_to_module(module: &PyModule) -> PyResult<()> { /// /// It currently supports the following formats: /// -/// * `N-Triples `_ (``application/n-triples``) -/// * `N-Quads `_ (``application/n-quads``) -/// * `Turtle `_ (``text/turtle``) -/// * `TriG `_ (``application/trig``) -/// * `RDF/XML `_ (``application/rdf+xml``) +/// * `N-Triples `_ (``application/n-triples`` or ``nt``) +/// * `N-Quads `_ (``application/n-quads`` or ``nq``) +/// * `Turtle `_ (``text/turtle`` or ``ttl``) +/// * `TriG `_ (``application/trig`` or ``trig``) +/// * `N3 `_ (``text/n3`` or ``n3``) +/// * `RDF/XML `_ (``application/rdf+xml`` or ``rdf``) /// -/// It supports also some MIME type aliases. +/// It supports also some media type and extension aliases. /// For example, ``application/turtle`` could also be used for `Turtle `_ -/// and ``application/xml`` for `RDF/XML `_. +/// and ``application/xml`` or ``xml`` for `RDF/XML `_. /// /// :param input: The binary I/O object or file path to read from. For example, it could be a file path as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``. /// :type input: io(bytes) or io(str) or str or pathlib.Path -/// :param mime_type: the MIME type of the RDF serialization. -/// :type mime_type: str +/// :param format: the format of the RDF serialization using a media type like ``text/turtle`` or an extension like `ttl`. +/// :type format: str /// :param base_iri: the base IRI used to resolve the relative IRIs in the file or :py:const:`None` if relative IRI resolution should not be done. /// :type base_iri: str or None, optional /// :param without_named_graphs: Sets that the parser must fail if parsing a named graph. @@ -44,27 +45,23 @@ pub fn add_to_module(module: &PyModule) -> PyResult<()> { /// :type rename_blank_nodes: bool, optional /// :return: an iterator of RDF triples or quads depending on the format. /// :rtype: iterator(Quad) -/// :raises ValueError: if the MIME type is not supported. +/// :raises ValueError: if the format is not supported. /// :raises SyntaxError: if the provided data is invalid. /// /// >>> input = io.BytesIO(b'

"1" .') /// >>> list(parse(input, "text/turtle", base_iri="http://example.com/")) /// [ predicate= object=> graph_name=>] #[pyfunction] -#[pyo3(signature = (input, mime_type, *, base_iri = None, without_named_graphs = false, rename_blank_nodes = false))] +#[pyo3(signature = (input, format, *, base_iri = None, without_named_graphs = false, rename_blank_nodes = false))] pub fn parse( input: PyObject, - mime_type: &str, + format: &str, base_iri: Option<&str>, without_named_graphs: bool, rename_blank_nodes: bool, py: Python<'_>, ) -> PyResult { - let Some(format) = RdfFormat::from_media_type(mime_type) else { - return Err(PyValueError::new_err(format!( - "Not supported MIME type: {mime_type}" - ))); - }; + let format = rdf_format(format)?; let input = if let Ok(path) = input.extract::(py) { PyReadable::from_file(&path, py).map_err(map_io_err)? } else { @@ -92,24 +89,25 @@ pub fn parse( /// /// It currently supports the following formats: /// -/// * `N-Triples `_ (``application/n-triples``) -/// * `N-Quads `_ (``application/n-quads``) -/// * `Turtle `_ (``text/turtle``) -/// * `TriG `_ (``application/trig``) -/// * `RDF/XML `_ (``application/rdf+xml``) +/// * `N-Triples `_ (``application/n-triples`` or ``nt``) +/// * `N-Quads `_ (``application/n-quads`` or ``nq``) +/// * `Turtle `_ (``text/turtle`` or ``ttl``) +/// * `TriG `_ (``application/trig`` or ``trig``) +/// * `N3 `_ (``text/n3`` or ``n3``) +/// * `RDF/XML `_ (``application/rdf+xml`` or ``rdf``) /// -/// It supports also some MIME type aliases. +/// It supports also some media type and extension aliases. /// For example, ``application/turtle`` could also be used for `Turtle `_ -/// and ``application/xml`` for `RDF/XML `_. +/// and ``application/xml`` or ``xml`` for `RDF/XML `_. /// /// :param input: the RDF triples and quads to serialize. /// :type input: iterable(Triple) or iterable(Quad) /// :param output: The binary I/O object or file path to write to. For example, it could be a file path as a string or a file writer opened in binary mode with ``open('my_file.ttl', 'wb')``. /// :type output: io(bytes) or str or pathlib.Path -/// :param mime_type: the MIME type of the RDF serialization. -/// :type mime_type: str +/// :param format: the format of the RDF serialization using a media type like ``text/turtle`` or an extension like `ttl`. +/// :type format: str /// :rtype: None -/// :raises ValueError: if the MIME type is not supported. +/// :raises ValueError: if the format is not supported. /// :raises TypeError: if a triple is given during a quad format serialization or reverse. /// /// >>> output = io.BytesIO() @@ -117,12 +115,8 @@ pub fn parse( /// >>> output.getvalue() /// b' "1" .\n' #[pyfunction] -pub fn serialize(input: &PyAny, output: PyObject, mime_type: &str, py: Python<'_>) -> PyResult<()> { - let Some(format) = RdfFormat::from_media_type(mime_type) else { - return Err(PyValueError::new_err(format!( - "Not supported MIME type: {mime_type}" - ))); - }; +pub fn serialize(input: &PyAny, output: PyObject, format: &str, py: Python<'_>) -> PyResult<()> { + let format = rdf_format(format)?; let output = if let Ok(path) = output.extract::(py) { PyWritable::from_file(&path, py).map_err(map_io_err)? } else { @@ -293,6 +287,18 @@ impl Write for PyIo { } } +pub fn rdf_format(format: &str) -> PyResult { + if format.contains('/') { + RdfFormat::from_media_type(format).ok_or_else(|| { + PyValueError::new_err(format!("Not supported RDF format media type: {format}")) + }) + } else { + RdfFormat::from_extension(format).ok_or_else(|| { + PyValueError::new_err(format!("Not supported RDF format extension: {format}")) + }) + } +} + fn to_io_err(error: PyErr) -> io::Error { io::Error::new(io::ErrorKind::Other, error) } diff --git a/python/src/store.rs b/python/src/store.rs index da20686a..d71d4936 100644 --- a/python/src/store.rs +++ b/python/src/store.rs @@ -1,9 +1,10 @@ #![allow(clippy::needless_option_as_deref)] -use crate::io::{allow_threads_unsafe, map_io_err, map_parse_error, PyReadable, PyWritable}; +use crate::io::{ + allow_threads_unsafe, map_io_err, map_parse_error, rdf_format, PyReadable, PyWritable, +}; use crate::model::*; use crate::sparql::*; -use oxigraph::io::RdfFormat; use oxigraph::model::{GraphName, GraphNameRef}; use oxigraph::sparql::Update; use oxigraph::store::{self, LoaderError, SerializerError, StorageError, Store}; @@ -348,26 +349,27 @@ impl PyStore { /// /// It currently supports the following formats: /// - /// * `N-Triples `_ (``application/n-triples``) - /// * `N-Quads `_ (``application/n-quads``) - /// * `Turtle `_ (``text/turtle``) - /// * `TriG `_ (``application/trig``) - /// * `RDF/XML `_ (``application/rdf+xml``) + /// * `N-Triples `_ (``application/n-triples`` or ``nt``) + /// * `N-Quads `_ (``application/n-quads`` or ``nq``) + /// * `Turtle `_ (``text/turtle`` or ``ttl``) + /// * `TriG `_ (``application/trig`` or ``trig``) + /// * `N3 `_ (``text/n3`` or ``n3``) + /// * `RDF/XML `_ (``application/rdf+xml`` or ``rdf``) /// - /// It supports also some MIME type aliases. + /// It supports also some media type and extension aliases. /// For example, ``application/turtle`` could also be used for `Turtle `_ - /// and ``application/xml`` for `RDF/XML `_. + /// and ``application/xml`` or ``xml`` for `RDF/XML `_. /// /// :param input: The binary I/O object or file path to read from. For example, it could be a file path as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``. /// :type input: io(bytes) or io(str) or str or pathlib.Path - /// :param mime_type: the MIME type of the RDF serialization. - /// :type mime_type: str + /// :param format: the format of the RDF serialization using a media type like ``text/turtle`` or an extension like `ttl`. + /// :type format: str /// :param base_iri: the base IRI used to resolve the relative IRIs in the file or :py:const:`None` if relative IRI resolution should not be done. /// :type base_iri: str or None, optional /// :param to_graph: if it is a file composed of triples, the graph in which the triples should be stored. By default, the default graph is used. /// :type to_graph: NamedNode or BlankNode or DefaultGraph or None, optional /// :rtype: None - /// :raises ValueError: if the MIME type is not supported. + /// :raises ValueError: if the format is not supported. /// :raises SyntaxError: if the provided data is invalid. /// :raises OSError: if an error happens during a quad insertion. /// @@ -375,20 +377,16 @@ impl PyStore { /// >>> store.load(io.BytesIO(b'

"1" .'), "text/turtle", base_iri="http://example.com/", to_graph=NamedNode("http://example.com/g")) /// >>> list(store) /// [ predicate= object=> graph_name=>] - #[pyo3(signature = (input, mime_type, *, base_iri = None, to_graph = None))] + #[pyo3(signature = (input, format, *, base_iri = None, to_graph = None))] fn load( &self, input: PyObject, - mime_type: &str, + format: &str, base_iri: Option<&str>, to_graph: Option<&PyAny>, py: Python<'_>, ) -> PyResult<()> { - let Some(format) = RdfFormat::from_media_type(mime_type) else { - return Err(PyValueError::new_err(format!( - "Not supported MIME type: {mime_type}" - ))); - }; + let format = rdf_format(format)?; let to_graph_name = if let Some(graph_name) = to_graph { Some(GraphName::from(&PyGraphNameRef::try_from(graph_name)?)) } else { @@ -419,26 +417,27 @@ impl PyStore { /// /// It currently supports the following formats: /// - /// * `N-Triples `_ (``application/n-triples``) - /// * `N-Quads `_ (``application/n-quads``) - /// * `Turtle `_ (``text/turtle``) - /// * `TriG `_ (``application/trig``) - /// * `RDF/XML `_ (``application/rdf+xml``) + /// * `N-Triples `_ (``application/n-triples`` or ``nt``) + /// * `N-Quads `_ (``application/n-quads`` or ``nq``) + /// * `Turtle `_ (``text/turtle`` or ``ttl``) + /// * `TriG `_ (``application/trig`` or ``trig``) + /// * `N3 `_ (``text/n3`` or ``n3``) + /// * `RDF/XML `_ (``application/rdf+xml`` or ``rdf``) /// - /// It supports also some MIME type aliases. + /// It supports also some media type and extension aliases. /// For example, ``application/turtle`` could also be used for `Turtle `_ - /// and ``application/xml`` for `RDF/XML `_. + /// and ``application/xml`` or ``xml`` for `RDF/XML `_. /// /// :param input: The binary I/O object or file path to read from. For example, it could be a file path as a string or a file reader opened in binary mode with ``open('my_file.ttl', 'rb')``. /// :type input: io(bytes) or io(str) or str or pathlib.Path - /// :param mime_type: the MIME type of the RDF serialization. - /// :type mime_type: str + /// :param format: the format of the RDF serialization using a media type like ``text/turtle`` or an extension like `ttl`. + /// :type format: str /// :param base_iri: the base IRI used to resolve the relative IRIs in the file or :py:const:`None` if relative IRI resolution should not be done. /// :type base_iri: str or None, optional /// :param to_graph: if it is a file composed of triples, the graph in which the triples should be stored. By default, the default graph is used. /// :type to_graph: NamedNode or BlankNode or DefaultGraph or None, optional /// :rtype: None - /// :raises ValueError: if the MIME type is not supported. + /// :raises ValueError: if the format is not supported. /// :raises SyntaxError: if the provided data is invalid. /// :raises OSError: if an error happens during a quad insertion. /// @@ -446,20 +445,16 @@ impl PyStore { /// >>> store.bulk_load(io.BytesIO(b'

"1" .'), "text/turtle", base_iri="http://example.com/", to_graph=NamedNode("http://example.com/g")) /// >>> list(store) /// [ predicate= object=> graph_name=>] - #[pyo3(signature = (input, mime_type, *, base_iri = None, to_graph = None))] + #[pyo3(signature = (input, format, *, base_iri = None, to_graph = None))] fn bulk_load( &self, input: PyObject, - mime_type: &str, + format: &str, base_iri: Option<&str>, to_graph: Option<&PyAny>, py: Python<'_>, ) -> PyResult<()> { - let Some(format) = RdfFormat::from_media_type(mime_type) else { - return Err(PyValueError::new_err(format!( - "Not supported MIME type: {mime_type}" - ))); - }; + let format = rdf_format(format)?; let to_graph_name = if let Some(graph_name) = to_graph { Some(GraphName::from(&PyGraphNameRef::try_from(graph_name)?)) } else { @@ -488,24 +483,25 @@ impl PyStore { /// /// It currently supports the following formats: /// - /// * `N-Triples `_ (``application/n-triples``) - /// * `N-Quads `_ (``application/n-quads``) - /// * `Turtle `_ (``text/turtle``) - /// * `TriG `_ (``application/trig``) - /// * `RDF/XML `_ (``application/rdf+xml``) + /// * `N-Triples `_ (``application/n-triples`` or ``nt``) + /// * `N-Quads `_ (``application/n-quads`` or ``nq``) + /// * `Turtle `_ (``text/turtle`` or ``ttl``) + /// * `TriG `_ (``application/trig`` or ``trig``) + /// * `N3 `_ (``text/n3`` or ``n3``) + /// * `RDF/XML `_ (``application/rdf+xml`` or ``rdf``) /// - /// It supports also some MIME type aliases. + /// It supports also some media type and extension aliases. /// For example, ``application/turtle`` could also be used for `Turtle `_ - /// and ``application/xml`` for `RDF/XML `_. + /// and ``application/xml`` or ``xml`` for `RDF/XML `_. /// /// :param output: The binary I/O object or file path to write to. For example, it could be a file path as a string or a file writer opened in binary mode with ``open('my_file.ttl', 'wb')``. /// :type output: io(bytes) or str or pathlib.Path - /// :param mime_type: the MIME type of the RDF serialization. - /// :type mime_type: str + /// :param format: the format of the RDF serialization using a media type like ``text/turtle`` or an extension like `ttl`. + /// :type format: str /// :param from_graph: the store graph from which dump the triples. Required if the serialization format does not support named graphs. If it does supports named graphs the full dataset is written. /// :type from_graph: NamedNode or BlankNode or DefaultGraph or None, optional /// :rtype: None - /// :raises ValueError: if the MIME type is not supported or the `from_graph` parameter is not given with a syntax not supporting named graphs. + /// :raises ValueError: if the format is not supported or the `from_graph` parameter is not given with a syntax not supporting named graphs. /// :raises OSError: if an error happens during a quad lookup /// /// >>> store = Store() @@ -514,19 +510,15 @@ impl PyStore { /// >>> store.dump(output, "text/turtle", from_graph=NamedNode("http://example.com/g")) /// >>> output.getvalue() /// b' "1" .\n' - #[pyo3(signature = (output, mime_type, *, from_graph = None))] + #[pyo3(signature = (output, format, *, from_graph = None))] fn dump( &self, output: PyObject, - mime_type: &str, + format: &str, from_graph: Option<&PyAny>, py: Python<'_>, ) -> PyResult<()> { - let Some(format) = RdfFormat::from_media_type(mime_type) else { - return Err(PyValueError::new_err(format!( - "Not supported MIME type: {mime_type}" - ))); - }; + let format = rdf_format(format)?; let from_graph_name = if let Some(graph_name) = from_graph { Some(GraphName::from(&PyGraphNameRef::try_from(graph_name)?)) } else { diff --git a/python/tests/test_io.py b/python/tests/test_io.py index d3f535c4..e9069e08 100644 --- a/python/tests/test_io.py +++ b/python/tests/test_io.py @@ -69,7 +69,7 @@ class TestParse(unittest.TestCase): def test_parse_io_error(self) -> None: with self.assertRaises(UnsupportedOperation) as _, TemporaryFile("wb") as fp: - list(parse(fp, mime_type="application/n-triples")) + list(parse(fp, "nt")) def test_parse_quad(self) -> None: self.assertEqual( diff --git a/python/tests/test_store.py b/python/tests/test_store.py index ee02e830..a3ed8fe0 100644 --- a/python/tests/test_store.py +++ b/python/tests/test_store.py @@ -225,7 +225,7 @@ class TestStore(unittest.TestCase): store = Store() store.load( BytesIO(b" ."), - mime_type="application/n-triples", + "application/n-triples", ) self.assertEqual(set(store), {Quad(foo, bar, baz, DefaultGraph())}) @@ -233,7 +233,7 @@ class TestStore(unittest.TestCase): store = Store() store.load( BytesIO(b" ."), - mime_type="application/n-triples", + "application/n-triples", to_graph=graph, ) self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) @@ -242,7 +242,7 @@ class TestStore(unittest.TestCase): store = Store() store.load( BytesIO(b" <> ."), - mime_type="text/turtle", + "text/turtle", base_iri="http://baz", ) self.assertEqual(set(store), {Quad(foo, bar, baz, DefaultGraph())}) @@ -251,7 +251,7 @@ class TestStore(unittest.TestCase): store = Store() store.load( BytesIO(b" ."), - mime_type="application/n-quads", + "nq", ) self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) @@ -259,7 +259,7 @@ class TestStore(unittest.TestCase): store = Store() store.load( BytesIO(b" { <> . }"), - mime_type="application/trig", + "application/trig", base_iri="http://baz", ) self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) @@ -269,13 +269,13 @@ class TestStore(unittest.TestCase): file_name = Path(fp.name) fp.write(b" .") store = Store() - store.load(file_name, mime_type="application/n-quads") + store.load(file_name, "nq") file_name.unlink() self.assertEqual(set(store), {Quad(foo, bar, baz, graph)}) def test_load_with_io_error(self) -> None: with self.assertRaises(UnsupportedOperation) as _, TemporaryFile("wb") as fp: - Store().load(fp, mime_type="application/n-triples") + Store().load(fp, "application/n-triples") def test_dump_ntriples(self) -> None: store = Store() @@ -291,7 +291,7 @@ class TestStore(unittest.TestCase): store = Store() store.add(Quad(foo, bar, baz, graph)) output = BytesIO() - store.dump(output, "application/n-quads") + store.dump(output, "nq") self.assertEqual( output.getvalue(), b" .\n", @@ -314,7 +314,7 @@ class TestStore(unittest.TestCase): file_name = Path(fp.name) store = Store() store.add(Quad(foo, bar, baz, graph)) - store.dump(file_name, "application/n-quads") + store.dump(file_name, "nq") self.assertEqual( file_name.read_text(), " .\n", @@ -324,7 +324,7 @@ class TestStore(unittest.TestCase): store = Store() store.add(Quad(foo, bar, bar)) with self.assertRaises(OSError) as _, TemporaryFile("rb") as fp: - store.dump(fp, mime_type="application/trig") + store.dump(fp, "application/trig") def test_write_in_read(self) -> None: store = Store()