Skip to content

n3

Notation 3 (N3) RDF graph serializer for RDFLib.

Classes:

SWAP_LOG module-attribute 

SWAP_LOG = Namespace('http://www.w3.org/2000/10/swap/log#')

__all__ module-attribute 

__all__ = ['N3Serializer']

N3Serializer 

N3Serializer(store: Graph, parent=None)

Bases: TurtleSerializer

Notation 3 (N3) RDF graph serializer.

Methods:

Attributes:

Source code in rdflib/plugins/serializers/n3.py 
19
20
21
22
def __init__(self, store: Graph, parent=None):
    super(N3Serializer, self).__init__(store)
    self.keywords.update({OWL.sameAs: "=", SWAP_LOG.implies: "=>"})
    self.parent = parent

parent instance-attribute 

parent = parent

short_name class-attribute instance-attribute 

short_name = 'n3'

endDocument 

endDocument()
Source code in rdflib/plugins/serializers/n3.py 
28
29
30
def endDocument(self):  # noqa: N802
    if not self.parent:
        super(N3Serializer, self).endDocument()

getQName 

getQName(uri, gen_prefix=True)
Source code in rdflib/plugins/serializers/n3.py 
50
51
52
53
54
55
56
def getQName(self, uri, gen_prefix=True):  # noqa: N802
    qname = None
    if self.parent is not None:
        qname = self.parent.getQName(uri, gen_prefix)
    if qname is None:
        qname = super(N3Serializer, self).getQName(uri, gen_prefix)
    return qname

indent 

indent(modifier=0)
Source code in rdflib/plugins/serializers/n3.py 
32
33
34
35
36
def indent(self, modifier=0):
    indent = super(N3Serializer, self).indent(modifier)
    if self.parent is not None:
        indent += self.parent.indent()  # modifier)
    return indent

p_clause 

p_clause(node, position)
Source code in rdflib/plugins/serializers/n3.py 
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
def p_clause(self, node, position):
    if isinstance(node, Graph):
        self.subjectDone(node)
        if position is OBJECT:
            self.write(" ")
        self.write("{")
        self.depth += 1
        serializer = N3Serializer(node, parent=self)
        # type error: Argument 1 to "serialize" of "TurtleSerializer" has incompatible type "Optional[IO[bytes]]"; expected "IO[bytes]"
        serializer.serialize(self.stream)  # type: ignore[arg-type]
        self.depth -= 1
        self.write(self.indent() + "}")
        return True
    else:
        return False

path 

path(node, position, newline=False)
Source code in rdflib/plugins/serializers/n3.py 
65
66
67
def path(self, node, position, newline=False):
    if not self.p_clause(node, position):
        super(N3Serializer, self).path(node, position, newline)

preprocessTriple 

preprocessTriple(triple)
Source code in rdflib/plugins/serializers/n3.py 
38
39
40
41
42
43
44
45
46
47
48
def preprocessTriple(self, triple):  # noqa: N802
    super(N3Serializer, self).preprocessTriple(triple)
    if isinstance(triple[0], Graph):
        for t in triple[0]:
            self.preprocessTriple(t)
    if isinstance(triple[1], Graph):
        for t in triple[1]:
            self.preprocessTriple(t)
    if isinstance(triple[2], Graph):
        for t in triple[2]:
            self.preprocessTriple(t)

reset 

reset()
Source code in rdflib/plugins/serializers/n3.py 
24
25
26
def reset(self):
    super(N3Serializer, self).reset()
    self._stores = {}

s_clause 

s_clause(subject)
Source code in rdflib/plugins/serializers/n3.py 
69
70
71
72
73
74
75
76
77
def s_clause(self, subject):
    if isinstance(subject, Graph):
        self.write("\n" + self.indent())
        self.p_clause(subject, SUBJECT)
        self.predicateList(subject)
        self.write(" .")
        return True
    else:
        return False

statement 

statement(subject)
Source code in rdflib/plugins/serializers/n3.py 
58
59
60
61
62
63
def statement(self, subject):
    self.subjectDone(subject)
    properties = self.buildPredicateHash(subject)
    if len(properties) == 0:
        return False
    return self.s_clause(subject) or super(N3Serializer, self).statement(subject)