feat(unparse): add selective force_cdata support (bool/tuple/callable)

- Add _should_force_cdata method similar to _should_force_list
- Support tuple of element names and callable functions for force_cdata
- Maintain full backwards compatibility with boolean values
- Add comprehensive tests for all force_cdata scenarios
- Update documentation with consistent examples for force_cdata and force_list

Fixes #375

Author: martinblech

README.md

@@ -210,13 +210,13 @@ Parse XML input into a Python dictionary.
 - `xml_attribs=True`: Include attributes in output dict (with `attr_prefix`).
 - `attr_prefix='@'`: Prefix for XML attributes in the dict.
 - `cdata_key='#text'`: Key for text content in the dict.
-- `force_cdata=False`: Force all text content to be wrapped as CDATA.
+- `force_cdata=False`: Force text content to be wrapped as CDATA for specific elements. Can be a boolean (True/False), a tuple of element names to force CDATA for, or a callable function that receives (path, key, value) and returns True/False.
 - `cdata_separator=''`: Separator string to join multiple text nodes. This joins adjacent text nodes. For example, set to a space to avoid concatenation.
 - `postprocessor=None`: Function to modify parsed items.
 - `dict_constructor=dict`: Constructor for dictionaries (e.g., dict or OrderedDict).
 - `strip_whitespace=True`: Remove leading/trailing whitespace in text nodes. Default is True; this trims whitespace in text nodes. Set to False to preserve whitespace exactly.
 - `namespaces=None`: Mapping of namespaces to prefixes, or None to keep full URIs.
-- `force_list=None`: List of keys or callable to force list values. Useful for elements that may appear once or multiple times. Ensures consistent list output. Can also be a callable for fine-grained control.
+- `force_list=None`: Force list values for specific elements. Can be a boolean (True/False), a tuple of element names to force lists for, or a callable function that receives (path, key, value) and returns True/False. Useful for elements that may appear once or multiple times to ensure consistent list output.
 - `item_depth=0`: Depth at which to call `item_callback`.
 - `item_callback=lambda *args: True`: Function called on items at `item_depth`.
 - `comment_key='#comment'`: Key used for XML comments when `process_comments=True`. Only used when `process_comments=True`. Comments can be preserved but multiple top-level comments may not retain order.
@@ -239,6 +239,50 @@ Convert a Python dictionary back into XML.
 
 Note: xmltodict aims to cover the common 90% of cases. It does not preserve every XML nuance (attribute order, mixed content ordering, multiple top-level comments). For exact fidelity, use a full XML library such as lxml.
 
+## Examples
+
+### Selective force_cdata
+
+The `force_cdata` parameter can be used to selectively force CDATA wrapping for specific elements:
+
+```python
+>>> xml = '<a><b>data1</b><c>data2</c><d>data3</d></a>'
+>>> # Force CDATA only for 'b' and 'd' elements
+>>> xmltodict.parse(xml, force_cdata=('b', 'd'))
+{'a': {'b': {'#text': 'data1'}, 'c': 'data2', 'd': {'#text': 'data3'}}}
+
+>>> # Force CDATA for all elements (original behavior)
+>>> xmltodict.parse(xml, force_cdata=True)
+{'a': {'b': {'#text': 'data1'}, 'c': {'#text': 'data2'}, 'd': {'#text': 'data3'}}}
+
+>>> # Use a callable for complex logic
+>>> def should_force_cdata(path, key, value):
+...     return key in ['b', 'd'] and len(value) > 4
+>>> xmltodict.parse(xml, force_cdata=should_force_cdata)
+{'a': {'b': {'#text': 'data1'}, 'c': 'data2', 'd': {'#text': 'data3'}}}
+```
+
+### Selective force_list
+
+The `force_list` parameter can be used to selectively force list values for specific elements:
+
+```python
+>>> xml = '<a><b>data1</b><b>data2</b><c>data3</c></a>'
+>>> # Force lists only for 'b' elements
+>>> xmltodict.parse(xml, force_list=('b',))
+{'a': {'b': ['data1', 'data2'], 'c': 'data3'}}
+
+>>> # Force lists for all elements (original behavior)
+>>> xmltodict.parse(xml, force_list=True)
+{'a': [{'b': ['data1', 'data2'], 'c': ['data3']}]}
+
+>>> # Use a callable for complex logic
+>>> def should_force_list(path, key, value):
+...     return key in ['b'] and isinstance(value, str)
+>>> xmltodict.parse(xml, force_list=should_force_list)
+{'a': {'b': ['data1', 'data2'], 'c': 'data3'}}
+```
+
 ## Ok, how do I get it?
 
 ### Using pypi

