Add inline lists support for Attributes.

Added new tests and updated old tests as this addition is
a regression/backwards incompatibility.

Author: ajoino

pydantic_xml/serializers.py

@@ -581,6 +581,37 @@ def serialize(
         def deserialize(self, element: etree.Element) -> Optional[List[Any]]:
             return [value for value in element.text.split()]
 
+    class AttributeSerializer(Serializer):
+        def __init__(
+                self, model: Type['pxml.BaseXmlModel'], model_field: pd.fields.ModelField, ctx: Serializer.Context,
+        ):
+            assert len(model_field.sub_fields) == 1
+            if issubclass(model_field.type_, pxml.BaseXmlModel):
+                raise errors.ModelFieldError(
+                     model.__name__, model_field.name, "Inline list value should be of scalar type",
+                )
+
+            ns_attrs = model.__xml_ns_attrs__
+            name = ctx.entity_name or model_field.alias
+            ns = ctx.entity_ns or (ctx.parent_ns if ns_attrs else None)
+            nsmap = ctx.parent_nsmap
+            
+            self.attr_name = QName.from_alias(tag=name, ns=ns, nsmap=nsmap, is_attr=True).uri
+
+
+        def serialize(
+                self, element: etree.Element, value: Any, *, encoder: XmlEncoder, skip_empty: bool = False,
+        ) -> Optional[etree.Element]:
+            if value is None or skip_empty and len(value) == 0:
+                return element
+
+            encoded = " ".join(encoder.encode(val) for val in value)
+            element.set(self.attr_name, encoded)
+            return element
+
+        def deserialize(self, element: etree.Element) -> Optional[List[Any]]:
+            return [value for value in element.get(self.attr_name).split()]
+
     class ElementSerializer(Serializer):
         def __init__(
                 self, model: Type['pxml.BaseXmlModel'], model_field: pd.fields.ModelField, ctx: Serializer.Context,
@@ -658,9 +689,10 @@ def build(
         elif field_location is Location.MISSING:
             return cls.TextSerializer(model, model_field, ctx)
         elif field_location is Location.ATTRIBUTE:
-            raise errors.ModelFieldError(
-                model.__name__, model_field.name, "attributes of collection type are not supported",
-            )
+            return cls.AttributeSerializer(model, model_field, ctx)
+            # raise errors.ModelFieldError(
+            #     model.__name__, model_field.name, "attributes of collection type are not supported",
+            # )
         else:
             raise AssertionError("unreachable")
 

tests/test_homogeneous_collections.py

@@ -140,10 +140,37 @@ class RootModel(BaseXmlModel, tag="model"):
     assert_xml_equal(actual_xml, xml)
 
 
+def test_attr_list_extraction():
+    class RootModel(BaseXmlModel, tag="model"):
+        values: List[float] = attr()
+
+    xml = '''
+    <model values="3.14 -1.0 300.0"/>
+    '''
+    # This will fail if scientific notation is used
+    # i.e. if 300 is replaced with 3e2 or 300, the deserializer
+    # will always use the standard notation with the added `.0`.
+    # While this behaviour fails the tests, it shouldn't
+    # matter in practice.
+
+    actual_obj = RootModel.from_xml(xml)
+    expected_obj = RootModel(
+        values = [3.14, -1.0, 3e2]
+    )
+
+    assert actual_obj == expected_obj
+
+    actual_xml = actual_obj.to_xml()
+    assert_xml_equal(actual_xml, xml)
+
+
 def test_homogeneous_definition_errors():
     with pytest.raises(errors.ModelFieldError):
+        class SubModel(BaseXmlModel):
+            text: str
+
         class TestModel(BaseXmlModel):
-            attr1: List[int] = attr()
+            attr1: List[SubModel] = attr()
 
     with pytest.raises(errors.ModelFieldError):
         class TestModel(BaseXmlModel):

tests/test_misc.py

@@ -39,7 +39,7 @@ class TestSubModel(BaseXmlModel, tag='model'):
 
     class TestModel(BaseXmlModel, tag='model'):
         model: TestSubModel
-        list: List[TestSubModel] = []
+        list: List[TestSubModel] = element(default=[])
         tuple: Optional[Tuple[TestSubModel, TestSubModel]] = None
         attrs: Dict[str, str] = {}
         wrapped: Optional[str] = wrapped('envelope')