How can I parse a YAML file from a Linux shell script

Question

I wish to provide a structured configuration file which is as easy as possible for a non-technical user to edit  unfortunately it has to be a file  and so I wanted to use YAML  I can t find any way of parsing this from a Unix shell script however

User · Answer

Hard to say because it depends on what you want the parser to extract from your YAML document  For simple cases  you might be able to use grep  cut  awk etc  For more complex parsing you would need to use a full-blown parsing library such as Python s PyYAML or YAML  Perl

User · Answer

My use case may or may not be quite the same as what this original post was asking  but it s definitely similar   I need to pull in some YAML as bash variables  The YAML will never be more than one level deep   YAML looks like so   KEY                 value ANOTHER KEY         another value OH MY SO MANY KEYS  yet another value LAST KEY            last value   Output like-a dis   KEY  value  ANOTHER KEY  another value  OH MY SO MANY KEYS  yet another value  LAST KEY  last value    I achieved the output with this line   sed -e  s              g s     g s       g  file yaml  gt  file sh    s              g finds   and replaces it with     while ignoring      for URLs  s     g appends   to the end of each line s       g removes all spaces before

User · Answer

I just wrote a parser that I called Yay   Yaml ain t Yamlesque   which parses Yamlesque  a small subset of YAML  So  if you re looking for a 100  compliant YAML parser for Bash then this isn t it  However  to quote the OP  if you want a structured configuration file which is as easy as possible for a non-technical user to edit that is YAML-like  this may be of interest   It s inspred by the earlier answer but writes associative arrays  yes  it requires Bash 4 x  instead of basic variables  It does so in a way that allows the data to be parsed without prior knowledge of the keys so that  data-driven code can be written   As well as the key value array elements  each array has a keys array containing a list of key names  a children array containing names of child arrays and a parent key that refers to its parent   This is an example of Yamlesque   root key1  this is value one root key2   this is value two   drink    state  liquid   coffee      best served  hot     colour  brown   orange juice      best served  cold     colour  orange  food    state  solid   apple pie      best served  warm  root key 3  this is value three   Here is an example showing how to use it      bin bash   An example showing how to use Yay     usr lib yay    helper to get array value at key value     eval echo     1  2         print a data collection print collection       for k in   value  1 keys    do     echo   2 k     value  1  k     done    for c in   value  1 children    do     echo -e   2 c n 2       print collection  c     2      echo   2     done    yay example print collection example   which outputs   root key1   this is value one root key2   this is value two root key 3   this is value three example drink     state   liquid   example coffee         best served   hot     colour   brown       example orange juice         best served   cold     colour   orange       example food     state   solid   example apple pie         best served   warm         And here is the parser   yay parse           find input file    for f in   1    1 yay    1 yml     do         -f   f      amp  amp  input   f   amp  amp  break    done       -z   input      amp  amp  exit 1       use given dataset prefix or imply from file name       -n   2      amp  amp  local prefix   2            local prefix   basename   input    prefix   prefix              echo  declare -g -A  prefix       local s     space      w   a-zA-Z0-9     fs   echo   tr     034      sed -n -e  s     s     w   s  s           s    1 fs 2 fs 3 p              -e  s     s     w   s  s       s    1 fs 2 fs 3 p    input       awk -F fs          indent         length  1  2        key             2        value           3           No prefix or parent for the top level  indent zero        root prefix       prefix           if  indent   0             prefix                parent key      prefix            else           prefix   root prefix  parent key   keys indent-1                  keys indent    key           remove keys left behind if prior row was indented more than this row       for  i in keys   if  i  gt  indent   delete keys i           if  length value   gt  0               value          printf   s s  s     s    n   prefix  parent key   key  value            printf   s s keys       s    n   prefix  parent key   key           else              collection          printf   s s children       s s    n   prefix  parent key   root prefix  key            printf  declare -g -A  s s  n   root prefix  key            printf   s s parent     s s    n   root prefix  key  prefix  parent key                      helper to load yay data file yay     eval   yay parse            There is some documentation in the linked source file and below is a short explanation of what the code does   The yay parse function first locates the input file or exits with an exit status of 1  Next  it determines the dataset prefix  either explicitly specified or derived from the file name    It writes valid bash commands to its standard output that  if executed  define arrays representing the contents of the input data file  The first of these defines the top-level array    echo  declare -g -A  prefix     Note that array declarations are associative  -A  which is a feature of Bash version 4  Declarations are also global  -g  so they can be executed in a function but be available to the global scope like the yay helper   yay     eval   yay parse            The input data is initially processed with sed  It drops lines that don t match the Yamlesque format specification before delimiting the valid Yamlesque fields with an ASCII File Separator character and removing any double-quotes surrounding the value field    local s     space      w   a-zA-Z0-9     fs   echo   tr     034    sed -n -e  s     s     w   s  s           s    1 fs 2 fs 3 p            -e  s     s     w   s  s       s    1 fs 2 fs 3 p    input      The two expressions are similar  they differ only because the first one picks out quoted values where as the second one picks out unquoted ones   The File Separator  28 hex 12 octal 034  is used because  as a non-printable character  it is unlikely to be in the input data   The result is piped into awk which processes its input one line at a time  It uses the FS character to assign each field to a variable   indent         length  1  2  key             2  value           3    All lines have an indent  possibly zero  and a key but they don t all have a value  It computes an indent level for the line dividing the length of the first field  which contains the leading whitespace  by two  The top level items without any indent are at indent level zero   Next  it works out what prefix to use for the current item  This is what gets added to a key name to make an array name  There s a root prefix for the top-level array which is defined as the data set name and an underscore   root prefix       prefix     if  indent   0       prefix                parent key      prefix      else     prefix   root prefix  parent key   keys indent-1       The parent key is the key at the indent level above the current line s indent level and represents the collection that the current line is part of  The collection s key value pairs will be stored in an array with its name defined as the concatenation of the prefix and parent key   For the top level  indent level zero  the data set prefix is used as the parent key so it has no prefix  it s set to      All other arrays are prefixed with the root prefix   Next  the current key is inserted into an  awk-internal  array containing the keys  This array persists throughout the whole awk session and therefore contains keys inserted by prior lines  The key is inserted into the array using its indent as the array index    keys indent    key    Because this array contains keys from previous lines  any keys with an indent level grater than the current line s indent level are removed    for  i in keys   if  i  gt  indent   delete keys i      This leaves the keys array containing the key-chain from the root at indent level 0 to the current line  It removes stale keys that remain when the prior line was indented deeper than the current line         The final section outputs the bash commands  an input line without a value starts a new indent level  a collection in YAML parlance  and an input line with a value adds a key to the current collection    The collection s name is the concatenation of the current line s prefix and parent key   When a key has a value  a key with that value is assigned to the current collection like this   printf   s s  s     s    n   prefix  parent key   key  value   printf   s s keys       s    n   prefix  parent key   key     The first statement outputs the command to assign the value to an associative array element named after the key and the second one outputs the command to add the key to the collection s space-delimited keys list    lt current collection gt   lt key gt     lt value gt     lt current collection gt  keys      lt key gt      When a key doesn t have a value  a new collection is started like this   printf   s s children       s s    n   prefix  parent key   root prefix  key   printf  declare -g -A  s s  n   root prefix  key     The first statement outputs the command to add the new collection to the current s collection s space-delimited children list and the second one outputs the command to declare a new associative array for the new collection    lt current collection gt  children      lt new collection gt   declare -g -A  lt new collection gt     All of the output from yay parse can be parsed as bash commands by the bash eval or source built-in commands

