使yaml / ruamel.yaml总是内联转储列表

Question

How do I make PyYAML or ruamel.yaml always dump lists inline? Be it lists of YAML elements loaded from an existing file or added from my code.

When I load YAML from a file and then dump it, it dumps lists inline (see code below). But if I add a new YAML element with lists to the existing parent object and then dump it, it dumps lists not inline.

I tried with Python 3.7.3, PyYAML 5.1.1 and ruamel.yaml 0.15.97.

>>> import ruamel.yaml
>>> ruamel.yaml.__version__
'0.15.97'
>>> raw_yaml = """
... users:
...   user1:
...     comment: comment1
...     keys: ["user1 key1", "user1 key2"]
...     groups: ["user1 group1", "user1 group2"]
... """
>>> yaml = ruamel.yaml.round_trip_load(raw_yaml, preserve_quotes=True)
>>> dump = ruamel.yaml.round_trip_dump(yaml, default_flow_style=None)
>>> print(dump)
users:
  user1:
    comment: comment1
    keys: ["user1 key1", "user1 key2"]
    groups: ["user1 group1", "user1 group2"]
# So far so good, 'keys' and 'groups' are dumped inline
>>> yaml['users']['user2'] = {}
>>> yaml['users']['user2']['comment'] = 'comment2'
>>> yaml['users']['user2']['keys'] = []
>>> yaml['users']['user2']['keys'].append('user2 key1')
>>> yaml['users']['user2']['keys'].append('user2 key2')
>>> yaml['users']['user2']['groups'] = []
>>> yaml['users']['user2']['groups'].append('user2 group1')
>>> yaml['users']['user2']['groups'].append('user2 group2')
>>> dump = ruamel.yaml.round_trip_dump(
...     yaml, default_flow_style=False, default_style="'",
...     indent=2, block_seq_indent=2)
# desired result:
# users:
#   user1:
#     comment: comment1
#     keys: ["user1 key1", "user1 key2"]
#     groups: ["user1 group1", "user1 group2"]
#   user2:
#     comment: comment2
#     keys: ["user2 key1", "user2 key2"]
#     groups: ["user2 group1", "user2 group2"]
>>> print(dump)
'users':
    'user1':
        'comment': 'comment1'
        'keys': ["user1 key1", "user1 key2"]
        'groups': ["user1 group1", "user1 group2"]
    'user2':
        'comment': 'comment2'
        'keys':
            - 'user2 key1'
            - 'user2 key2'
        'groups':
            - 'user2 group1'
            - 'user2 group2'

See above, when I dump just loaded YAML (users['user1']), the lists are inline:

keys: ["user1 key1", "user1 key2"]
groups: ["user1 group1", "user1 group2"]

But when I add users['user2'] and then dump entire YAML object, the lists are not inline:

'keys':
    - 'user2 key1'
    - 'user2 key2'
'groups':
    - 'user2 group1'
    - 'user2 group2'

If I set 'default_flow_style=True', it dumps the entire element inline:

'user2': {'comment': 'comment2', 'keys': ['user2 key1', 'user2 key2'], 'groups': [ 'user2 group1', 'user2 group2']}

This is not what I want. I want 'comment', 'keys' and 'groups' are dumped on separate lines with lists inline:

user2:
  comment: comment2
  keys: ["user2 key1", "user2 key2"]
  groups: ["user2 group1", "user2 group2"]

For PyYaml, the situation is practically the same.

I want lists are being always dumped inline (as for users['user1']). How do I do that?

Answer 1

I can only answer for PyYAML: The behavior was changed in version 5.1.

https://github.com/yaml/pyyaml/pull/256

False will output block style always. True will output flow style always. None will output flow style only for the collections which consists only of scalars.

False is now the default because many users complained that the previous default None wasn't a good one.

So you want default_flow_style=None for PyYAML.

data = dict( a=dict(aa=dict(aaa = ['x','y']), ab=42) )
print( yaml.dump( data ) )
print( yaml.dump( data, default_flow_style=True ) )
print( yaml.dump( data, default_flow_style=False ) )
print( yaml.dump( data, default_flow_style=None ) )

Output:

a:
  aa:
    aaa:
    - x
    - y
  ab: 42

{a: {aa: {aaa: [x, y]}, ab: 42}}

a:
  aa:
    aaa:
    - x
    - y
  ab: 42

a:
  aa:
    aaa: [x, y]
  ab: 42```

Answer 2

What you call inline is called flow-style in the YAML documentation. There is an option ( default_flow_style ) in both ruamel.yaml to globally have everything flow-style, everything block-style, or have leaf-nodes flow-style (rest block style). This is the old behaviour of PyYAML.

However this is not what you want as that affect both sequences and mappings, and you want mappings only.

ruamel.yaml , in round-trip-mode, can preserve individual flow-style/block-style as they occur in your file, so you can have eg leave nodes and their parents be flow-style, or all sequences (Python lists) flow-style and all mappings (Python dicts) block-style The latter of course only works as long as mapping is not "under" a sequence, as you cannot have block style within flow-style.

If you start from scratch or with a loaded YAML that has the right format, just make sure any added lists are actually the special internal list subclass that ruamel.yaml uses to preserve comments, style etc and set the flow-style on the added lists

import sys
import ruamel.yaml
from ruamel.yaml.scalarstring import DoubleQuotedScalarString as dq

def L(*l):
   ret = ruamel.yaml.comments.CommentedSeq(l)
   ret.fa.set_flow_style()
   return ret   


raw_yaml = """\
users:
   user1:
    comment: comment1
    keys: ["user1 key1", "user1 key2"]
    groups: ["user1 group1", "user1 group2"]
"""

yaml = ruamel.yaml.YAML()
# yaml.indent(mapping=4, sequence=4, offset=2)
yaml.preserve_quotes = True
data = yaml.load(raw_yaml)
data['users']['user2'] = {}
data['users']['user2']['comment'] = 'comment2'
data['users']['user2']['keys'] = L()
data['users']['user2']['keys'].append('user2 key1')
data['users']['user2']['keys'].append('user2 key2')
data['users']['user2']['groups'] = L('abc', L('user2 group1', dq('user2 group2')))
# print(data)
yaml.dump(data, sys.stdout)

which gives:

users:
  user1:
    comment: comment1
    keys: ["user1 key1", "user1 key2"]
    groups: ["user1 group1", "user1 group2"]
  user2:
    comment: comment2
    keys: [user2 key1, user2 key2]
    groups: [abc, [user2 group1, "user2 group2"]]

Since you want every list to be represented as a flow style sequence, it is also possible to change the representer for all lists, by subclassing the Representer, but the above gives you finer control and allows you to flow exactly those lists you want in flow-style.

---

ruamel.yaml (and PyYAML) use a streaming interface, doing print(dump(data)) instead of dump(data, sys.stdout) makes the dump be done to a buffer in memory and then you stream that buffer. It is inefficient in time and space, don't do it .