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)