tests/test_xmltodict.py

@@ -39,6 +39,68 @@ def test_force_cdata(self):
         self.assertEqual(parse('<a>data</a>', force_cdata=True),
                          {'a': {'#text': 'data'}})
 
+    def test_selective_force_cdata_tuple(self):
+        xml = "<a><b>data1</b><c>data2</c><d>data3</d></a>"
+        # Test with tuple of specific element names
+        result = parse(xml, force_cdata=("b", "d"))
+        expected = {
+            "a": {"b": {"#text": "data1"}, "c": "data2", "d": {"#text": "data3"}}
+        }
+        self.assertEqual(result, expected)
+
+    def test_selective_force_cdata_single_element(self):
+        xml = "<a><b>data1</b><c>data2</c></a>"
+        # Test with single element name
+        result = parse(xml, force_cdata=("b",))
+        expected = {"a": {"b": {"#text": "data1"}, "c": "data2"}}
+        self.assertEqual(result, expected)
+
+    def test_selective_force_cdata_empty_tuple(self):
+        xml = "<a><b>data1</b><c>data2</c></a>"
+        # Test with empty tuple (should behave like force_cdata=False)
+        result = parse(xml, force_cdata=())
+        expected = {"a": {"b": "data1", "c": "data2"}}
+        self.assertEqual(result, expected)
+
+    def test_selective_force_cdata_callable(self):
+        xml = "<a><b>data1</b><c>data2</c><d>data3</d></a>"
+
+        # Test with callable function
+        def should_force_cdata(path, key, value):
+            return key in ["b", "d"]
+
+        result = parse(xml, force_cdata=should_force_cdata)
+        expected = {
+            "a": {"b": {"#text": "data1"}, "c": "data2", "d": {"#text": "data3"}}
+        }
+        self.assertEqual(result, expected)
+
+    def test_selective_force_cdata_nested_elements(self):
+        xml = "<a><b><c>data1</c></b><d>data2</d></a>"
+        # Test with nested elements - only 'c' should be forced
+        result = parse(xml, force_cdata=("c",))
+        expected = {"a": {"b": {"c": {"#text": "data1"}}, "d": "data2"}}
+        self.assertEqual(result, expected)
+
+    def test_selective_force_cdata_with_attributes(self):
+        xml = '<a><b attr="value">data1</b><c>data2</c></a>'
+        # Test with attributes - force_cdata should still work
+        result = parse(xml, force_cdata=("b",))
+        expected = {"a": {"b": {"@attr": "value", "#text": "data1"}, "c": "data2"}}
+        self.assertEqual(result, expected)
+
+    def test_selective_force_cdata_backwards_compatibility(self):
+        xml = "<a><b>data1</b><c>data2</c></a>"
+        # Test that boolean True still works (backwards compatibility)
+        result_true = parse(xml, force_cdata=True)
+        expected_true = {"a": {"b": {"#text": "data1"}, "c": {"#text": "data2"}}}
+        self.assertEqual(result_true, expected_true)
+
+        # Test that boolean False still works (backwards compatibility)
+        result_false = parse(xml, force_cdata=False)
+        expected_false = {"a": {"b": "data1", "c": "data2"}}
+        self.assertEqual(result_false, expected_false)
+
     def test_custom_cdata(self):
         self.assertEqual(parse('<a>data</a>',
                                force_cdata=True,

xmltodict.py

@@ -139,7 +139,7 @@ def endElement(self, full_name):
             self.item, self.data = self.stack.pop()
             if self.strip_whitespace and data:
                 data = data.strip() or None
-            if data and self.force_cdata and item is None:
+            if data and self._should_force_cdata(name, data) and item is None:
                 item = self.dict_constructor()
             if item is not None:
                 if data:
@@ -194,6 +194,16 @@ def _should_force_list(self, key, value):
         except TypeError:
             return self.force_list(self.path[:-1], key, value)
 
+    def _should_force_cdata(self, key, value):
+        if not self.force_cdata:
+            return False
+        if isinstance(self.force_cdata, bool):
+            return self.force_cdata
+        try:
+            return key in self.force_cdata
+        except TypeError:
+            return self.force_cdata(self.path[:-1], key, value)
+
 
 def parse(xml_input, encoding=None, expat=expat, process_namespaces=False,
           namespace_separator=':', disable_entities=True, process_comments=False, **kwargs):