User · Answer

If you have python 2 and PyYAML  you can use this parser I wrote called parse yaml py  Some of the neater things it does is let you choose a prefix  in case you have more than one file with similar variables  and to pick a single value from a yaml file   For example if you have these yaml files   staging yaml   db      type  sqllite     host  127 0 0 1     user  dev     password  password123   prod yaml   db      type  postgres     host  10 0 50 100     user  postgres     password  password123   You can load both without conflict     eval   python parse yaml py prod yaml --prefix prod --cap    eval   python parse yaml py staging yaml --prefix stg --cap    echo  PROD DB HOST 10 0 50 100   echo  STG DB HOST 127 0 0 1   And even cherry pick the values you want     prod user   python parse yaml py prod yaml --get db user    prod port   python parse yaml py prod yaml --get db port --default 5432    echo prod user postgres   echo prod port 5432

User · Answer

I ve written shyaml in python for YAML query needs from the shell command line   Overview     pip install shyaml         installation   Example s YAML file  with complex features      cat  lt  lt EOF  gt  test yaml name   MyName     subvalue      how-much  1 1     things          - first         - second         - third     other-things   a  b  c      maintainer   Valentin Lab      description            Multiline description          Line 1         Line 2 EOF   Basic query     cat test yaml   shyaml get-value subvalue maintainer Valentin Lab   More complex looping query on complex values     cat test yaml   shyaml values-0       while read -r -d    0  value  do       echo  RECEIVED    value     done RECEIVED   1 1  RECEIVED   - first - second - third  RECEIVED   2  RECEIVED   Valentin Lab  RECEIVED   Multiline description  Line 1 Line 2    A few key points    all YAML types and syntax oddities are correctly handled  as multiline  quoted strings  inline sequences      0 padded output is available for solid multiline entry manipulation   simple dotted notation to select sub-values  ie  subvalue maintainer is a valid key   access by index is provided to sequences  ie  subvalue things -1 is the last element of the subvalue things sequence    access to all sequence structs elements in one go for use in bash loops  you can output whole subpart of a YAML file as     YAML  which blend well for further manipulations with shyaml    More sample and documentation are available on the shyaml github page or the shyaml PyPI page

