fix(unparse): handle non-string #text with attributes; unify value conversion

- Fix TypeError when #text contains non-string values (int, float, bool) with attributes
- Add _convert_value_to_string() helper to eliminate duplicated conversion logic
- Ensure consistent boolean conversion (lowercase) for both plain and #text values
- Add comprehensive test coverage for GitHub issue #366

Fixes #366

Author: martinblech

tests/test_dicttoxml.py

@@ -460,3 +460,51 @@ def test_empty_dict_vs_empty_list_behavior(self):
 
         # They should be different
         self.assertNotEqual(compact_dict, compact_list)
+
+    def test_non_string_text_with_attributes(self):
+        """Test that non-string #text values work when tag has attributes.
+
+        This test covers GitHub issue #366: Tag value (#text) must be a string
+        when tag has additional parameters - unparse.
+
+        Also tests that plain values and explicit #text values are treated
+        consistently (both go through the same conversion logic).
+        """
+        # Test cases for explicit #text values with attributes
+        self.assertEqual(unparse({"a": {"@param": "test", "#text": 1}}, full_document=False),
+                         '<a param="test">1</a>')
+
+        self.assertEqual(unparse({"a": {"@param": 42, "#text": 3.14}}, full_document=False),
+                         '<a param="42">3.14</a>')
+
+        self.assertEqual(unparse({"a": {"@param": "flag", "#text": True}}, full_document=False),
+                         '<a param="flag">true</a>')
+
+        self.assertEqual(unparse({"a": {"@param": "test", "#text": None}}, full_document=False),
+                         '<a param="test">None</a>')
+
+        self.assertEqual(unparse({"a": {"@param": "test", "#text": "string"}}, full_document=False),
+                         '<a param="test">string</a>')
+
+        self.assertEqual(unparse({"a": {"@attr1": "value1", "@attr2": 2, "#text": 100}}, full_document=False),
+                         '<a attr1="value1" attr2="2">100</a>')
+
+        # Test cases for plain values (should be treated the same as #text)
+        self.assertEqual(unparse({"a": 1}, full_document=False), '<a>1</a>')
+        self.assertEqual(unparse({"a": 3.14}, full_document=False), '<a>3.14</a>')
+        self.assertEqual(unparse({"a": True}, full_document=False), '<a>true</a>')
+        self.assertEqual(unparse({"a": "hello"}, full_document=False), '<a>hello</a>')
+        self.assertEqual(unparse({"a": None}, full_document=False), '<a></a>')
+
+        # Consistency tests: plain values should match explicit #text values
+        self.assertEqual(unparse({"a": 42}, full_document=False),
+                         unparse({"a": {"#text": 42}}, full_document=False))
+
+        self.assertEqual(unparse({"a": 3.14}, full_document=False),
+                         unparse({"a": {"#text": 3.14}}, full_document=False))
+
+        self.assertEqual(unparse({"a": True}, full_document=False),
+                         unparse({"a": {"#text": True}}, full_document=False))
+
+        self.assertEqual(unparse({"a": "hello"}, full_document=False),
+                         unparse({"a": {"#text": "hello"}}, full_document=False))

xmltodict.py

@@ -374,6 +374,18 @@ def parse(xml_input, encoding=None, expat=expat, process_namespaces=False,
     return handler.item
 
 
+def _convert_value_to_string(value):
+    """Convert a value to its string representation for XML output.
+
+    Handles boolean values consistently by converting them to lowercase.
+    """
+    if isinstance(value, (str, bytes)):
+        return value
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)
+
+
 def _has_angle_brackets(value):
     """Return True if value (a str) contains '<' or '>'.
 
@@ -463,21 +475,19 @@ def _emit(key, value, content_handler,
             raise ValueError('document with multiple roots')
         if v is None:
             v = _dict()
-        elif isinstance(v, bool):
-            v = 'true' if v else 'false'
         elif not isinstance(v, (dict, str)):
             if expand_iter and hasattr(v, '__iter__'):
                 v = _dict(((expand_iter, v),))
             else:
-                v = str(v)
+                v = _convert_value_to_string(v)
         if isinstance(v, str):
             v = _dict(((cdata_key, v),))
         cdata = None
         attrs = _dict()
         children = []
         for ik, iv in v.items():
             if ik == cdata_key:
-                cdata = iv
+                cdata = _convert_value_to_string(iv)
                 continue
             if isinstance(ik, str) and ik.startswith(attr_prefix):
                 ik = _process_namespace(ik, namespaces, namespace_separator,