Source code

Download source archive ↓

src/rdflib/plugins/serializers/xmlwriter.py

1from __future__ import annotations
2
3import codecs
4from typing import IO, TYPE_CHECKING, Dict, Iterable, List, Optional, Tuple
5from xml.sax.saxutils import escape, quoteattr
6
7from rdflib.term import URIRef
8
9if TYPE_CHECKING:
10    from rdflib.namespace import Namespace, NamespaceManager
11
12
13__all__ = ["XMLWriter"]
14
15ESCAPE_ENTITIES = {"\r": "
"}
16
17
18class XMLWriter:
19    """A simple XML writer that writes to a stream."""
20
21    def __init__(
22        self,
23        stream: IO[bytes],
24        namespace_manager: NamespaceManager,
25        encoding: Optional[str] = None,
26        decl: int = 1,
27        extra_ns: Optional[Dict[str, Namespace]] = None,
28    ):
29        encoding = encoding or "utf-8"
30        encoder, decoder, stream_reader, stream_writer = codecs.lookup(encoding)
31        # NOTE on type ignores: this is mainly because the variable is being re-used.
32        # type error: Incompatible types in assignment (expression has type "StreamWriter", variable has type "IO[bytes]")
33        self.stream = stream = stream_writer(stream)  # type: ignore[assignment]
34        if decl:
35            # type error: No overload variant of "write" of "IO" matches argument type "str"
36            stream.write('<?xml version="1.0" encoding="%s"?>' % encoding)  # type: ignore[call-overload]
37        self.element_stack: List[str] = []
38        self.nm = namespace_manager
39        self.extra_ns = extra_ns or {}
40        self.closed = True
41
42    def __get_indent(self) -> str:
43        return "  " * len(self.element_stack)
44
45    indent = property(__get_indent)
46
47    def __close_start_tag(self) -> None:
48        if not self.closed:  # TODO:
49            self.closed = True
50            self.stream.write(">")
51
52    def push(self, uri: str) -> None:
53        self.__close_start_tag()
54        write = self.stream.write
55        write("\n")
56        write(self.indent)
57        write("<%s" % self.qname(uri))
58        self.element_stack.append(uri)
59        self.closed = False
60        self.parent = False
61
62    def pop(self, uri: Optional[str] = None) -> None:
63        top = self.element_stack.pop()
64        if uri:
65            assert uri == top
66        write = self.stream.write
67        if not self.closed:
68            self.closed = True
69            write("/>")
70        else:
71            if self.parent:
72                write("\n")
73                write(self.indent)
74            write("</%s>" % self.qname(top))
75        self.parent = True
76
77    def element(
78        self, uri: str, content: str, attributes: Dict[URIRef, str] = {}
79    ) -> None:
80        """Utility method for adding a complete simple element"""
81        self.push(uri)
82        for k, v in attributes.items():
83            self.attribute(k, v)
84        self.text(content)
85        self.pop()
86
87    def namespaces(self, namespaces: Iterable[Tuple[str, str]] = None) -> None:
88        if not namespaces:
89            namespaces = self.nm.namespaces()
90
91        write = self.stream.write
92        write("\n")
93        for prefix, namespace in namespaces:
94            if prefix:
95                write('  xmlns:%s="%s"\n' % (prefix, namespace))
96            # Allow user-provided namespace bindings to prevail
97            elif prefix not in self.extra_ns:
98                write('  xmlns="%s"\n' % namespace)
99
100        for prefix, namespace in self.extra_ns.items():
101            if prefix:
102                write('  xmlns:%s="%s"\n' % (prefix, namespace))
103            else:
104                write('  xmlns="%s"\n' % namespace)
105
106    def attribute(self, uri: str, value: str) -> None:
107        write = self.stream.write
108        write(" %s=%s" % (self.qname(uri), quoteattr(value)))
109
110    def text(self, text: str) -> None:
111        self.__close_start_tag()
112        if "<" in text and ">" in text and "]]>" not in text:
113            self.stream.write("<![CDATA[")
114            self.stream.write(text)
115            self.stream.write("]]>")
116        else:
117            self.stream.write(escape(text, ESCAPE_ENTITIES))
118
119    def qname(self, uri: str) -> str:
120        """Compute qname for a uri using our extra namespaces,
121        or the given namespace manager"""
122
123        for pre, ns in self.extra_ns.items():
124            if uri.startswith(ns):
125                if pre != "":
126                    return ":".join([pre, uri[len(ns) :]])
127                else:
128                    return uri[len(ns) :]
129
130        return self.nm.qname_strict(uri)