User · Answer

Here is a bash-only parser that leverages sed and awk to parse simple yaml files   function parse yaml      local prefix  2    local s     space      w   a-zA-Z0-9     fs   echo   tr     034      sed -ne  s     s     1             -e  s     s     w   s  s                 s    1 fs 2 fs 3 p            -e  s     s     w   s  s       s    1 fs 2 fs 3 p    1      awk -F fs          indent   length  1  2        vname indent     2        for  i in vname   if  i  gt  indent   delete vname i          if  length  3   gt  0             vn     for  i 0  i lt indent  i     vn  vn  vname i                  printf   s s s    s   n      prefix   vn   2   3                     It understands files such as      global definitions global    debug  yes   verbose  no   debugging      detailed  no     header   debugging started      output output     file   yes    Which  when parsed using   parse yaml sample yml   will output    global debug  yes  global verbose  no  global debugging detailed  no  global debugging header  debugging started  output file  yes    it also understands yaml files  generated by ruby which may include ruby symbols  like   ---  global     debug   yes     verbose   no     debugging       detailed   no       header  debugging started    output   yes    and will output the same as in the previous example   typical use within a script is   eval   parse yaml sample yml    parse yaml accepts a prefix argument so that imported settings all have a common prefix  which will reduce the risk of namespace collisions    parse yaml sample yml  CONF     yields   CONF global debug  yes  CONF global verbose  no  CONF global debugging detailed  no  CONF global debugging header  debugging started  CONF output file  yes    Note that previous settings in a file can be referred to by later settings      global definitions global    debug  yes   verbose  no   debugging      detailed  no     header   debugging started      output output     debug   global debug   Another nice usage is to first parse a defaults file and then the user settings  which works since the latter settings overrides the first ones   eval   parse yaml defaults yml  eval   parse yaml project yml

User · Answer

Given that Python3 and PyYAML are quite easy dependencies to meet nowadays  the following may help   yaml         python3 -c  import yaml print yaml safe load open   1    2      VALUE   yaml   my yaml file yaml    a key

User · Answer

Another option is to convert the YAML to JSON  then use jq to interact with the JSON representation either to extract information from it or edit it   I wrote a simple bash script that contains this glue - see Y2J project on GitHub

User · Answer

If you need a single value you could a tool which converts your YAML document to JSON and feed to jq  for example yq   Content of sample yaml   --- bob    item1      cats  bananas   item2      cats  apples   thing      cats  oranges   Example     yq -r   bob  thing    cats    sample yaml  oranges

User · Answer

