Sort Turtle output

rdflib/graph.py

@@ -1233,6 +1233,7 @@ def serialize(
         format: str,
         base: Optional[str],
         encoding: str,
+        sort: bool = ...,
         **args: Any,
     ) -> bytes:
         ...
@@ -1246,6 +1247,7 @@ def serialize(
         base: Optional[str] = ...,
         *,
         encoding: str,
+        sort: bool = ...,
         **args: Any,
     ) -> bytes:
         ...
@@ -1258,6 +1260,7 @@ def serialize(
         format: str = ...,
         base: Optional[str] = ...,
         encoding: None = ...,
+        sort: bool = ...,
         **args: Any,
     ) -> str:
         ...
@@ -1270,6 +1273,7 @@ def serialize(
         format: str = ...,
         base: Optional[str] = ...,
         encoding: Optional[str] = ...,
+        sort: bool = ...,
         **args: Any,
     ) -> "Graph":
         ...
@@ -1282,6 +1286,7 @@ def serialize(
         format: str = ...,
         base: Optional[str] = ...,
         encoding: Optional[str] = ...,
+        sort: bool = ...,
         **args: Any,
     ) -> Union[bytes, str, "Graph"]:
         ...
@@ -1292,6 +1297,7 @@ def serialize(
         format: str = "turtle",
         base: Optional[str] = None,
         encoding: Optional[str] = None,
+        sort: bool = ...,
         **args: Any,
     ) -> Union[bytes, str, _GraphT]:
         """
@@ -1335,14 +1341,20 @@ def serialize(
         if destination is None:
             stream = BytesIO()
             if encoding is None:
-                serializer.serialize(stream, base=base, encoding="utf-8", **args)
+                serializer.serialize(
+                    stream, base=base, encoding="utf-8", sort=sort, **args
+                )
                 return stream.getvalue().decode("utf-8")
             else:
-                serializer.serialize(stream, base=base, encoding=encoding, **args)
+                serializer.serialize(
+                    stream, base=base, encoding=encoding, sort=sort, **args
+                )
                 return stream.getvalue()
         if hasattr(destination, "write"):
             stream = cast(IO[bytes], destination)
-            serializer.serialize(stream, base=base, encoding=encoding, **args)
+            serializer.serialize(
+                stream, base=base, encoding=encoding, sort=sort, **args
+            )
         else:
             if isinstance(destination, pathlib.PurePath):
                 os_path = str(destination)
@@ -1358,7 +1370,7 @@ def serialize(
                 else:
                     os_path = location
             with open(os_path, "wb") as stream:
-                serializer.serialize(stream, encoding=encoding, **args)
+                serializer.serialize(stream, encoding=encoding, sort=sort, **args)
         return self
 
     def print(

rdflib/plugins/serializers/turtle.py

@@ -5,11 +5,12 @@
 
 from collections import defaultdict
 from functools import cmp_to_key
+from typing import Dict, List
 
 from rdflib.exceptions import Error
 from rdflib.namespace import RDF, RDFS
 from rdflib.serializer import Serializer
-from rdflib.term import BNode, Literal, URIRef
+from rdflib.term import BNode, IdentifiedNode, Literal, URIRef
 
 __all__ = ["RecursiveSerializer", "TurtleSerializer"]
 
@@ -73,9 +74,9 @@ def isDone(self, subject):
         """Return true if subject is serialized"""
         return subject in self._serialized
 
-    def orderSubjects(self):
-        seen = {}
-        subjects = []
+    def orderSubjects(self) -> List[IdentifiedNode]:
+        seen: Dict[IdentifiedNode, bool] = {}
+        subjects: List[IdentifiedNode] = []
 
         for classURI in self.topClasses:
             members = list(self.store.subjects(RDF.type, classURI))
@@ -223,7 +224,15 @@ def reset(self):
         self._started = False
         self._ns_rewrite = {}
 
-    def serialize(self, stream, base=None, encoding=None, spacious=None, **args):
+    def serialize(
+        self,
+        stream,
+        base=None,
+        encoding=None,
+        spacious=None,
+        sort: bool = False,
+        **args,
+    ) -> None:
         self.reset()
         self.stream = stream
         # if base is given here, use that, if not and a base is set for the graph use that

rdflib/serializer.py

@@ -21,7 +21,7 @@
 
 
 class Serializer:
-    def __init__(self, store: "Graph"):
+    def __init__(self, store: "Graph") -> None:
         self.store: "Graph" = store
         self.encoding: str = "utf-8"
         self.base: Optional[str] = None
@@ -31,6 +31,7 @@ def serialize(
         stream: IO[bytes],
         base: Optional[str] = None,
         encoding: Optional[str] = None,
+        sort: bool = False,
         **args,
     ) -> None:
         """Abstract method"""

test/test_turtle_sort_issue1890.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+
+# This software was developed at the National Institute of Standards
+# and Technology by employees of the Federal Government in the course
+# of their official duties. Pursuant to title 17 Section 105 of the
+# United States Code this software is not subject to copyright
+# protection and is in the public domain. NIST assumes no
+# responsibility whatsoever for its use by other parties, and makes
+# no guarantees, expressed or implied, about its quality,
+# reliability, or any other characteristic.
+#
+# We would appreciate acknowledgement if the software is used.
+
+import random
+from collections import defaultdict
+from typing import DefaultDict, List
+
+from rdflib import RDFS, BNode, Graph, Literal, Namespace, URIRef
+
+
+def test_sort_semiblank_graph() -> None:
+    """
+    This test reviews whether the output of the Turtle form is
+    consistent when involving repeated generates with blank nodes.
+    """
+
+    EX = Namespace("http://example.org/ex/")
+
+    serialization_counter: DefaultDict[str, int] = defaultdict(int)
+
+    first_graph_text: str = ""
+
+    # Use a fixed sequence of once-but-no-longer random values for more
+    # consistent test results.
+    nonrandom_shuffler = random.Random(1234)
+    for x in range(1, 10):
+        graph = Graph()
+        graph.bind("ex", EX)
+        graph.bind("rdfs", RDFS)
+
+        graph.add((EX.A, RDFS.comment, Literal("Thing A")))
+        graph.add((EX.B, RDFS.comment, Literal("Thing B")))
+        graph.add((EX.C, RDFS.comment, Literal("Thing C")))
+
+        nodes: List[URIRef] = [EX.A, EX.B, EX.C, EX.B]
+        nonrandom_shuffler.shuffle(nodes)
+        for node in nodes:
+            # Instantiate one bnode per URIRef node.
+            graph.add((BNode(), RDFS.seeAlso, node))
+
+        nesteds: List[URIRef] = [EX.A, EX.B, EX.C]
+        nonrandom_shuffler.shuffle(nesteds)
+        for nested in nesteds:
+            # Instantiate a nested node reference.
+            outer_node = BNode()
+            inner_node = BNode()
+            graph.add((outer_node, EX.has, inner_node))
+            graph.add((inner_node, RDFS.seeAlso, nested))
+
+        graph_text = graph.serialize(format="turtle", sort=True)
+        if first_graph_text == "":
+            first_graph_text = graph_text
+
+        serialization_counter[graph_text] += 1
+
+    expected_serialization = """
+@prefix ex: <http://example.org/ex/> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+ex:A rdfs:comment "Thing A" .
+
+ex:B rdfs:comment "Thing B" .
+
+ex:C rdfs:comment "Thing C" .
+
+[] ex:has [ rdfs:seeAlso ex:A ] .
+
+[] ex:has [ rdfs:seeAlso ex:B ] .
+
+[] ex:has [ rdfs:seeAlso ex:C ] .
+
+[] rdfs:seeAlso ex:A .
+
+[] rdfs:seeAlso ex:B .
+
+[] rdfs:seeAlso ex:B .
+
+[] rdfs:seeAlso ex:C .
+"""
+
+    assert expected_serialization.strip() == first_graph_text.strip()
+    assert 1 == len(serialization_counter)