Add namespace_manager argument for n3 method on Paths

rdflib/paths.py

@@ -188,6 +188,7 @@
 
 if TYPE_CHECKING:
     from rdflib.graph import Graph, _ObjectType, _SubjectType
+    from rdflib.namespace import NamespaceManager
 
 
 # property paths
@@ -233,8 +234,8 @@ def eval(self, graph, subj=None, obj=None):
     def __repr__(self):
         return "Path(~%s)" % (self.arg,)
 
-    def n3(self):
-        return "^%s" % self.arg.n3()
+    def n3(self, namespace_manager: Optional["NamespaceManager"] = None) -> str:
+        return "^%s" % self.arg.n3(namespace_manager)
 
 
 class SequencePath(Path):
@@ -277,8 +278,8 @@ def _eval_seq_bw(paths, subj, obj):
     def __repr__(self):
         return "Path(%s)" % " / ".join(str(x) for x in self.args)
 
-    def n3(self):
-        return "/".join(a.n3() for a in self.args)
+    def n3(self, namespace_manager: Optional["NamespaceManager"] = None) -> str:
+        return "/".join(a.n3(namespace_manager) for a in self.args)
 
 
 class AlternativePath(Path):
@@ -298,8 +299,8 @@ def eval(self, graph, subj=None, obj=None):
     def __repr__(self):
         return "Path(%s)" % " | ".join(str(x) for x in self.args)
 
-    def n3(self):
-        return "|".join(a.n3() for a in self.args)
+    def n3(self, namespace_manager: Optional["NamespaceManager"] = None) -> str:
+        return "|".join(a.n3(namespace_manager) for a in self.args)
 
 
 class MulPath(Path):
@@ -402,8 +403,8 @@ def _all_fwd_paths():
     def __repr__(self):
         return "Path(%s%s)" % (self.path, self.mod)
 
-    def n3(self):
-        return "%s%s" % (self.path.n3(), self.mod)
+    def n3(self, namespace_manager: Optional["NamespaceManager"] = None) -> str:
+        return "%s%s" % (self.path.n3(namespace_manager), self.mod)
 
 
 class NegatedPath(Path):
@@ -435,8 +436,8 @@ def eval(self, graph, subj=None, obj=None):
     def __repr__(self):
         return "Path(! %s)" % ",".join(str(x) for x in self.args)
 
-    def n3(self):
-        return "!(%s)" % ("|".join(self.args))
+    def n3(self, namespace_manager: Optional["NamespaceManager"] = None) -> str:
+        return "!(%s)" % ("|".join(arg.n3(namespace_manager) for arg in self.args))
 
 
 class PathList(list):

test/test_paths_n3.py

@@ -0,0 +1,73 @@
+import logging
+from typing import Union
+
+import pytest
+
+from rdflib import RDF, RDFS, Graph
+from rdflib.paths import (
+    AlternativePath,
+    InvPath,
+    MulPath,
+    NegatedPath,
+    OneOrMore,
+    SequencePath,
+    ZeroOrMore,
+    ZeroOrOne,
+)
+
+g = Graph()
+nsm = g.namespace_manager
+
+
+@pytest.mark.parametrize(
+    "path, no_nsm, with_nsm",
+    [
+        (~RDF.type, f"^<{RDF.type}>", "^rdf:type"),
+        (
+            RDF.type / RDFS.subClassOf,
+            f"<{RDF.type}>/<{RDFS.subClassOf}>",
+            "rdf:type/rdfs:subClassOf",
+        ),
+        (
+            RDF.type | RDFS.subClassOf,
+            f"<{RDF.type}>|<{RDFS.subClassOf}>",
+            "rdf:type|rdfs:subClassOf",
+        ),
+        (-RDF.type, f"!(<{RDF.type}>)", "!(rdf:type)"),
+        # type errors: Unsupported operand types for * ("URIRef" and "str")
+        # note on type errors: The operator is defined but in an odd place
+        (
+            RDFS.subClassOf * ZeroOrMore,  # type: ignore[operator]
+            f"<{RDFS.subClassOf}>*",
+            "rdfs:subClassOf*",
+        ),
+        (
+            RDFS.subClassOf * OneOrMore,  # type: ignore[operator]
+            f"<{RDFS.subClassOf}>+",
+            "rdfs:subClassOf+",
+        ),
+        (
+            RDFS.subClassOf * ZeroOrOne,  # type: ignore[operator]
+            f"<{RDFS.subClassOf}>?",
+            "rdfs:subClassOf?",
+        ),
+        (
+            RDF.type / RDFS.subClassOf * "*",
+            f"<{RDF.type}>/<{RDFS.subClassOf}>*",
+            "rdf:type/rdfs:subClassOf*",
+        ),
+        (
+            -(RDF.type | RDFS.subClassOf),
+            f"!(<{RDF.type}>|<{RDFS.subClassOf}>)",
+            "!(rdf:type|rdfs:subClassOf)",
+        ),
+    ],
+)
+def test_paths_n3(
+    path: Union[InvPath, SequencePath, AlternativePath, MulPath, NegatedPath],
+    no_nsm: str,
+    with_nsm: str,
+) -> None:
+    logging.debug("path = %s", path)
+    assert path.n3() == no_nsm
+    assert path.n3(nsm) == with_nsm