here an extended version of the Stefan Farestam s answer   function parse yaml      local prefix  2    local s     space      w   a-zA-Z0-9     fs   echo   tr     034      sed -ne  s   s   s                 -e   1 s     s     w   s  s   s       s  s       s    1 2    3  n 1  -  4  t1            -e  s     s     w   s  s   s       s    1 2  n 1  -  3  p   1        sed -ne  s   s  s                 -e   1 s     s  - s  s       s  s   w   s  s       s   1-   2  n 1   3   4  t1            -e     s     s  - s  s       s   1- n 1   2  p         sed -ne  s     s     1             -e  s     s  - s                 s    1 fs fs 2 p            -e  s     s  - s       s    1 fs fs 2 p            -e  s     s     w   s  s                 s    1 fs 2 fs 3 p            -e  s     s     w   s  s       s    1 fs 2 fs 3 p         awk -F fs          indent   length  1  2        vname indent     2        for  i in vname   if  i  gt  indent   delete vname i   idx i  0         if length  2    0    vname indent     idx indent           if  length  3   gt  0             vn     for  i 0  i lt indent  i      vn  vn  vname i                  printf   s s s    s   n      prefix   vn  vname indent    3                     This version supports the - notation and the short notation for dictionaries and lists  The following input   global    input      -  main c      -  main h    flags     -O3    -fpic      sample input      -    property1  value  property2   value2        -    property1   value3   property2   value 4      produces this output   global input 1  main c  global input 2  main h  global flags 1  -O3  global flags 2  -fpic  global sample input 1 property1  value  global sample input 1 property2  value2  global sample input 2 property1  value3  global sample input 2 property2  value 4    as you can see the - items automatically get numbered in order to obtain different variable names for each item  In bash there are no multidimensional arrays  so this is one way to work around  Multiple levels are supported   To work around the problem with trailing white spaces mentioned by  briceburg one should enclose the values in single or double quotes  However  there are still some limitations  Expansion of the dictionaries and lists can produce wrong results when values contain commas  Also  more complex structures like values spanning multiple lines  like ssh-keys  are not  yet  supported   A few words about the code  The first sed command expands the short form of dictionaries   key  value       to regular and converts them to more simple yaml style  The second sed call does the same for the short notation of lists and converts   entry        to an itemized list with the - notation  The third sed call is the original one that handled normal dictionaries  now with the addition to handle lists with - and indentations  The awk part introduces an index for each indentation level and increases it when the variable name is empty  i e  when processing a list   The current value of the counters are used instead of the empty vname  When going up one level  the counters are zeroed   Edit  I have created a github repository for this

User · Answer

You could use an equivalent of yq that is written in golang     go-yg -yamlFile  home user dev ansible-firefox defaults main yml -key firefox version   returns   62 0 3

User · Answer

I know my answer is specific  but if one already has PHP and Symfony installed  it can be very handy to use Symfony s YAML parser   For instance   php -r  require   SYMFONY ROOT PATH vendor autoload php         var dump  Symfony Component Yaml Yaml  parse file get contents   YAML FILE PATH         Here I simply used var dump to output the parsed array but of course you can do much more

User · Answer

yq is a lightweight and portable command-line YAML processor      The aim of the project is to be the jq or sed of yaml files     https   github com mikefarah yq readme   As an example  stolen straight from the documentation   given a sample yaml file of   --- bob    item1      cats  bananas   item2      cats  apples   then  yq r sample yaml bob   cats   will output  - bananas - apples

User · Answer

It s possible to pass a small script to some interpreters  like Python  An easy way to do so using Ruby and its YAML library is the following     RUBY SCRIPT  data   YAML  load STDIN read   puts data  a    puts data  b      echo -e  --- na  1234 nb  4321    ruby -ryaml -e   RUBY SCRIPT  1234 4321     wheredata is a hash  or array  with the values from yaml   As a bonus  it ll parse Jekyll s front matter just fine   ruby -ryaml -e  puts YAML  load open ARGV first  read   tags    example md

User · Answer

perl -ne  chomp  printf qq  s   s  n   split   s   s      2   file yml  gt  file sh

User · Answer

