Source code

Download source archive ↓

src/rdflib/plugins/parsers/trix.py

1"""
2A TriX parser for RDFLib
3"""
4
5from __future__ import annotations
6
7from typing import TYPE_CHECKING, Any, Dict, List, NoReturn, Optional, Tuple
8from xml.sax import handler, make_parser
9from xml.sax.handler import ErrorHandler
10
11from rdflib.exceptions import ParserError
12from rdflib.graph import Graph
13from rdflib.namespace import Namespace
14from rdflib.parser import InputSource, Parser
15from rdflib.store import Store
16from rdflib.term import BNode, Identifier, Literal, URIRef
17
18if TYPE_CHECKING:
19    # from xml.sax.expatreader import ExpatLocator
20    from xml.sax.xmlreader import AttributesImpl, Locator, XMLReader
21
22__all__ = ["create_parser", "TriXHandler", "TriXParser"]
23
24
25TRIXNS = Namespace("http://www.w3.org/2004/03/trix/trix-1/")
26XMLNS = Namespace("http://www.w3.org/XML/1998/namespace")
27
28
29class TriXHandler(handler.ContentHandler):
30    """An Sax Handler for TriX. See http://sw.nokia.com/trix/"""
31
32    lang: Optional[str]
33    datatype: Optional[str]
34
35    def __init__(self, store: Store):
36        self.store = store
37        self.preserve_bnode_ids = False
38        self.reset()
39
40    def reset(self) -> None:
41        self.bnode: Dict[str, BNode] = {}
42        self.graph: Optional[Graph] = None
43        self.triple: Optional[List[Identifier]] = None
44        self.state = 0
45        self.lang = None
46        self.datatype = None
47
48    # ContentHandler methods
49
50    def setDocumentLocator(self, locator: Locator):
51        self.locator = locator
52
53    def startDocument(self) -> None:
54        pass
55
56    def startPrefixMapping(self, prefix: Optional[str], namespace: str) -> None:
57        pass
58
59    def endPrefixMapping(self, prefix: Optional[str]) -> None:
60        pass
61
62    def startElementNS(
63        self, name: Tuple[Optional[str], str], qname, attrs: AttributesImpl
64    ) -> None:
65        if name[0] != str(TRIXNS):
66            self.error(
67                "Only elements in the TriX namespace are allowed. %s!=%s"
68                % (name[0], TRIXNS)
69            )
70
71        if name[1].lower() == "trix":
72            if self.state == 0:
73                self.state = 1
74            else:
75                self.error("Unexpected TriX element")
76
77        elif name[1] == "graph":
78            if self.state == 1:
79                self.state = 2
80            else:
81                self.error("Unexpected graph element")
82
83        elif name[1] == "uri":
84            if self.state == 2:
85                # the context uri
86                self.state = 3
87            elif self.state == 4:
88                # part of a triple
89                pass
90            else:
91                self.error("Unexpected uri element")
92
93        elif name[1] == "triple":
94            if self.state == 2:
95                if self.graph is None:
96                    # anonymous graph, create one with random bnode id
97                    self.graph = Graph(store=self.store)
98                # start of a triple
99                self.triple = []
100                self.state = 4
101            else:
102                self.error("Unexpected triple element")
103
104        elif name[1] == "typedLiteral":
105            if self.state == 4:
106                # part of triple
107                self.lang = None
108                self.datatype = None
109
110                try:
111                    self.lang = attrs.getValue((str(XMLNS), "lang"))  # type: ignore[arg-type, unused-ignore]
112                except Exception:
113                    # language not required - ignore
114                    pass
115                try:
116                    self.datatype = attrs.getValueByQName("datatype")  # type: ignore[arg-type, unused-ignore]
117                except KeyError:
118                    self.error("No required attribute 'datatype'")
119            else:
120                self.error("Unexpected typedLiteral element")
121
122        elif name[1] == "plainLiteral":
123            if self.state == 4:
124                # part of triple
125                self.lang = None
126                self.datatype = None
127                try:
128                    # type error: Argument 1 to "getValue" of "AttributesImpl" has incompatible type "Tuple[str, str]"; expected "str"
129                    self.lang = attrs.getValue((str(XMLNS), "lang"))  # type: ignore[arg-type, unused-ignore]
130                except Exception:
131                    # language not required - ignore
132                    pass
133
134            else:
135                self.error("Unexpected plainLiteral element")
136
137        elif name[1] == "id":
138            if self.state == 2:
139                # the context uri
140                self.state = 3
141
142            elif self.state == 4:
143                # part of triple
144                pass
145            else:
146                self.error("Unexpected id element")
147
148        else:
149            self.error("Unknown element %s in TriX namespace" % name[1])
150
151        self.chars = ""
152
153    def endElementNS(self, name: Tuple[Optional[str], str], qname) -> None:
154        if TYPE_CHECKING:
155            assert self.triple is not None
156        if name[0] != str(TRIXNS):
157            self.error(
158                "Only elements in the TriX namespace are allowed. %s!=%s"
159                % (name[0], TRIXNS)
160            )
161
162        if name[1] == "uri":
163            if self.state == 3:
164                self.graph = Graph(
165                    store=self.store, identifier=URIRef(self.chars.strip())
166                )
167                self.state = 2
168            elif self.state == 4:
169                self.triple += [URIRef(self.chars.strip())]
170            else:
171                self.error(
172                    "Illegal internal self.state - This should never "
173                    + "happen if the SAX parser ensures XML syntax correctness"
174                )
175
176        elif name[1] == "id":
177            if self.state == 3:
178                self.graph = Graph(
179                    self.store, identifier=self.get_bnode(self.chars.strip())
180                )
181                self.state = 2
182            elif self.state == 4:
183                self.triple += [self.get_bnode(self.chars.strip())]
184            else:
185                self.error(
186                    "Illegal internal self.state - This should never "
187                    + "happen if the SAX parser ensures XML syntax correctness"
188                )
189
190        elif name[1] == "plainLiteral" or name[1] == "typedLiteral":
191            if self.state == 4:
192                self.triple += [
193                    Literal(self.chars, lang=self.lang, datatype=self.datatype)
194                ]
195            else:
196                self.error(
197                    "This should never happen if the SAX parser "
198                    + "ensures XML syntax correctness"
199                )
200
201        elif name[1] == "triple":
202            if self.state == 4:
203                if len(self.triple) != 3:
204                    self.error(
205                        "Triple has wrong length, got %d elements: %s"
206                        % (len(self.triple), self.triple)
207                    )
208                # type error: Item "None" of "Optional[Graph]" has no attribute "add"
209                # type error: Argument 1 to "add" of "Graph" has incompatible type "List[Identifier]"; expected "Tuple[Node, Node, Node]"
210                self.graph.add(self.triple)  # type: ignore[union-attr, arg-type]
211                # self.store.store.add(self.triple,context=self.graph)
212                # self.store.addN([self.triple+[self.graph]])
213                self.state = 2
214            else:
215                self.error(
216                    "This should never happen if the SAX parser "
217                    + "ensures XML syntax correctness"
218                )
219
220        elif name[1] == "graph":
221            self.graph = None
222            self.state = 1
223
224        elif name[1].lower() == "trix":
225            self.state = 0
226
227        else:
228            self.error("Unexpected close element")
229
230    def get_bnode(self, label: str) -> BNode:
231        if self.preserve_bnode_ids:
232            bn = BNode(label)
233        else:
234            if label in self.bnode:
235                bn = self.bnode[label]
236            else:
237                bn = BNode(label)
238                self.bnode[label] = bn
239        return bn
240
241    def characters(self, content: str) -> None:
242        self.chars += content
243
244    def ignorableWhitespace(self, content) -> None:
245        pass
246
247    def processingInstruction(self, target, data) -> None:
248        pass
249
250    def error(self, message: str) -> NoReturn:
251        locator = self.locator
252        info = "%s:%s:%s: " % (
253            locator.getSystemId(),
254            locator.getLineNumber(),
255            locator.getColumnNumber(),
256        )
257        raise ParserError(info + message)
258
259
260def create_parser(store: Store) -> XMLReader:
261    parser = make_parser()
262    try:
263        # Workaround for bug in expatreader.py. Needed when
264        # expatreader is trying to guess a prefix.
265        # type error: "XMLReader" has no attribute "start_namespace_decl"
266        parser.start_namespace_decl("xml", "http://www.w3.org/XML/1998/namespace")  # type: ignore[attr-defined]
267    except AttributeError:
268        pass  # Not present in Jython (at least)
269    parser.setFeature(handler.feature_namespaces, 1)
270    trix = TriXHandler(store)
271    parser.setContentHandler(trix)
272    parser.setErrorHandler(ErrorHandler())
273    return parser
274
275
276class TriXParser(Parser):
277    """A parser for TriX. See http://sw.nokia.com/trix/"""
278
279    def __init__(self):
280        pass
281
282    def parse(self, source: InputSource, sink: Graph, **args: Any) -> None:
283        assert (
284            sink.store.context_aware
285        ), "TriXParser must be given a context aware store."
286
287        self._parser = create_parser(sink.store)
288        content_handler = self._parser.getContentHandler()
289        preserve_bnode_ids = args.get("preserve_bnode_ids", None)
290        if preserve_bnode_ids is not None:
291            # type error: ContentHandler has no attribute "preserve_bnode_ids"
292            content_handler.preserve_bnode_ids = preserve_bnode_ids  # type: ignore[attr-defined, unused-ignore]
293        # We're only using it once now
294        # content_handler.reset()
295        # self._parser.reset()
296        self._parser.parse(source)