_elementtree.XMLParser._setevents should support any sequence, not just tuples

Also clean up some code around this

2 files changed, 52 insertions, 12 deletions

diff --git a/Lib/test/test_xml_etree.py b/Lib/test/test_xml_etree.py
index f37cfe9..6973371 100644
--- a/Lib/test/test_xml_etree.py
+++ b/Lib/test/test_xml_etree.py
@@ -979,6 +979,21 @@ class IncrementalParserTest(unittest.TestCase):
         parser.eof_received()
         self.assertEqual(parser.root.tag, '{namespace}root')
 
+    def test_ns_events(self):
+        parser = ET.IncrementalParser(events=('start-ns', 'end-ns'))
+        self._feed(parser, "<!-- comment -->\n")
+        self._feed(parser, "<root xmlns='namespace'>\n")
+        self.assertEqual(
+            list(parser.events()),
+            [('start-ns', ('', 'namespace'))])
+        self._feed(parser, "<element key='value'>text</element")
+        self._feed(parser, ">\n")
+        self._feed(parser, "<element>text</element>tail\n")
+        self._feed(parser, "<empty-element/>\n")
+        self._feed(parser, "</root>\n")
+        self.assertEqual(list(parser.events()), [('end-ns', None)])
+        parser.eof_received()
+
     def test_events(self):
         parser = ET.IncrementalParser(events=())
         self._feed(parser, "<root/>\n")
@@ -1026,6 +1041,26 @@ class IncrementalParserTest(unittest.TestCase):
         parser.eof_received()
         self.assertEqual(parser.root.tag, 'root')
 
+    def test_events_sequence(self):
+        # Test that events can be some sequence that's not just a tuple or list
+        eventset = {'end', 'start'}
+        parser = ET.IncrementalParser(events=eventset)
+        self._feed(parser, "<foo>bar</foo>")
+        self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')])
+
+        class DummyIter:
+            def __init__(self):
+                self.events = iter(['start', 'end', 'start-ns'])
+            def __iter__(self):
+                return self
+            def __next__(self):
+                return next(self.events)
+
+        parser = ET.IncrementalParser(events=DummyIter())
+        self._feed(parser, "<foo>bar</foo>")
+        self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')])
+
+
     def test_unknown_event(self):
         with self.assertRaises(ValueError):
             ET.IncrementalParser(events=('start', 'end', 'bogus'))
diff --git a/Lib/xml/etree/ElementTree.py b/Lib/xml/etree/ElementTree.py
index b56ddff..1ab80cd 100644
--- a/Lib/xml/etree/ElementTree.py
+++ b/Lib/xml/etree/ElementTree.py
@@ -1498,33 +1498,38 @@ class XMLParser:
         except AttributeError:
             pass # unknown
 
-    def _setevents(self, event_list, events):
+    def _setevents(self, events_queue, events_to_report):
         # Internal API for IncrementalParser
+        # events_to_report: a list of events to report during parsing (same as
+        # the *events* of IncrementalParser's constructor.
+        # events_queue: a list of actual parsing events that will be populated
+        # by the underlying parser.
+        #
         parser = self._parser
-        append = event_list.append
-        for event in events:
-            if event == "start":
+        append = events_queue.append
+        for event_name in events_to_report:
+            if event_name == "start":
                 parser.ordered_attributes = 1
                 parser.specified_attributes = 1
-                def handler(tag, attrib_in, event=event, append=append,
+                def handler(tag, attrib_in, event=event_name, append=append,
                             start=self._start_list):
                     append((event, start(tag, attrib_in)))
                 parser.StartElementHandler = handler
-            elif event == "end":
-                def handler(tag, event=event, append=append,
+            elif event_name == "end":
+                def handler(tag, event=event_name, append=append,
                             end=self._end):
                     append((event, end(tag)))
                 parser.EndElementHandler = handler
-            elif event == "start-ns":
-                def handler(prefix, uri, event=event, append=append):
+            elif event_name == "start-ns":
+                def handler(prefix, uri, event=event_name, append=append):
                     append((event, (prefix or "", uri or "")))
                 parser.StartNamespaceDeclHandler = handler
-            elif event == "end-ns":
-                def handler(prefix, event=event, append=append):
+            elif event_name == "end-ns":
+                def handler(prefix, event=event_name, append=append):
                     append((event, None))
                 parser.EndNamespaceDeclHandler = handler
             else:
-                raise ValueError("unknown event %r" % event)
+                raise ValueError("unknown event %r" % event_name)
 
     def _raiseerror(self, value):
         err = ParseError(value)