Whenever you need a solution for  quot How to work with YAML JSON compatible data from a shell script quot  which works on just about every OS with Python   nix  OSX  Windows   consider yamlpath  which provides several command-line tools for reading  writing  searching  and merging YAML  EYAML  JSON  and compatible files   Since just about every OS either comes with Python pre-installed or it is trivial to install  this makes yamlpath highly portable   Even more interesting   this project defines an intuitive path language with very powerful  command-line-friendly syntax that enables accessing one or more nodes  To your specific question and after installing yamlpath using Python s native package manager or your OS s package manager  yamlpath is available via RPM to some OSes      bin bash   Read values directly from YAML  or EYAML  JSON  etc  for use in this shell script  myShellVar   yaml-get --query any path no matter how  complex source-file yaml     Use the value any way you need  echo  quot Retrieved   myShellVar  quot     Perhaps change the value and write it back  myShellVar  quot New Value quot  yaml-set --change  any path no matter how  complex --value  quot  myShellVar quot  source-file yaml  You didn t specify that the data was a simple Scalar value though  so let s up the ante   What if the result you want is an Array   Even more challenging  what if it s an Array-of-Hashes and you only want one property of each result   Suppose further that your data is actually spread out across multiple YAML files and you need all the results in a single query   That s a much more interesting question to demonstrate with   So  suppose you have these two YAML files  File  data1 yaml --- baubles    - name  Doohickey     sku  0-000-1     price  4 75     weight  2 7g   - name  Doodad     sku  0-000-2     price  10 5     weight  5g   - name  Oddball     sku  0-000-3     price  25 99     weight  25kg  File   data2 yaml --- baubles    - name  Fob     sku  0-000-4     price  0 99     weight  18mg   - name  Doohickey     price  10 5   - name  Oddball     sku  0-000-3     description  This ball is odd  How would you report only the sku of every item in inventory after applying the changes from data2 yaml to data1 yaml  all from a shell script   Try this     bin bash baubleSKUs    yaml-merge --aoh deep data1 yaml data2 yaml   yaml-get --query  baubles sku -    for sku in  quot   baubleSKUs     quot   do     echo  quot Found bauble SKU     sku  quot  done  You get exactly what you need from only a few lines of code  Found bauble SKU   0-000-1 Found bauble SKU   0-000-2 Found bauble SKU   0-000-3 Found bauble SKU   0-000-4  As you can see  yamlpath turns very complex problems into trivial solutions   Note that the entire query was handled as a stream  no YAML files were changed by the query and there were no temp files  I realize this is  quot yet another tool to solve the same question quot  but after reading the other answers here  yamlpath appears more portable and robust than most alternatives   It also fully understands YAML JSON compatible files and it does not need to convert YAML to JSON to perform requested operations   As such  comments within the original YAML file are preserved whenever you need to change data in the source YAML file   Like some alternatives  yamlpath is also portable across OSes   More importantly  yamlpath defines a query language that is extremely powerful  enabling very specialized filtered data queries   It can even operate against results from disparate parts of the file in a single query  If you want to get or set many values in the data at once -- including complex data like hashes arrays maps lists -- yamlpath can do that   Want a value but don t know precisely where it is in the document   yamlpath can find it and give you the exact path s    Need to merge multiple data file together  including from STDIN   yamlpath does that  too   Further  yamlpath fully comprehends YAML anchors and their aliases  always giving or changing exactly the data you expect whether it is a concrete or referenced value  Disclaimer   I wrote and maintain yamlpath  which is based on ruamel yaml  which is in turn based on PyYAML   As such  yamlpath is fully standards-compliant

User · Answer

I know this is very specific  but I think my answer could be helpful for certain users  If you have node and npm installed on your machine  you can use js-yaml  First install    npm i -g js-yaml   or locally npm i js-yaml   then in your bash script     bin bash js-yaml your-yaml-file yml   Also if you are using jq you can do something like that     bin bash json    js-yaml your-yaml-file yml   aproperty    jq   apropery   lt  lt  lt    json    echo   aproperty    Because js-yaml converts a yaml file to a json string literal  You can then use the string with any json parser in your unix system

User · Answer

