Retain literal types in collection backend

tests/test_collection.py → tests/backends/test_collection.py

@@ -34,19 +34,20 @@ def test_collection():
     ts.remove(object=EMMO.Mass)
     assert set(ts.triples()) == set(triples[:-1])
 
-
-# TODO: Fix handling of Literal in Collections (Issue #160, PR #165) and
-# reactivate test.
-#
-#    # Test that we can initialise from an existing collection
-#    coll = dlite.Collection()
-#    for triple in triples:
-#        coll.add_relation(*triple)
-#    ts2 = Triplestore(backend="collection", collection=coll)
-#    assert set(ts2.triples()) == set(triples)
-#
-#    # Test serialising/parsing
-#    dump = ts.serialize(backend="rdflib")
-#    ts3 = Triplestore(backend="collection")
-#    ts3.parse(backend="rdflib", data=dump)
-#    assert set(ts3.triples()) == set(triples)
+    # Test that we can initialise from an existing collection
+    coll = dlite.Collection()
+    coll.add_relation(STRUCTURE.name, DM.hasLabel, "Strontium titanate", "@en")
+    coll.add_relation(STRUCTURE.masses, DM.hasUnit, "u", XSD.string)
+    for triple in triples[2:]:
+        coll.add_relation(*triple)
+    ts2 = Triplestore(backend="collection", collection=coll)
+    assert set(ts2.triples()) == set(triples)
+
+    # Test serialising/parsing
+    dump = ts.serialize()
+    ts3 = Triplestore(backend="collection")
+    ts3.parse(data=dump)
+    assert set(ts3.triples()) == set(ts.triples())
+    label = ts3.value(STRUCTURE.name, DM.hasLabel)
+    assert isinstance(label, Literal)
+    assert label == Literal("Strontium titanate", lang="en")

tests/test_triplestore.py

@@ -62,12 +62,8 @@ def test_triplestore(  # pylint: disable=too-many-locals
         standard="fno",
     )
 
-    try:
-        ts_as_turtle = ts.serialize(format="turtle")
-    except NotImplementedError:
-        pass
-    else:
-        assert ts_as_turtle == expected_function_triplestore
+    ts_as_turtle = ts.serialize(format="turtle")
+    assert ts_as_turtle == expected_function_triplestore
 
     # Test SPARQL query
     try:

tripper/backends/collection.py

@@ -66,31 +66,37 @@ def triples(self, triple: "Triple") -> "Generator[Triple, None, None]":
             else:
                 yield s, p, o
 
-    def add_triples(self, triples: "Sequence[Triple]"):
+    def add_triples(
+        self, triples: "Union[Sequence[Triple], Generator[Triple, None, None]]"
+    ):
         """Add a sequence of triples."""
         for s, p, o in triples:
             # Strange complains by mypy - it assumed that
             # parse_object() is returning a `str` regardless that it
             # has been declared to return the union of `str` and
             # `Literal`.
             v = parse_object(o)
-            o = v if isinstance(v, str) else v.value
+
+            # Possible bug in mypy
+            # parse_object() is declared to return "Union[str, Literal]".
+            # Dispite of that complains mypy about that `v` has no
+            # attribute "value"
+            obj = v if isinstance(v, str) else str(v.value)  # type: ignore
             d = (
                 None
                 if not isinstance(v, Literal)
                 else f"@{v.lang}" if v.lang else v.datatype
             )
-            self.collection.add_relation(s, p, o, d)
+            self.collection.add_relation(s, p, obj, d)
 
     def remove(self, triple: "Triple"):
         """Remove all matching triples from the backend."""
         s, p, o = triple
         v = parse_object(o)
-        o = v if isinstance(v, str) else v.value
+        obj = v if isinstance(v, str) else str(v.value)  # type: ignore
         d = (
             None
-            if isinstance(v, str)
+            if not isinstance(v, Literal)
             else f"@{v.lang}" if v.lang else v.datatype
         )
-        # v_str = v.n3() if isinstance(v, Literal) else v
-        self.collection.remove_relations(s, p, o, d)
+        self.collection.remove_relations(s, p, obj, d)

