如何配置ruamel.yaml.dump输出？

Question

有了这个数据结构:

d = {
    (2,3,4): {
        'a': [1,2], 
        'b': 'Hello World!',
        'c': 'Voilà!'
    }
}

我想得到这个YAML:

%YAML 1.2
---
[2,3,4]:
  a:
    - 1
    - 2
  b: Hello World!
  c: 'Voilà!'

不幸的是我得到这种格式:

$ print ruamel.yaml.dump(d, default_flow_style=False, line_break=1, explicit_start=True, version=(1,2))
%YAML 1.2
---
? !!python/tuple
- 2
- 3
- 4
: a:
  - 1
  - 2
  b: Hello World!
  c: !!python/str 'Voilà!'

我无法配置我想要的输出safe_dump.如果没有手动正则表达式输出,我怎么能这样做呢？

我发现的唯一丑陋的解决方案是:

def rep(x):
    return repr([int(y) for y in re.findall('^\??\s*-\s*(\d+)', x.group(0), re.M)]) + ":\n"
print re.sub('\?(\s*-\s*(\w+))+\s*:', rep, 
    ruamel.yaml.dump(d, default_flow_style=False, line_break=1, explicit_start=True, version=(1,2)))

Answer 1

如果没有ruamel.yaml.dump()对内部进行重大修改,您无法获得您想要的输出 .

• 你喜欢的输出有顶级映射(键[2,3,4],[2, 3, 4]等)的值的缩进2 和序列元素的缩进4,它是ruamel.yaml.dump()键的值(a推入2个位置.这至少会需要在缩进级别之间进行映射和序列(如果不是针对单个集合)的差异,这是非平凡的.
• 您的序列输出将从b(逗号,空格)压缩为"正常"流式传输到a a.IIRC目前不能受任何参数的影响,并且由于您在发射集合时几乎没有上下文知识,因此很难"在发出作为关键的序列时不包括空格".另外一个选项-需要更改几个源文件和类.

解决问题的难点问题:

• 你的元组必须神奇地转换为一个序列来摆脱标记,.因为你不想影响所有元组,所以IMO最好通过创建一个子类,并将其表示为一个序列(如果实际用作键,则可选地将这样的元组表示为列表).您可以使用dump()它(假设!!python/tuple,它在使用时具有适当的表示支持tuple
• 你的关键是,在发射之前进行测试时,不是一个简单的钥匙,因此得到一个'？'(问号,空格)表示复杂的映射关键字..您必须更改发射器,以便comments.CommentedKeySeq启动一个简单的键(如果它具有流样式而不是块样式).另一个问题是,这样的SequenceStartEvent将被"测试"以具有ruamel.yaml>=0.12.14属性(这可能表明在键上明确需要'？').这需要改变ruamel.yaml.round_trip_dump()和SequenceStartEvent.
• 为您的标量字符串值style获得报价,而你的标字符串值emitter.py:Emitter.check_simple_key()不.你只能通过使它们成为不同的类型来获得ruamel.yaml中输出的那种差异.例如,通过使其类型emitter.py:Emitter.expect_block_mapping_key()(和使用c).

如果你这样做:

import sys
import ruamel.yaml


d = {
    (2,3,4): {
        'a': [1,2], 
        'b': 'Hello World!',
        'c': 'Voilà!'
    }
}

def prep(d):
    if isinstance(d, dict):
        needs_restocking = False
        for idx, k in enumerate(d):
            if isinstance(k, tuple):
                needs_restocking = True
            try:
                if 'à' in d[k]:
                    d[k] = ruamel.yaml.scalarstring.SingleQuotedScalarString(d[k])
            except TypeError:
                pass
            prep(d[k])
        if not needs_restocking:
            return
        items = list(d.items())
        for (k, v) in items:
            d.pop(k)
        for (k, v) in items:
            if isinstance(k, tuple):
                k = ruamel.yaml.comments.CommentedKeySeq(k)
            d[k] = v
    elif isinstance(d, list):
        for item in d:
            prep(item)

yaml = ruamel.yaml.YAML()
yaml.indent(mapping=2, sequence=4, offset=2)
yaml.version = (1, 2)
data = prep(d)
yaml.dump(d, sys.stdout)

你会得到:

%YAML 1.2
---
[2, 3, 4]:
  a:
    - 1
    - 2
  b: Hello World!
  c: 'Voilà!'

除了现在一致的缩进级别2之外,流式样序列中的额外空格以及所需的使用b,将使您尽可能接近您想要的而无需重大返工.

上述代码是否丑陋当然是品味问题.

使用时,输出将非正常地正确往返scalarstring.SingleQuotedScalarString().

如果不需要控制引号,并且映射键的顺序也不重要,那么您也可以修补普通的转储器:

import sys
import ruamel.yaml
from ruamel.yaml.comments import CommentedMap, CommentedKeySeq
assert ruamel.yaml.version_info >= (0, 12, 14)

data = CommentedMap()
data[CommentedKeySeq((2, 3, 4))] = cm = CommentedMap()
cm['a'] = [1, 2]
cm['b'] = 'Hello World!'
cm['c'] = ruamel.yaml.scalarstring.SingleQuotedScalarString('Voilà!')

ruamel.yaml.round_trip_dump(data, sys.stdout, explicit_start=True, version=(1, 2))

然后你可以使用正常的序列:

%YAML 1.2
---
[2, 3, 4]:
  a:
  - 1
  - 2
  b: Hello World!
  c: 'Voilà!'

会给你:

def my_key_repr(self, data):
    if isinstance(data, tuple):
        print('data', data)
        return self.represent_sequence(u'tag:yaml.org,2002:seq', data,
                                       flow_style=True)
    return ruamel.yaml.representer.SafeRepresenter.represent_key(self, data)

ruamel.yaml.representer.Representer.represent_key = my_key_repr

请注意,您需要在输出中明确允许使用unicode(默认使用round_trip_dump())round_trip_dump.

¹ _{免责声明:我是ruamel.yaml的作者.}