def build_class_attribute(cls, target: Class, name: str, value: Any):
if isinstance(value, list):
for val in value:
cls.build_class_attribute(target, name, val)
target.attrs[-1].restrictions.max_occurs = sys.maxsize
else:
if isinstance(value, dict):
inner = cls.build_class(value, name)
attr_type = AttrType(qname=inner.qname, forward=True)
target.inner.append(inner)
else:
attr_type = ElementMapper.build_attribute_type(name, value)
ElementMapper.build_attribute(target, name, attr_type)
def test_build_class_mixed_content(self):
element = AnyElement(
qname="{xsdata}root",
children=[
AnyElement(qname="{xsdata}child", text="primitive"),
AnyElement(qname="something", text="foo", tail="bar"),
],
)
actual = ElementMapper.build_class(element, None)
expected = ClassFactory.create(
tag=Tag.ELEMENT,
qname="root",
namespace="xsdata",
module="",
mixed=True,
ns_map={},
attrs=[
AttrFactory.native(DataType.STRING,
name="child",
namespace="xsdata",
index=0),
AttrFactory.native(DataType.STRING, name="something", index=1),
],
)
self.assertEqual(expected, actual)
def test_sequential_names(self):
a = AnyElement(qname="a")
b = AnyElement(qname="b")
actual = ElementMapper.sequential_names([a, b])
self.assertEqual(0, len(actual))
actual = ElementMapper.sequential_names([a, b, a])
self.assertEqual({"a", "b"}, actual)
c = AnyElement(qname="c")
actual = ElementMapper.sequential_names([a, b, a, c])
self.assertEqual({"a", "b"}, actual)
d = AnyElement(qname="d")
e = AnyElement(qname="e")
actual = ElementMapper.sequential_names([a, b, a, c, d, e, d])
self.assertEqual({"a", "b", "d", "e"}, actual)
def test_map(self, mock_build_class, mock_flatten):
element = AnyElement(qname="{xsdata}root")
root_class = ClassFactory.create()
flat_classes = ClassFactory.list(5)
iter_flat_classes = iter(flat_classes)
mock_build_class.return_value = root_class
mock_flatten.return_value = iter_flat_classes
actual = ElementMapper.map(element)
self.assertEqual(flat_classes, actual)
mock_build_class.assert_called_once_with(element, "xsdata")
mock_flatten.assert_called_once_with(root_class, "root")
def process_xml_documents(self, uris: List[str]):
"""Process a list of xml resources."""
classes = []
parser = TreeParser()
for uri in uris:
input_stream = self.load_resource(uri)
if input_stream:
logger.info("Parsing document %s", os.path.basename(uri))
any_element: AnyElement = parser.from_bytes(input_stream)
classes.extend(ElementMapper.map(any_element))
dirname = os.path.dirname(uris[0]) if uris else ""
self.class_map[dirname] = ClassUtils.reduce(classes)
def test_build_class_complex_type(self):
element = AnyElement(
qname="{xsdata}root",
children=[
AnyElement(qname="{xsdata}child", text="primitive"),
AnyElement(qname="{inner}child",
attributes={
"{foo}bar": "1",
"{bar}foo": "2"
}),
],
)
actual = ElementMapper.build_class(element, "target")
expected = ClassFactory.create(
tag=Tag.ELEMENT,
qname="{target}root",
namespace="xsdata",
module="",
ns_map={},
attrs=[
AttrFactory.native(
DataType.STRING,
tag=Tag.ELEMENT,
name="child",
namespace="xsdata",
index=0,
),
AttrFactory.element(
name="child",
namespace="inner",
types=[
AttrTypeFactory.create(qname="{target}child",
forward=True)
],
index=1,
),
],
)
self.assertEqual(1, len(actual.inner))
actual.inner.clear()
self.assertEqual(expected, actual)
def test_select_namespace(self):
self.assertEqual("a",
ElementMapper.select_namespace("a", "a", Tag.ELEMENT))
self.assertEqual("b",
ElementMapper.select_namespace("b", "a", Tag.ELEMENT))
self.assertEqual(
"", ElementMapper.select_namespace(None, "a", Tag.ELEMENT))
self.assertEqual(
"a", ElementMapper.select_namespace("a", "a", Tag.ATTRIBUTE))
self.assertEqual(
"b", ElementMapper.select_namespace("b", "a", Tag.ATTRIBUTE))
self.assertIsNone(
ElementMapper.select_namespace(None, "a", Tag.ATTRIBUTE))
def test_build_class_simple_type(self):
element = AnyElement(
qname="{xsdata}root",
attributes={
"{foo}bar": "1",
"{bar}foo": "2.0"
},
text="true",
)
actual = ElementMapper.build_class(element, "target")
expected = ClassFactory.create(
tag=Tag.ELEMENT,
qname="{target}root",
namespace="xsdata",
module="",
ns_map={},
attrs=[
AttrFactory.native(
DataType.INT,
tag=Tag.ATTRIBUTE,
name="bar",
namespace="foo",
index=0,
),
AttrFactory.native(
DataType.FLOAT,
tag=Tag.ATTRIBUTE,
name="foo",
namespace="bar",
index=1,
),
AttrFactory.native(
DataType.BOOLEAN,
tag=Tag.SIMPLE_TYPE,
name="value",
namespace=None,
index=2,
),
],
)
self.assertEqual(expected, actual)
def test_add_attribute(self):
target = ClassFactory.elements(2)
attr = target.attrs[0].clone()
attr.index += 1
ElementMapper.add_attribute(target, attr)
self.assertEqual(2, len(target.attrs))
self.assertEqual(sys.maxsize, target.attrs[0].restrictions.max_occurs)
self.assertEqual(2, len(target.attrs[0].types))
self.assertFalse(target.attrs[0].restrictions.sequential)
attr = target.attrs[1].clone()
attr.restrictions.sequential = True
ElementMapper.add_attribute(target, attr)
self.assertTrue(target.attrs[1].restrictions.sequential)
attr = AttrFactory.create()
ElementMapper.add_attribute(target, attr)
self.assertEqual(3, len(target.attrs))
def test_build_attribute_type(self):
actual = ElementMapper.build_attribute_type(QNames.XSI_TYPE, "")
self.assertEqual(str(DataType.QNAME), actual.qname)
self.assertTrue(actual.native)
actual = ElementMapper.build_attribute_type("name", "foo")
self.assertEqual(str(DataType.STRING), actual.qname)
self.assertTrue(actual.native)
actual = ElementMapper.build_attribute_type("name", "")
self.assertEqual(str(DataType.ANY_SIMPLE_TYPE), actual.qname)
self.assertTrue(actual.native)
actual = ElementMapper.build_attribute_type("name", None)
self.assertEqual(str(DataType.ANY_SIMPLE_TYPE), actual.qname)
self.assertTrue(actual.native)
actual = ElementMapper.build_attribute_type("name", 1)
self.assertEqual(str(DataType.SHORT), actual.qname)
self.assertTrue(actual.native)
actual = ElementMapper.build_attribute_type("name", "1.9")
self.assertEqual(str(DataType.FLOAT), actual.qname)
self.assertTrue(actual.native)