gh-140601: Add ResourceWarning to iterparse when not closed

When iterparse() opens a file by filename and is not explicitly closed,
emit a ResourceWarning to alert developers of the resource leak.

This implements the TODO comment at line 1270 of ElementTree.py which
has been requesting this feature since the close() method was added.

- Add _closed flag to IterParseIterator to track state
- Emit ResourceWarning in __del__ if not closed
- Add comprehensive test cases
- Update existing tests to properly close iterators

Signed-off-by: Osama Abdelkader <[email protected]>

Author: osamakader

Lib/test/test_xml_etree.py

@@ -692,28 +692,31 @@ def test_iterparse(self):
         it = iterparse(TESTFN)
         action, elem = next(it)
         self.assertEqual((action, elem.tag), ('end', 'document'))
-        with warnings_helper.check_no_resource_warning(self):
-            with self.assertRaises(ET.ParseError) as cm:
-                next(it)
-            self.assertEqual(str(cm.exception),
-                    'junk after document element: line 1, column 12')
-            del cm, it
+        with self.assertRaises(ET.ParseError) as cm:
+            next(it)
+        self.assertEqual(str(cm.exception),
+                'junk after document element: line 1, column 12')
+        it.close()  # Close to avoid ResourceWarning
+        del cm, it
 
-        # Not exhausting the iterator still closes the resource (bpo-43292)
-        with warnings_helper.check_no_resource_warning(self):
-            it = iterparse(SIMPLE_XMLFILE)
-            del it
+        # Deleting iterator without close() should emit ResourceWarning (bpo-43292)
+        it = iterparse(SIMPLE_XMLFILE)
+        del it
+        import gc
+        gc.collect()  # Ensure previous iterator is cleaned up
 
+        # Explicitly calling close() should not emit warning
         with warnings_helper.check_no_resource_warning(self):
             it = iterparse(SIMPLE_XMLFILE)
             it.close()
             del it
 
-        with warnings_helper.check_no_resource_warning(self):
-            it = iterparse(SIMPLE_XMLFILE)
-            action, elem = next(it)
-            self.assertEqual((action, elem.tag), ('end', 'element'))
-            del it, elem
+        # Not closing before del should emit ResourceWarning
+        it = iterparse(SIMPLE_XMLFILE)
+        action, elem = next(it)
+        self.assertEqual((action, elem.tag), ('end', 'element'))
+        del it, elem
+        gc.collect()  # Ensure previous iterator is cleaned up
 
         with warnings_helper.check_no_resource_warning(self):
             it = iterparse(SIMPLE_XMLFILE)
@@ -725,6 +728,63 @@ def test_iterparse(self):
         with self.assertRaises(FileNotFoundError):
             iterparse("nonexistent")
 
+    def test_iterparse_resource_warning(self):
+        # Test ResourceWarning when iterparse with filename is not closed
+        import gc
+        import warnings
+
+        # Should emit warning when not closed
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always", ResourceWarning)
+
+            def create_unclosed():
+                context = ET.iterparse(SIMPLE_XMLFILE)
+                next(context)
+                # Don't close - should warn
+
+            create_unclosed()
+            gc.collect()
+
+            resource_warnings = [x for x in w
+                               if issubclass(x.category, ResourceWarning)]
+            self.assertGreater(len(resource_warnings), 0,
+                              "Expected ResourceWarning when iterparse is not closed")
+
+        # Should NOT warn when explicitly closed
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always", ResourceWarning)
+
+            def create_closed():
+                context = ET.iterparse(SIMPLE_XMLFILE)
+                next(context)
+                context.close()
+
+            create_closed()
+            gc.collect()
+
+            resource_warnings = [x for x in w
+                               if issubclass(x.category, ResourceWarning)]
+            self.assertEqual(len(resource_warnings), 0,
+                            "No warning expected when iterparse is properly closed")
+
+        # Should NOT warn for file objects (externally managed)
+        with open(SIMPLE_XMLFILE, 'rb') as source:
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter("always", ResourceWarning)
+
+                def create_with_fileobj():
+                    context = ET.iterparse(source)
+                    next(context)
+                    # Don't close - file object managed externally
+
+                create_with_fileobj()
+                gc.collect()
+
+                resource_warnings = [x for x in w
+                                   if issubclass(x.category, ResourceWarning)]
+                self.assertEqual(len(resource_warnings), 0,
+                                "No warning for file objects managed externally")
+
     def test_iterparse_close(self):
         iterparse = ET.iterparse
 

Lib/xml/etree/ElementTree.py

@@ -1261,18 +1261,35 @@ def iterator(source):
     gen = iterator(source)
     class IterParseIterator(collections.abc.Iterator):
         __next__ = gen.__next__
+
         def close(self):
             if close_source:
                 source.close()
             gen.close()
+            self._closed = True
 
         def __del__(self):
-            # TODO: Emit a ResourceWarning if it was not explicitly closed.
-            # (When the close() method will be supported in all maintained Python versions.)
+            if close_source and not getattr(self, '_closed', False):
+                try:
+                    warnings.warn(
+                        f"unclosed file {source!r}",
+                        ResourceWarning,
+                        stacklevel=2,
+                        source=self
+                    )
+                except:
+                    # Ignore errors during warning emission in __del__
+                    # This can happen during interpreter shutdown
+                    pass
             if close_source:
-                source.close()
+                try:
+                    source.close()
+                except:
+                    # Ignore errors when closing during __del__
+                    pass
 
     it = IterParseIterator()
+    it._closed = False
     it.root = None
     wr = weakref.ref(it)
     return it

Misc/NEWS.d/next/Library/2025-10-25-22-55-07.gh-issue-140601.In3MlS.rst

@@ -0,0 +1,4 @@
+:func:`xml.etree.ElementTree.iterparse` now emits a :exc:`ResourceWarning`
+when the iterator is not explicitly closed and was opened with a filename.
+This helps developers identify and fix resource leaks. Patch by Osama
+Abdelkader.