tripper/triplestore.py

@@ -294,33 +294,35 @@ def parse(
         self,
         source=None,
         format=None,
-        backend=None,
-        backend_kwargs=None,
+        fallback_backend="rdflib",
+        fallback_backend_kwargs=None,
         **kwargs,  # pylint: disable=redefined-builtin
     ) -> None:
         """Parse source and add the resulting triples to triplestore.
 
         Parameters:
             source: File-like object or file name.
             format: Needed if format can not be inferred from source.
-            backend: If given, use the parse() method of the specified
-                backend instead of the current backend.
-            backend_kwargs: Dict with additional keyword arguments passed
-                when instantiating `backend`.
+            fallback_backend: If the current backend doesn't implement
+                parse, use the `fallback_backend` instead.
+            fallback_backend_kwargs: Dict with additional keyword arguments
+                for initialising `fallback_backend`.
             kwargs: Keyword arguments passed to the backend.
                 The rdflib backend supports e.g. `location` (absolute
                 or relative URL) and `data` (string containing the
                 data to be parsed) arguments.
         """
-        if backend and backend != self.backend_name:
-            if backend_kwargs is None:
-                backend_kwargs = {}
-            ts = Triplestore(backend=backend, **backend_kwargs)
-            ts.parse(source=source, format=format, **kwargs)
-            self.add_triples(ts.triples())
-        else:
+        if hasattr(self.backend, "parse"):
             self._check_method("parse")
             self.backend.parse(source=source, format=format, **kwargs)
+        else:
+            if fallback_backend_kwargs is None:
+                fallback_backend_kwargs = {}
+            ts = Triplestore(
+                backend=fallback_backend, **fallback_backend_kwargs
+            )
+            ts.parse(source=source, format=format, **kwargs)
+            self.add_triples(ts.triples())
 
         if hasattr(self.backend, "namespaces"):
             for prefix, namespace in self.backend.namespaces().items():
@@ -331,8 +333,8 @@ def serialize(
         self,
         destination=None,
         format="turtle",  # pylint: disable=redefined-builtin
-        backend=None,
-        backend_kwargs=None,
+        fallback_backend="rdflib",
+        fallback_backend_kwargs=None,
         **kwargs,
     ) -> "Union[None, str]":
         """Serialise triplestore.
@@ -342,28 +344,28 @@ def serialize(
                 serialisation is returned.
             format: Format to serialise as.  Supported formats, depends on
                 the backend.
-            backend: If given, use the parse() method of the specified
-                backend instead of the current backend.
-            backend_kwargs: Dict with additional keyword arguments passed
-                when instantiating `backend`.
+            fallback_backend: If the current backend doesn't implement
+                serialisation, use the `fallback_backend` instead.
+            fallback_backend_kwargs: Dict with additional keyword arguments
+                for initialising `fallback_backend`.
             kwargs: Passed to the backend serialize() method.
 
         Returns:
             Serialized string if `destination` is None.
         """
-        if backend and backend != self.backend_name:
-            if backend_kwargs is None:
-                backend_kwargs = {}
-            ts = Triplestore(backend=backend, **backend_kwargs)
-            ts.add_triples(self.triples())
-            return ts.serialize(
+        if hasattr(self.backend, "parse"):
+            self._check_method("serialize")
+            return self.backend.serialize(
                 destination=destination, format=format, **kwargs
             )
 
-        self._check_method("serialize")
-        return self.backend.serialize(
-            destination=destination, format=format, **kwargs
-        )
+        if fallback_backend_kwargs is None:
+            fallback_backend_kwargs = {}
+        ts = Triplestore(backend=fallback_backend, **fallback_backend_kwargs)
+        ts.add_triples(self.triples())
+        for prefix, iri in self.namespaces.items():
+            ts.bind(prefix, iri)
+        return ts.serialize(destination=destination, format=format, **kwargs)
 
     def query(self, query_object, **kwargs) -> "List[Tuple[str, ...]]":
         """SPARQL query.