gh-57092: Add the validate option to xml.sax.saxutils.XMLGenerator

Doc/library/xml.sax.utils.rst

@@ -56,7 +56,8 @@ or as base classes.
    using the reference concrete syntax.
 
 
-.. class:: XMLGenerator(out=None, encoding='iso-8859-1', short_empty_elements=False)
+.. class:: XMLGenerator(out=None, encoding='iso-8859-1', short_empty_elements=False, \
+                        *, validate=False)
 
    This class implements the :class:`~xml.sax.handler.ContentHandler` interface
    by writing SAX
@@ -68,9 +69,20 @@ or as base classes.
    content:  if ``False`` (the default) they are emitted as a pair of start/end
    tags, if set to ``True`` they are emitted as a single self-closed tag.
 
+   If *validate* is true, check that all characters are legal,
+   that element and attribute names and namespace prefixes are valid,
+   and that the content of processing instructions
+   does not contain illegal sequences.
+   Raise :exc:`ValueError` if any check fails.
+   By default no validation is performed, because the events produced
+   by a parser are always valid.
+
    .. versionchanged:: 3.2
       Added the *short_empty_elements* parameter.
 
+   .. versionchanged:: next
+      Added the *validate* parameter.
+
 
 .. class:: XMLFilterBase(base)
 

Doc/whatsnew/3.16.rst

@@ -654,6 +654,10 @@ xml
   and :meth:`!Document.createEntityReference`.
   (Contributed by Jason Orendorff and Serhiy Storchaka in :gh:`44871`.)
 
+* Add the *validate* option to :class:`xml.sax.saxutils.XMLGenerator`,
+  which makes it check that the generated document is well-formed.
+  (Contributed by Serhiy Storchaka in :gh:`57092`.)
+
 * Add :meth:`!GetSpecifiedAttributeCount` method
   to the :mod:`XML parser <xml.parsers.expat>` objects.
   It tells how many of the reported attributes were given in the start tag

Lib/test/test_sax.py

@@ -869,6 +869,72 @@ def xml(self, doc, encoding='iso-8859-1'):
 start = b'<?xml version="1.0" encoding="iso-8859-1"?>\n'
 
 
+class XmlgenValidationTest(unittest.TestCase):
+
+    def gen(self, validate=True):
+        return XMLGenerator(StringIO(), validate=validate)
+
+    def check(self, callback):
+        with self.assertRaises(ValueError):
+            callback(self.gen())
+        callback(self.gen(validate=False))  # no exception
+
+    def test_invalid_element_name(self):
+        for name in '', '0', 'a/b', 'a b':
+            with self.subTest(name=name):
+                self.check(lambda gen: gen.startElement(name, {}))
+                self.check(lambda gen: gen.endElement(name))
+
+    def test_invalid_attribute_name(self):
+        for name in '', '0', 'a/b':
+            with self.subTest(name=name):
+                self.check(lambda gen: gen.startElement('doc', {name: 'v'}))
+
+    def test_invalid_attribute_value(self):
+        for value in '\x00', '\x01', '\ud8ff', '\ufffe':
+            with self.subTest(value=value):
+                self.check(lambda gen: gen.startElement('doc', {'a': value}))
+
+    def test_invalid_characters(self):
+        for text in '\x00', '\x01', '\ud8ff', '\ufffe':
+            with self.subTest(text=text):
+                self.check(lambda gen: gen.characters(text))
+
+    def test_invalid_whitespace(self):
+        for text in '\x00', '&', 'x', '\f', '\xa0':
+            with self.subTest(text=text):
+                self.check(lambda gen: gen.ignorableWhitespace(text))
+        gen = self.gen()
+        gen.ignorableWhitespace(' \t\r\n')  # no exception
+
+    def test_invalid_processing_instruction(self):
+        for target, data in ('', 'a'), ('0', 'a'), ('a/b', 'a'), \
+                            ('xml', 'a'), ('XML', 'a'), \
+                            ('t', 'a?>b'), ('t', '\x00'), ('t', '\ufffe'):
+            with self.subTest(target=target, data=data):
+                self.check(lambda gen: gen.processingInstruction(target, data))
+
+    def test_invalid_namespace(self):
+        self.check(lambda gen: gen.startPrefixMapping('a b', 'http://e'))
+        self.check(lambda gen: gen.startPrefixMapping('p', 'http://\x00'))
+
+    def test_valid(self):
+        result = StringIO()
+        gen = XMLGenerator(result, validate=True)
+        gen.startDocument()
+        gen.startPrefixMapping('p', 'http://e')
+        gen.startElementNS(('http://e', 'doc'), None,
+                           AttributesNSImpl({(None, 'a'): 'v'}, {(None, 'a'): 'a'}))
+        gen.characters('text')
+        gen.processingInstruction('t', 'data')
+        gen.endElementNS(('http://e', 'doc'), None)
+        gen.endPrefixMapping('p')
+        gen.endDocument()
+        self.assertEqual(result.getvalue(),
+                         '<?xml version="1.0" encoding="iso-8859-1"?>\n'
+                         '<p:doc xmlns:p="http://e" a="v">text<?t data?></p:doc>')
+
+
 class XMLFilterBaseTest(unittest.TestCase):
     def test_filter_basic(self):
         result = BytesIO()

