Skip to content

tree

xsdata.formats.dataclass.parsers.tree

TreeParser dataclass

Bases: NodeParser

Bind xml nodes to a tree of AnyElement objects.

Source code in xsdata/formats/dataclass/parsers/tree.py 
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
@dataclass
class TreeParser(NodeParser):
    """Bind xml nodes to a tree of AnyElement objects."""

    handler: type[XmlHandler] = field(default=default_handler())

    def start(
        self,
        clazz: type | None,
        queue: list[XmlNode],
        objects: list[Parsed],
        qname: str,
        attrs: dict,
        ns_map: dict,
    ) -> None:
        """Build and queue the XmlNode for the starting element.

        Args:
            clazz: The target class type, auto locate if omitted
            queue: The XmlNode queue list
            objects: The list of all intermediate parsed objects
            qname: The element qualified name
            attrs: The element attributes
            ns_map: The element namespace prefix-URI map
        """
        try:
            item = queue[-1]
            child = item.child(qname, attrs, ns_map, len(objects))
        except IndexError:
            namespace, name = namespaces.split_qname(qname)
            var = XmlVar(
                name=name,
                local_name=name,
                wrapper=None,
                xml_type=XmlType.WILDCARD,
                index=0,
                types=(object,),
                clazz=None,
                init=True,
                mixed=False,
                factory=None,
                tokens_factory=None,
                format=None,
                derived=False,
                any_type=False,
                process_contents="strict",
                required=False,
                nillable=False,
                sequence=None,
                default=None,
                namespaces=(namespace,),
                elements={},
                wildcards=(),
            )

            child = WildcardNode(
                var=var,
                attrs=attrs,
                ns_map=ns_map,
                position=0,
                factory=self.context.class_type.any_element,
            )
        queue.append(child)

start(clazz, queue, objects, qname, attrs, ns_map)

Build and queue the XmlNode for the starting element.

Parameters:

Name Type Description Default
clazz type | None

The target class type, auto locate if omitted

 required
queue list[XmlNode]

The XmlNode queue list

 required
objects list[Parsed]

The list of all intermediate parsed objects

 required
qname str

The element qualified name

 required
attrs dict

The element attributes

 required
ns_map dict

The element namespace prefix-URI map

 required
Source code in xsdata/formats/dataclass/parsers/tree.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
def start(
    self,
    clazz: type | None,
    queue: list[XmlNode],
    objects: list[Parsed],
    qname: str,
    attrs: dict,
    ns_map: dict,
) -> None:
    """Build and queue the XmlNode for the starting element.

    Args:
        clazz: The target class type, auto locate if omitted
        queue: The XmlNode queue list
        objects: The list of all intermediate parsed objects
        qname: The element qualified name
        attrs: The element attributes
        ns_map: The element namespace prefix-URI map
    """
    try:
        item = queue[-1]
        child = item.child(qname, attrs, ns_map, len(objects))
    except IndexError:
        namespace, name = namespaces.split_qname(qname)
        var = XmlVar(
            name=name,
            local_name=name,
            wrapper=None,
            xml_type=XmlType.WILDCARD,
            index=0,
            types=(object,),
            clazz=None,
            init=True,
            mixed=False,
            factory=None,
            tokens_factory=None,
            format=None,
            derived=False,
            any_type=False,
            process_contents="strict",
            required=False,
            nillable=False,
            sequence=None,
            default=None,
            namespaces=(namespace,),
            elements={},
            wildcards=(),
        )

        child = WildcardNode(
            var=var,
            attrs=attrs,
            ns_map=ns_map,
            position=0,
            factory=self.context.class_type.any_element,
        )
    queue.append(child)