Como achatar um mapeamento construído a partir de um escalar marcado usando ruamel.yaml

O tipo independente de linguagem de chave de mesclagem para definição YAML declara :

A chave de mesclagem “<<” é usada para indicar que todas as chaves de um ou mais mapas especificados devem ser inseridas no mapa atual. Se o valor associado à chave for um único nó de mapeamento, cada um de seus pares de chave/valor será inserido no mapeamento atual, a menos que a chave já exista nele. Se o valor associado à chave de mesclagem for uma sequência, espera-se que essa sequência contenha nós de mapeamento e cada um desses nós seja mesclado por vez de acordo com sua ordem na sequência. Chaves em nós de mapeamento anteriores na sequência substituem chaves especificadas em nós de mapeamento posteriores.

Você tem um nó escalar, não um nó de mapeamento ou uma sequência de nós de mapeamento. Isso é independente do tipo (Python) que é construído a partir do nó escalar.

Se você quiser adaptar o parser para aceitar seu não-YAML, você precisa adaptar a rotina de achatamento que lida com as mesclagens. Entre outras coisas, isso espera um ruamel.yaml.commments.CommentedMape não um simples dict:

# coding: utf-8
import sys
from pathlib import Path
import ruamel.yaml

import ruamel.yaml

class MyConstructor(ruamel.yaml.constructor.RoundTripConstructor):
    def flatten_mapping(self, node):
        def constructed(value_node):
            if value_node in self.constructed_objects:
                value = self.constructed_objects[value_node]
            else:
                value = self.construct_object(value_node, deep=True)
            return value

        # merge = []
        merge_map_list: List[Any] = []
        index = 0
        while index < len(node.value):
            key_node, value_node = node.value[index]
            if key_node.tag == 'tag:yaml.org,2002:merge':
                if merge_map_list:  # double << key
                    if self.allow_duplicate_keys:
                        del node.value[index]
                        index += 1
                        continue
                    args = [
                        'while constructing a mapping',
                        node.start_mark,
                        f'found duplicate key "{key_node.value}"',
                        key_node.start_mark,
                        """
                        To suppress this check see:
                           http://yaml.readthedocs.io/en/latest/api.html#duplicate-keys
                        """,
                        """\
                        Duplicate keys will become an error in future releases, and are errors
                        by default when using the new API.
                        """,
                    ]
                    if self.allow_duplicate_keys is None:
                        warnings.warn(DuplicateKeyFutureWarning(*args), stacklevel=1)
                    else:
                        raise DuplicateKeyError(*args)
                del node.value[index]
                cval = constructed(value_node)
                if isinstance(value_node, ruamel.yaml.nodes.MappingNode):
                    merge_map_list.append((index, cval))
                elif isinstance(value_node, ruamel.yaml.nodes.SequenceNode):
                    for subnode in value_node.value:
                        if not isinstance(subnode, ruamel.yaml.nodes.MappingNode):
                            raise ConstructorError(
                                'while constructing a mapping',
                                node.start_mark,
                                f'expected a mapping for merging, but found {subnode.id!s}',
                                subnode.start_mark,
                            )
                        merge_map_list.append((index, constructed(subnode)))
                elif isinstance(value_node, ruamel.yaml.nodes.ScalarNode) and isinstance(cval, dict):
                    merge_map_list.append((index, cval))
                else:
                    raise ConstructorError(
                        'while constructing a mapping',
                        node.start_mark,
                        'expected a mapping or list of mappings for merging, '
                        f'but found {value_node.id!s}',
                        value_node.start_mark,
                    )
            elif key_node.tag == 'tag:yaml.org,2002:value':
                key_node.tag = 'tag:yaml.org,2002:str'
                index += 1
            else:
                index += 1
        return merge_map_list


class MyLoader(ruamel.yaml.YAML):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.Constructor = MyConstructor
        self.constructor.add_constructor("!fullname", self._fullname_constructor)

    @staticmethod
    def _fullname_constructor(constructor, node):
        value = constructor.construct_scalar(node)
        first, *middle, last = value.split()
        return ruamel.yaml.comments.CommentedMap({
            "first_name": first,
            "middle_names": middle,
            "last_name": last

        })



myyaml = MyLoader()

data = myyaml.load("""\
id: 0
<<: !fullname Albus Percival Wulfric Brian Dumbledore
""")

print(f'{data=}')
print()
myyaml.dump(data, sys.stdout)

que dá:

data={'id': 0, 'first_name': 'Albus', 'middle_names': ['Percival', 'Wulfric', 'Brian'], 'last_name': 'Dumbledore'}

id: 0
<<:
  first_name: Albus
  middle_names:
  - Percival
  - Wulfric
  - Brian
  last_name: Dumbledore

Como você pode ver, a mesclagem é preservada ao despejar, mas o escalar não é reconstruído.