Python 中是否有支持将长字符串转储为块文字或折叠块的 yaml 库？

Question

我希望能够转储包含长字符串的字典，我希望将其采用块样式以提高可读性。例如：

foo: |
  this is a
  block literal
bar: >
  this is a
  folded block

PyYAML 支持使用这种样式加载文档，但我似乎找不到以这种方式转储文档的方法。我错过了什么吗？

Answer 1

import yaml

class folded_unicode(unicode): pass
class literal_unicode(unicode): pass

def folded_unicode_representer(dumper, data):
    return dumper.represent_scalar(u'tag:yaml.org,2002:str', data, style='>')
def literal_unicode_representer(dumper, data):
    return dumper.represent_scalar(u'tag:yaml.org,2002:str', data, style='|')

yaml.add_representer(folded_unicode, folded_unicode_representer)
yaml.add_representer(literal_unicode, literal_unicode_representer)

data = {
    'literal':literal_unicode(
        u'by hjw              ___\n'
         '   __              /.-.\\\n'
         '  /  )_____________\\\\  Y\n'
         ' /_ /=== == === === =\\ _\\_\n'
         '( /)=== == === === == Y   \\\n'
         ' `-------------------(  o  )\n'
         '                      \\___/\n'),
    'folded': folded_unicode(
        u'It removes all ordinary curses from all equipped items. '
        'Heavy or permanent curses are unaffected.\n')}

print yaml.dump(data)

结果：

folded: >
  It removes all ordinary curses from all equipped items. Heavy or permanent curses
  are unaffected.
literal: |
  by hjw              ___
     __              /.-.\
    /  )_____________\\  Y
   /_ /=== == === === =\ _\_
  ( /)=== == === === == Y   \
   `-------------------(  o  )
                        \___/

为了完整性，还应该有 str 实现，但我会偷懒:-)

Answer 2

pyyaml 确实支持转储文字或折叠块。

使用 Representer.add_representer

定义类型：

class folded_str(str): pass

class literal_str(str): pass

class folded_unicode(unicode): pass

class literal_unicode(str): pass

然后您可以定义这些类型的表示者。
请注意，虽然 Gary 的 解决方案非常适合 unicode，您可能需要更多工作才能使字符串正常工作（请参阅represent_str 的实现）。

def change_style(style, representer):
    def new_representer(dumper, data):
        scalar = representer(dumper, data)
        scalar.style = style
        return scalar
    return new_representer

import yaml
from yaml.representer import SafeRepresenter

# represent_str does handle some corner cases, so use that
# instead of calling represent_scalar directly
represent_folded_str = change_style('>', SafeRepresenter.represent_str)
represent_literal_str = change_style('|', SafeRepresenter.represent_str)
represent_folded_unicode = change_style('>', SafeRepresenter.represent_unicode)
represent_literal_unicode = change_style('|', SafeRepresenter.represent_unicode)

然后，您可以将这些表示符添加到默认转储器中：

yaml.add_representer(folded_str, represent_folded_str)
yaml.add_representer(literal_str, represent_literal_str)
yaml.add_representer(folded_unicode, represent_folded_unicode)
yaml.add_representer(literal_unicode, represent_literal_unicode)

... 并测试它：

data = {
    'foo': literal_str('this is a\nblock literal'),
    'bar': folded_unicode('this is a folded block'),
}

print yaml.dump(data)

结果：

bar: >-
  this is a folded block
foo: |-
  this is a
  block literal

使用 default_style

如果您有兴趣让所有字符串都遵循默认样式，您还可以使用 default_style 关键字参数，例如：

>>> data = { 'foo': 'line1\nline2\nline3' }
>>> print yaml.dump(data, default_style='|')
"foo": |-
  line1
  line2
  line3

或 对于折叠文字：

>>> print yaml.dump(data, default_style='>')
"foo": >-
  line1

  line2

  line3

或对于双引号文字：

>>> print yaml.dump(data, default_style='"')
"foo": "line1\nline2\nline3"

警告：

这是您可能意想不到的示例：

data = {
    'foo': literal_str('this is a\nblock literal'),
    'bar': folded_unicode('this is a folded block'),
    'non-printable': literal_unicode('this has a \t tab in it'),
    'leading': literal_unicode('   with leading white spaces'),
    'trailing': literal_unicode('with trailing white spaces  '),
}
print yaml.dump(data)

结果：

bar: >-
  this is a folded block
foo: |-
  this is a
  block literal
leading: |2-
     with leading white spaces
non-printable: "this has a \t tab in it"
trailing: "with trailing white spaces  "

1) 不可打印字符

请参阅 YAML 规范转义字符 (第 5.7 节）：

请注意，转义序列仅在双引号标量中解释。在所有其他标量样式中，“\”字符没有特殊含义，并且不可打印的字符不可用。

如果要保留不可打印的字符（例如 TAB），则需要使用双引号标量。如果您能够使用文字样式转储标量，并且其中存在不可打印字符（例如 TAB），则您的 YAML 转储程序不合规。

例如 pyyaml 检测不可打印字符 \t 并使用双引号样式，即使指定了默认样式：

>>> data = { 'foo': 'line1\nline2\n\tline3' }
>>> print yaml.dump(data, default_style='"')
"foo": "line1\nline2\n\tline3"

>>> print yaml.dump(data, default_style='>')
"foo": "line1\nline2\n\tline3"

>>> print yaml.dump(data, default_style='|')
"foo": "line1\nline2\n\tline3"

2) 前导和尾随空格

另一点有用规范中的信息是：

内容中排除所有前导和尾随空白字符

这意味着，如果您的字符串确实具有前导或尾随空格，则除了双引号之外，这些字符不会以标量样式保留。因此，pyyaml 尝试检测标量中的内容，并可能强制使用双引号样式。

Answer 3

这可以相对容易地完成，唯一的“障碍”是如何
指示字符串中的哪些空格需要被替换
表示为折叠标量，需要成为折叠。字面标量
有包含该信息的显式换行符，但这不能
用于折叠标量，因为它们可以包含显式换行符，例如
如果有前导空格，并且末尾还需要换行
为了不使用剥离 chomping 指示符 (>-) 表示

import sys
import ruamel.yaml

folded = ruamel.yaml.scalarstring.FoldedScalarString
literal = ruamel.yaml.scalarstring.LiteralScalarString

yaml = ruamel.yaml.YAML()

data = dict(
    foo=literal('this is a\nblock literal\n'), 
    bar=folded('this is a folded block\n'),
)

data['bar'].fold_pos = [data['bar'].index(' folded')]

yaml.dump(data, sys.stdout)

，该指示符给出：

foo: |
  this is a
  block literal
bar: >
  this is a
  folded block

fold_pos 属性需要一个可逆的可迭代，表示位置
空格指示折叠位置。

如果你的字符串中从来没有管道字符（'|'），那么你
可以做类似的事情：

import re

s = 'this is a|folded block\n'
sf = folded(s.replace('|', ' '))  # need to have a space!
sf.fold_pos = [x.start() for x in re.finditer('\|', s)]  # | is special in re, needs escaping


data = dict(
    foo=literal('this is a\nblock literal\n'), 
    bar=sf,  # need to have a space
)

yaml = ruamel.yaml.YAML()
yaml.dump(data, sys.stdout)

这也给出了您期望的输出