How do I make yaml.dump render a <<:

[delfick]

Hello,

Is it possible, and if so, how, to make yaml.dump output something like

my_dictionary:
    <<: *some_anchor

?

[delfick]

I ended up doing this

import attrs
import yaml


class MyDumper(yaml.Dumper):
    """
    We inherit a yaml Dumper class so that we can customize how the YAML is rendered
    """

    def serialize_node(
        self, node: yaml.Node, parent: yaml.Node | None, index: yaml.Node | None
    ) -> None:
        """
        This is used in concert with the presenters below to render

        * yaml anchor aliases
        * the double angle brackets for unpacking anchor aliases into a map
        """
        if node.tag == "!alias":
            self.anchors[node] = node.value
            self.serialized_nodes[node] = True

        elif node.tag == "!map_anchor_key":
            self.serialized_nodes[node] = True
            self.descend_resolver(parent, index)
            self.emit(
                yaml.ScalarEvent(
                    None, "tag:yaml.org,2002:str", (True, True), "<<", style=""
                )
            )
            self.ascend_resolver()
            return

        super().serialize_node(node, parent, index)


@attrs.frozen
class AnchorReference:
    name: str


def yaml_alias_presenter(dumper: yaml.Dumper, data: AnchorReference) -> yaml.ScalarNode:
    """
    This lets us render AnchorReference objects in our YAML the way we want.

    So for example, we can yaml.dump:

        AnchorReference("my_anchor")

    And get as output:

        *my_anchor

    This works in concert with `serialize_node` on the Dumper itself.
    """
    return dumper.represent_scalar("!alias", data.name, style=None)


MyDumper.add_representer(AnchorReference, yaml_alias_presenter)


@attrs.frozen
class Anchored:
    anchor: str

    name: str
    value: object


def yaml_anchor_presenter(dumper: yaml.Dumper, data: Anchored) -> yaml.MappingNode:
    """
    This lets us render Anchored objects in our YAML the way we
    want.

    So for example, we can yaml.dump:

        Anchored(
            anchor="my_anchor",
            name="some_stuff",
            value=...
        )

    And get as output:

        some_stuff: &my_anchor
            ...
    """
    node = dumper.represent_mapping("tag:yaml.org,2002:map", {data.name: data.value})
    dumper.anchor_node(node.value[0][1])
    dumper.anchors[node.value[0][1]] = data.anchor
    return node


MyDumper.add_representer(Anchored, yaml_anchor_presenter)


@attrs.frozen
class MapAnchorKey:
    pass


def yaml_map_anchor_key(dumper: yaml.Dumper, data: MapAnchorKey) -> yaml.ScalarNode:
    """
    Used to render angle brackets for a key in a map that is provided anchor references.

    For example, we can yaml.dump:

        {
            MapAnchorKey(): AnchorReference(name="my_anchor"),
            "another_key": 1
        }

    and get as output:

        <<: *my_anchor
        another_key: 1

    This works in concert with `serialize_node` on the Dumper itself.
    """
    return yaml.ScalarNode("!map_anchor_key", data, style="")


MyDumper.add_representer(MapAnchorKey, yaml_map_anchor_key)


my_example = {
    "things": Anchored(anchor="my_stuff", name="stuff", value={"a": 1, "b": 2}),
    "example": {"blah": {MapAnchorKey(): AnchorReference("my_stuff"), "things": 2}},
}
print(
    yaml.dump(
        my_example,
        sort_keys=False,
        # Make yaml not wrap long lines
        width=1000,
        Dumper=MyDumper,
    )
)

Which renders

my_example = {
    "things": Anchored(anchor="my_stuff", name="stuff", value={"a": 1, "b": 2}),
    "example": {"blah": {MapAnchorKey(): AnchorReference("my_stuff"), "things": 2}},
}

as

things:
  stuff: &my_stuff
    a: 1
    b: 2
example:
  blah:
    <<: *my_stuff
    things: 2

I imagine the way I've figured this out is more awkward than it needs to be, is there a better way to make this work?

Thanks