python - parse - ¿Cómo puedo controlar qué forma escalar utiliza PyYAML para mis datos?

python pyyaml

Question

Tengo un objeto con un atributo de cadena corta y un atributo de cadena multilínea larga. Quiero escribir la cadena corta como un escalar YAML entre comillas, y la cadena multilínea como un escalar literal:

my_obj.short = "Hello"
my_obj.long = "Line1/nLine2/nLine3"

Me gustaría que el YAML se vea así:

short: "Hello"
long: |
Line1
Line2
Line3

¿Cómo puedo ordenar a PyYAML que haga esto? Si llamo a yaml.dump(my_obj) , produce una salida similar a un dict:

{long: ''line1
line2
line3
'', short: Hello}

(No estoy seguro de por qué el tiempo es doble espacio así ...)

¿Puedo dictar a PyYAML cómo tratar mis atributos? Me gustaría afectar tanto el orden como el estilo.

Answer 1

¿ Está basado en las bibliotecas yaml de Python que admiten el volcado de cadenas largas como bloques literales o bloques plegados?

import yaml
from collections import OrderedDict
class quoted(str):
pass
def quoted_presenter(dumper, data):
return dumper.represent_scalar(''tag:yaml.org,2002:str'', data, style=''"'')
yaml.add_representer(quoted, quoted_presenter)
class literal(str):
pass
def literal_presenter(dumper, data):
return dumper.represent_scalar(''tag:yaml.org,2002:str'', data, style=''|'')
yaml.add_representer(literal, literal_presenter)
def ordered_dict_presenter(dumper, data):
return dumper.represent_dict(data.items())
yaml.add_representer(OrderedDict, ordered_dict_presenter)
d = OrderedDict(short=quoted("Hello"), long=literal("Line1/nLine2/nLine3/n"))
print(yaml.dump(d))

Salida

short: "Hello"
long: |
Line1
Line2
Line3

Answer 2

Al enamorarme del enfoque de @lbt , obtuve este código:

import yaml
def str_presenter(dumper, data):
if len(data.splitlines()) > 1: # check for multiline string
return dumper.represent_scalar(''tag:yaml.org,2002:str'', data, style=''|'')
return dumper.represent_scalar(''tag:yaml.org,2002:str'', data)
yaml.add_representer(str, str_presenter)

Hace que cada cadena multilínea sea un bloque literal.

Estaba tratando de evitar la parte de parches de mono. Crédito completo para @lbt y @JFSebastian.

Answer 3

Puede usar ruamel.yaml y su RoundTripLoader / Dumper (descargo de responsabilidad: soy el autor de ese paquete) además de hacer lo que quiere, es compatible con la especificación YAML 1.2 (desde 2009) y tiene otras mejoras:

import sys
from ruamel.yaml import YAML
yaml_str = """/
short: "Hello" # does keep the quotes, but need to tell the loader
long: |
Line1
Line2
Line3
folded: >
some like
explicit folding
of scalars
for readability
"""
yaml = YAML()
yaml.preserve_quotes = True
data = yaml.load(yaml_str)
yaml.dump(data, sys.stdout)

da:

short: "Hello" # does keep the quotes, but need to tell the loader
long: |
Line1
Line2
Line3
folded: >
some like
explicit folding
of scalars
for readability

(incluyendo el comentario, comenzando en la misma columna que antes)

También puede crear esta salida desde cero, pero luego debe proporcionar la información adicional, por ejemplo, las posiciones explícitas sobre dónde plegarse.

Answer 4

Quería que cualquier entrada con un /n en ella fuera un literal de bloque. Usando el código en yaml/representer.py como base obtuve:

# -*- coding: utf-8 -*-
import yaml
def should_use_block(value):
for c in u"/u000a/u000d/u001c/u001d/u001e/u0085/u2028/u2029":
if c in value:
return True
return False
def my_represent_scalar(self, tag, value, style=None):
if style is None:
if should_use_block(value):
style=''|''
else:
style = self.default_style
node = yaml.representer.ScalarNode(tag, value, style=style)
if self.alias_key is not None:
self.represented_objects[self.alias_key] = node
return node
a={''short'': "Hello", ''multiline'': """Line1
Line2
Line3
""", ''multiline-unicode'': u"""Lêne1
Lêne2
Lêne3
"""}
print(yaml.dump(a))
print(yaml.dump(a, allow_unicode=True))
yaml.representer.BaseRepresenter.represent_scalar = my_represent_scalar
print(yaml.dump(a))
print(yaml.dump(a, allow_unicode=True))

Salida

{multiline: ''Line1
Line2
Line3
'', multiline-unicode: "L/xEAne1/nL/xEAne2/nL/xEAne3/n", short: Hello}
{multiline: ''Line1
Line2
Line3
'', multiline-unicode: ''Lêne1
Lêne2
Lêne3
'', short: Hello}
After override
multiline: |
Line1
Line2
Line3
multiline-unicode: "L/xEAne1/nL/xEAne2/nL/xEAne3/n"
short: Hello
multiline: |
Line1
Line2
Line3
multiline-unicode: |
Lêne1
Lêne2
Lêne3
short: Hello