Lib/xml/sax/saxutils.py

@@ -8,6 +8,8 @@
 import codecs
 from . import handler
 from . import xmlreader
+from .. import is_valid_name as _is_valid_name
+from .. import is_valid_text as _is_valid_text
 
 def __dict_replace(s, d):
     """Replace substrings of a string using a dictionary."""
@@ -109,10 +111,16 @@ def __getattr__(self, name):
                             newline='\n',
                             write_through=True)
 
+def _check_name(name, what):
+    if not _is_valid_name(name):
+        raise ValueError(f'invalid {what} {name!r}')
+
+
 class XMLGenerator(handler.ContentHandler):
     """Content handler which writes the events back as an XML document."""
 
-    def __init__(self, out=None, encoding="iso-8859-1", short_empty_elements=False):
+    def __init__(self, out=None, encoding="iso-8859-1", short_empty_elements=False,
+                 *, validate=False):
         handler.ContentHandler.__init__(self)
         out = _gettextwriter(out, encoding)
         self._write = out.write
@@ -122,6 +130,7 @@ def __init__(self, out=None, encoding="iso-8859-1", short_empty_elements=False):
         self._undeclared_ns_maps = []
         self._encoding = encoding
         self._short_empty_elements = short_empty_elements
+        self._validate = validate
         self._pending_start_element = False
 
     def _qname(self, name):
@@ -156,6 +165,11 @@ def endDocument(self):
         self._flush()
 
     def startPrefixMapping(self, prefix, uri):
+        if self._validate:
+            if prefix:
+                _check_name(prefix, 'namespace prefix')
+            if not _is_valid_text(uri):
+                raise ValueError(f'invalid namespace name {uri!r}')
         self._ns_contexts.append(self._current_context.copy())
         self._current_context[uri] = prefix
         self._undeclared_ns_maps.append((prefix, uri))
@@ -165,9 +179,15 @@ def endPrefixMapping(self, prefix):
         del self._ns_contexts[-1]
 
     def startElement(self, name, attrs):
+        if self._validate:
+            _check_name(name, 'element name')
         self._finish_pending_start_element()
         self._write('<' + name)
         for (name, value) in attrs.items():
+            if self._validate:
+                _check_name(name, 'attribute name')
+                if not _is_valid_text(value):
+                    raise ValueError('invalid attribute value')
             self._write(' %s=%s' % (name, quoteattr(value)))
         if self._short_empty_elements:
             self._pending_start_element = True
@@ -179,11 +199,16 @@ def endElement(self, name):
             self._write('/>')
             self._pending_start_element = False
         else:
+            if self._validate:
+                _check_name(name, 'element name')
             self._write('</%s>' % name)
 
     def startElementNS(self, name, qname, attrs):
+        name = self._qname(name)
+        if self._validate:
+            _check_name(name, 'element name')
         self._finish_pending_start_element()
-        self._write('<' + self._qname(name))
+        self._write('<' + name)
 
         for prefix, uri in self._undeclared_ns_maps:
             if prefix:
@@ -193,7 +218,12 @@ def startElementNS(self, name, qname, attrs):
         self._undeclared_ns_maps = []
 
         for (name, value) in attrs.items():
-            self._write(' %s=%s' % (self._qname(name), quoteattr(value)))
+            name = self._qname(name)
+            if self._validate:
+                _check_name(name, 'attribute name')
+                if not _is_valid_text(value):
+                    raise ValueError('invalid attribute value')
+            self._write(' %s=%s' % (name, quoteattr(value)))
         if self._short_empty_elements:
             self._pending_start_element = True
         else:
@@ -204,23 +234,35 @@ def endElementNS(self, name, qname):
             self._write('/>')
             self._pending_start_element = False
         else:
-            self._write('</%s>' % self._qname(name))
+            name = self._qname(name)
+            if self._validate:
+                _check_name(name, 'element name')
+            self._write('</%s>' % name)
 
     def characters(self, content):
         if content:
             self._finish_pending_start_element()
             if not isinstance(content, str):
                 content = str(content, self._encoding)
+            if self._validate and not _is_valid_text(content):
+                raise ValueError('invalid characters')
             self._write(escape(content))
 
     def ignorableWhitespace(self, content):
         if content:
             self._finish_pending_start_element()
             if not isinstance(content, str):
                 content = str(content, self._encoding)
+            if self._validate and content.strip(' \t\r\n'):
+                raise ValueError(f'invalid whitespace {content!r}')
             self._write(content)
 
     def processingInstruction(self, target, data):
+        if self._validate:
+            if (not _is_valid_name(target) or target.lower() == 'xml'
+                    or '?>' in data or not _is_valid_text(data)):
+                raise ValueError('invalid processing instruction '
+                                 f'{f"{target} {data}"!r}')
         self._finish_pending_start_element()
         self._write('<?%s %s?>' % (target, data))
 

Misc/NEWS.d/next/Library/2026-09-01-15-42-10.gh-issue-57092.Kx3vQb.rst

@@ -0,0 +1,3 @@
+Add the *validate* option to :class:`xml.sax.saxutils.XMLGenerator`.  If it is
+true, invalid names, illegal characters and other content which cannot be
+represented in a well-formed XML document are rejected with :exc:`ValueError`.