From 3ca2890a5c3faeee92a332088cc151f7c1722f2c Mon Sep 17 00:00:00 2001 From: Ramon Domingos Date: Thu, 12 Nov 2026 20:37:23 -0300 Subject: [PATCH 1/2] gh-161807: Fix ElementTree find*/iterfind with empty path `ElementPath.iterfind()` used a bare `return` when the tokenizer produced no tokens (empty path string), which returned `None` instead of an iterator. This caused `find()`, `findall()`, `findtext()`, and `iterfind()` to raise `TypeError` when called with an empty path. Changed `return` to `return iter(())` so that an empty path yields an empty iterator, consistent with a path that simply matches nothing. --- Lib/test/test_xml_etree.py | 22 +++++++++++++++++++ Lib/xml/etree/ElementPath.py | 2 +- ...1-12-23-45-00.gh-issue-161807._IY0DOR6.rst | 6 +++++ 3 files changed, 29 insertions(+), 1 deletion(-) create mode 100644 Misc/NEWS.d/next/Library/2026-11-12-23-45-00.gh-issue-161807._IY0DOR6.rst diff --git a/Lib/test/test_xml_etree.py b/Lib/test/test_xml_etree.py index acb11615b35c0b3..6e956dd643f0d1d 100644 --- a/Lib/test/test_xml_etree.py +++ b/Lib/test/test_xml_etree.py @@ -4064,6 +4064,28 @@ def test_findall_wildcard(self): self.assertEqual(summarize_list(root.findall(".//{}b")), summarize_list(root.findall(".//b"))) + def test_find_empty_path(self): + # gh-161807: empty path should not raise TypeError + e = ET.XML(SAMPLE_XML) + self.assertIsNone(e.find("")) + self.assertEqual(e.findall(""), []) + self.assertIsNone(e.findtext("")) + self.assertEqual(e.findtext("", "default"), "default") + self.assertEqual(list(e.iterfind("")), []) + + # Same with namespaces + ns = {"ns": "http://example.com"} + self.assertIsNone(e.find("", ns)) + self.assertEqual(e.findall("", ns), []) + self.assertIsNone(e.findtext("", namespaces=ns)) + self.assertEqual(list(e.iterfind("", ns)), []) + + # Also test through ElementTree + tree = ET.ElementTree(e) + self.assertIsNone(tree.find("")) + self.assertEqual(tree.findall(""), []) + self.assertIsNone(tree.findtext("")) + def test_bad_find(self): e = ET.XML(SAMPLE_XML) with self.assertRaisesRegex(SyntaxError, 'cannot use absolute path'): diff --git a/Lib/xml/etree/ElementPath.py b/Lib/xml/etree/ElementPath.py index de1fd203ff6a0f6..ca41ef403fb6fd2 100644 --- a/Lib/xml/etree/ElementPath.py +++ b/Lib/xml/etree/ElementPath.py @@ -384,7 +384,7 @@ def iterfind(elem, path, namespaces=None): try: token = next() except StopIteration: - return + return iter(()) selector = [] while 1: try: diff --git a/Misc/NEWS.d/next/Library/2026-11-12-23-45-00.gh-issue-161807._IY0DOR6.rst b/Misc/NEWS.d/next/Library/2026-11-12-23-45-00.gh-issue-161807._IY0DOR6.rst new file mode 100644 index 000000000000000..f6a862abc317b0a --- /dev/null +++ b/Misc/NEWS.d/next/Library/2026-11-12-23-45-00.gh-issue-161807._IY0DOR6.rst @@ -0,0 +1,6 @@ +Fix :func:`xml.etree.ElementTree.Element.find`, +:func:`~xml.etree.ElementTree.Element.findall`, +:func:`~xml.etree.ElementTree.Element.findtext`, and +:func:`~xml.etree.ElementTree.Element.iterfind` raising :exc:`TypeError` +when called with an empty path string. They now return ``None``, ``[]``, +the default value, and an empty iterator, respectively. From 0c2a4a61d4110d68f8c64093cd6c76a827c31635 Mon Sep 17 00:00:00 2001 From: Ramon Domingos Date: Mon, 16 Nov 2026 11:21:05 -0300 Subject: [PATCH 2/2] gh-161807: Refactor test_find_empty_path to use a parameterised helper MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add do_test_find_empty_path(m) so both Element and ElementTree are exercised with the same assertions. Also verify that the namespace dict is not mutated by any of the find*/iterfind calls, and add a comment noting that the test covers the pure-Python implementation – after the fix it matches what the C accelerator already returned. --- Lib/test/test_xml_etree.py | 44 ++++++++++++++++++++++---------------- 1 file changed, 25 insertions(+), 19 deletions(-) diff --git a/Lib/test/test_xml_etree.py b/Lib/test/test_xml_etree.py index 6e956dd643f0d1d..96626aa118cc465 100644 --- a/Lib/test/test_xml_etree.py +++ b/Lib/test/test_xml_etree.py @@ -4064,27 +4064,33 @@ def test_findall_wildcard(self): self.assertEqual(summarize_list(root.findall(".//{}b")), summarize_list(root.findall(".//b"))) + def do_test_find_empty_path(self, m): + # This tests the pure-Python ElementPath implementation; the C + # accelerator already returned the same results for most cases before + # gh-161807. After the fix both implementations agree. + + # Without namespaces + self.assertIsNone(m.find("")) + self.assertEqual(m.findall(""), []) + self.assertIsNone(m.findtext("")) + self.assertEqual(m.findtext("", "default"), "default") + self.assertEqual(list(m.iterfind("")), []) + + # With namespaces — the dict must not be altered by any of the calls + ns = {"ns": "http://example.com"} + ns_before = dict(ns) + self.assertIsNone(m.find("", ns)) + self.assertEqual(m.findall("", ns), []) + self.assertIsNone(m.findtext("", namespaces=ns)) + self.assertEqual(m.findtext("", "default", namespaces=ns), "default") + self.assertEqual(list(m.iterfind("", ns)), []) + self.assertEqual(ns, ns_before) + def test_find_empty_path(self): - # gh-161807: empty path should not raise TypeError + # gh-161807: empty path must not raise TypeError e = ET.XML(SAMPLE_XML) - self.assertIsNone(e.find("")) - self.assertEqual(e.findall(""), []) - self.assertIsNone(e.findtext("")) - self.assertEqual(e.findtext("", "default"), "default") - self.assertEqual(list(e.iterfind("")), []) - - # Same with namespaces - ns = {"ns": "http://example.com"} - self.assertIsNone(e.find("", ns)) - self.assertEqual(e.findall("", ns), []) - self.assertIsNone(e.findtext("", namespaces=ns)) - self.assertEqual(list(e.iterfind("", ns)), []) - - # Also test through ElementTree - tree = ET.ElementTree(e) - self.assertIsNone(tree.find("")) - self.assertEqual(tree.findall(""), []) - self.assertIsNone(tree.findtext("")) + self.do_test_find_empty_path(e) + self.do_test_find_empty_path(ET.ElementTree(e)) def test_bad_find(self): e = ET.XML(SAMPLE_XML)