How can I preserve original quotes when processing YAML annotations with PyYAML?

PyYAML (and its standard dumper) doesn’t track or preserve the quoting style from the input. When you load YAML into Python objects, all the stylistic details (such as whether a string was quoted or not) are lost—only the final string value is retained. Consequently, when PyYAML dumps these objects, it re-serializes them using its own formatting rules, which explains why your quotes are “lost” in the output.

What Can You Do?

1. Use a Library Designed for Round-Tripping:
   The ruamel.yaml library is built for round-trip editing of YAML and can preserve quotes when used properly. However, you must load the YAML with its round-trip loader (e.g., using ruamel.yaml.YAML(typ="rt")) and work with its data structures directly. For example:

   PYTHONCopied
   from ruamel.yaml import YAML
   
   yaml_ruamel = YAML(typ="rt")  # Round-trip mode
   with open("annotations.yaml") as f:
       data = yaml_ruamel.load(f)
   
   # (Perform needed manipulations on 'data')
   
   with open("namespace.yaml", "w") as f:
       yaml_ruamel.dump(data, f)

   Note: You’ll need to adapt your code so that you’re not converting the data into plain Python dictionaries (which lose the quote information) but instead work with ruamel.yaml’s preserved structure.

2. Custom String Wrapper (with PyYAML):
   In PyYAML you can define a custom subclass of str (for example, QuotedStr) that retains its intended quote style in an attribute and then create a custom representer that uses the desired style when dumping. However, this approach requires extra effort and manual tracking of which strings should be quoted.

   For instance:

   PYTHONCopied
   import yaml
   
   class QuotedStr(str):
       def __new__(cls, value, quoted=False):
           obj = str.__new__(cls, value)
           obj.quoted = quoted
           return obj
   
   def quoted_str_representer(dumper, data):
       style = "'" if data.quoted else None
       return dumper.represent_scalar('tag:yaml.org,2002:str', data, style=style)
   
   yaml.add_representer(QuotedStr, quoted_str_representer)
   
   # Example usage:
   my_data = {
       'annotations': {
           'example.com/catalog-item-20': QuotedStr('server1.test.local:80', quoted=True),
           'openshift.io/sa.scc.mcs': QuotedStr('s0,c107,c49', quoted=True),
           'collectord.io/logs-index': 'channel_1',
           # etc.
       }
   }
   
   with open('namespace.yaml', 'w') as f:
       yaml.dump(my_data, f, default_flow_style=False)

   With this approach, you’ll have to mark which values require quotes when you parse your input, ensuring that you wrap them in QuotedStr with the appropriate flag. This gives you manual control over the quoting in the output.

Summary

• PyYAML limitation: PyYAML doesn’t preserve input quote formatting because this information is lost when YAML is loaded into plain Python data types.
• Alternative routes: Use ruamel.yaml’s round-trip capabilities or implement a custom solution (such as a custom scalar subclass with a representer) if you need precise control over the output quoting.

Choose the approach that best fits your workflow. If you want to minimize changes to your code, ruamel.yaml’s round-trip mode is likely the best option, provided you adapt your data manipulations to its data structures.