Moving my answer from How to convert a json response into yaml in bash  since this seems to be the authoritative post on dealing with YAML text parsing from command line  I would like to add details about the yq YAML implementation  Since there are two implementations of this YAML parser lying around  both having the name yq  it is hard to differentiate which one is in use  without looking at the implementations  DSL  There two available implementations are  kislyuk yq - The more often talked about version  which is a wrapper over jq  written in Python using the PyYAML library for YAML parsing mikefarah yq - A Go implementation  with its own dynamic DSL using the go-yaml v3 parser   Both are available for installation via standard installation package managers on almost all major distributions  kislyuk yq - Installation instructions mikefarah yq - Installation instructions  Both the versions have some pros and cons over the other  but a few valid points to highlight  adopted from their repo instructions  kislyuk yq  Since the DSL is the adopted completely from jq  for users familiar with the latter  the parsing and manipulation becomes quite straightforward Supports mode to preserve YAML tags and styles  but loses comments during the conversion  Since jq doesn t preserve comments  during the round-trip conversion  the comments are lost  As part of the package  XML support is built in  An executable  xq  which transcodes XML to JSON using xmltodict and pipes it to jq  on which you can apply the same DSL to perform CRUD operations on the objects and round-trip the output back to XML  Supports in-place edit mode with -i flag  similar to sed -i   mikefarah yq  Prone to frequent changes in DSL  migration from 2 x - 3 x Rich support for anchors  styles and tags  But lookout for bugs once in a while A relatively simple Path expression syntax to navigate and match yaml nodes Supports YAML- gt JSON  JSON- gt YAML formatting and pretty printing YAML  with comments  Supports in-place edit mode with -i flag  similar to sed -i  Supports coloring the output YAML with -C flag  not applicable for JSON output  and indentation of the sub elements  default at 2 spaces  Supports Shell completion for most shells - Bash  zsh  because of powerful support from spf13 cobra used to generate CLI flags    My take on the following YAML  referenced in other answer as well  with both the versions root key1  this is value one root key2   quot this is value two quot   drink    state  liquid   coffee      best served  hot     colour  brown   orange juice      best served  cold     colour  orange  food    state  solid   apple pie      best served  warm  root key 3  this is value three  Various actions to be performed with both the implementations  some frequently used operations   Modifying node value at root level -  Change value of root key2 Modifying array contents  adding value  - Add property to coffee Modifying array contents  deleting value - Delete property from orange juice Printing key value pairs with paths - For all items under food  Using kislyuk yq   yq -y   root key2     quot this is a new value quot   yaml    yq -y   drink coffee      time   quot always quot    yaml    yq -y  del  drink orange juice colour   yaml    yq -r   food paths scalars  as  p      p join  quot   quot      getpath  p  tojson      tsv  yaml    Which is pretty straightforward  All you need is to transcode jq JSON output back into YAML with the -y flag  Using mikefarah yq    yq w yaml root key2  quot this is a new value quot      yq w yaml drink coffee time  quot always quot      yq d yaml drink orange juice colour     yq r yaml --printMode pv  quot food    quot      As of today Dec 21st 2020  yq v4 is in beta and supports much powerful path expressions and supports DSL similar to using jq  Read the transition notes - Upgrading from V3

User · Answer

A quick way to do the thing now  previous ones haven t worked for me   sudo wget https   github com mikefarah yq releases download v4 4 1 yq linux amd64 -O  usr bin yq  amp  amp   sudo chmod  x  usr bin yq  Example asd yaml  a list    - key1  value1     key2  value2     key3  value3  parsing root  user vm    yq e     asd yaml                                                                                                          a list    - key1  value1     key2  value2     key3  value3   parsing key3  user vm    yq e   a list 0  key3  asd yaml                                                                                              value3

User · Answer

You can also consider using Grunt  The JavaScript Task Runner   Can be easily integrated with shell  It supports reading YAML  grunt file readYAML  and JSON  grunt file readJSON  files   This can be achieved by creating a task in Gruntfile js  or Gruntfile coffee   e g    module exports   function  grunt         grunt registerTask  foo     load yml          grunt registerTask  load yml   function              var data   grunt file readYAML  foo yml            Object keys data  forEach function  g                     switch  g    case  my key                             then from shell just simply run grunt foo  check grunt --help for available tasks    Further more you can implement exec foo tasks  grunt-exec  with input variables passed from your task  foo    cmd   echo bar  lt    foo   gt      in order to print the output in whatever format you want  then pipe it into another command     There is also similar tool to Grunt  it s called gulp with additional plugin gulp-yaml   Install via  npm install --save-dev gulp-yaml  Sample usage   var yaml   require  gulp-yaml     gulp src    src   yml      pipe yaml       pipe gulp dest    dist      gulp src    src   yml      pipe yaml   space  2        pipe gulp dest    dist      gulp src    src   yml      pipe yaml   safe  true        pipe gulp dest    dist         To more options to deal with YAML format  check YAML site for available projects  libraries and other resources which can help you to parse that format     Other tools    Jshon     parses  reads and creates JSON

[shell] How can I parse a YAML file from a Linux shell script?

Examples related to shell

Examples related to yaml