yq | Pure Python implementation a subset the features | YAML Processing library

May be something like this?

Using kislyuk/yq you can base your filter on jq.

• to_entries splits up the object into an array of key-value pairs
• select selects those items matching your criteria
• String interpolation in combination with the -r option puts together your desired output

Your second approach can work, but in a roundabout way, as mikefarah/yq does not support updating multi-line block literals yet

One way to solve this, with the existing constructs would be to do below, without having to create a temporary YAML file

You can either make name and mountPath appear on the same level:

You need to pass the --front-matter=process when modifying the front-matter content and pass the required expression to modify the tags.

For case 1) pre-formatted array notation with just sorting needed, use yq as

With the syntax you've shown in the question, I would assume you are using mikefarah/yq.

Its DSL is almost similar to that of jq, so you can use select operator for choosing the right record and use the |= to update the desired value

You're asking for equivalence but that's not a term in the spec and therefore cannot be discussed (at least not without definition). I'll go with discussing equality instead, which is defined by the spec as follows:

Two scalars are equal only when their tags and canonical forms are equal character-by-character. Equality of collections is defined recursively.

One node in your example has the tag !!binary but the others do not have tags. So we must check what the spec says about tags of nodes that don't have explicit tags:

The YAML spec says that every node is to have a tag. Any node that does not have an explicit tag gets a non-specific tag assigned. Nodes are divided into scalars (that get created from textual content) and collections (sequences and mappings). Every non-plain scalar node (i.e. every scalar in quotes or given via | or >) that does not have an explicit tag gets the non-specific tag !, every other node without explicit tag gets the non-specific tag ?.

During loading, the spec defines that non-specific tags are to be resolved to specific tags by means of using a scheme. The specification describes some schemes, but does not require an implementation to support any particular one.

The failsafe scheme, which is designed to be the most basic scheme, will resolve non-specific tags as follows:

• on scalars to !!str
• on sequences to !!seq
• on mappings to !!map

and that's it.

A scheme is allowed to derive a specific tag from a non-specific one by considering the kind of non-specific tag, the node's position in the document, and the node's content. For example, the JSON Scheme will give a scalar true the tag !!bool due to its content.

The spec says that the non-specific tag ! should only be resolved to !!str for scalars, !!seq for sequence, and !!map for mappings, but does not require this. This is what most implementations support and means that if you quote your scalar, you will get a string. This is important so that you can give the scalar "true" quoted to avoid getting a boolean value.

By the way, the spec does not say that every step defined there is to be implemented slavishly as defined in the spec, it is more a logical description. A lot of implementations do not actually transition from non-specific tags to specific tags, but instead directly choose native types for the YAML data they load according to the scheme rules.

Now that we know how tags are assigned to nodes, let's go over your example:

One way to fix that would be include a select statement at the top level to act on only Deployment type

It can be accomplished by doing a recursive decent to identify keys matching your string and update their value part using |=