fix(streaming): avoid parent accumulation at item_depth; add regression tests

- Emit and drop items at item_depth in streaming mode to restore low memory usage.
- Add tracemalloc-based memory regression test, plus tests for return None and comments/attrs in streaming.
- Fixes #365, #369. Credit: @bigpick (see PR #370).

Author: martinblech

tests/test_xmltodict.py

@@ -487,6 +487,40 @@ def handler(path, item):
 
         parse(xml, item_depth=2, item_callback=handler, process_comments=True)
 
+    def test_streaming_memory_usage(self):
+        # Guard against re-introducing accumulation of streamed items into parent
+        try:
+            import tracemalloc
+        except ImportError:
+            self.skipTest("tracemalloc not available")
+
+        NUM_ITEMS = 20000
+
+        def xml_gen():
+            yield "<a>"
+            # generate many children with attribute and text
+            for i in range(NUM_ITEMS):
+                yield f'<b attr="v">{i % 10}</b>'
+            yield "</a>"
+
+        count = 0
+
+        def cb(path, item):
+            nonlocal count
+            count += 1
+            return True
+
+        tracemalloc.start()
+        parse(xml_gen(), item_depth=2, item_callback=cb)
+        current, peak = tracemalloc.get_traced_memory()
+        tracemalloc.stop()
+
+        self.assertEqual(count, NUM_ITEMS)
+        # Peak memory should remain reasonably bounded; choose a conservative threshold
+        # This value should stay well below pathological accumulation levels
+        MAX_BYTES = 32 * 1024  # 32 KiB
+        self.assertLess(peak, MAX_BYTES, f"peak memory too high: {peak} bytes")
+
     def test_streaming_attrs(self):
         xml = """
         <a>

xmltodict.py

@@ -111,6 +111,9 @@ def startElement(self, full_name, attrs):
 
     def endElement(self, full_name):
         name = self._build_name(full_name)
+        # If we just closed an item at the streaming depth, emit it and drop it
+        # without attaching it back to its parent. This avoids accumulating all
+        # streamed items in memory when using item_depth > 0.
         if len(self.path) == self.item_depth:
             item = self.item
             if item is None:
@@ -120,6 +123,15 @@ def endElement(self, full_name):
             should_continue = self.item_callback(self.path, item)
             if not should_continue:
                 raise ParsingInterrupted
+            # Reset state for the parent context without keeping a reference to
+            # the emitted item.
+            if self.stack:
+                self.item, self.data = self.stack.pop()
+            else:
+                self.item = None
+                self.data = []
+            self.path.pop()
+            return
         if self.stack:
             data = (None if not self.data
                     else self.cdata_separator.join(self.data))
@@ -549,8 +561,8 @@ def unparse(input_dict, output=None, encoding='utf-8', full_document=True,
 
 
 if __name__ == '__main__':  # pragma: no cover
-    import sys
     import marshal
+    import sys
     try:
         stdin = sys.stdin.buffer
         stdout = sys.stdout.buffer