PyYAML automatically converting certain keys to boolean values

PyYAML is YAML 1.1 conformant for parsing and emitting, and for YAML 1.1 this is at least partly documented behavior, so no idiosyncrasy at all, but conscious design.

In YAML 1.2 (which in 2009 superseded the 1.1 specification from 2005) this usage of Off/On/Yes/No was dropped, among other changes.

In ruamel.yaml (disclaimer: I am the author of that package), the round_trip_loader is a safe_loader that defaults to YAML 1.2 behaviour:

import ruamel.yaml as yaml

yaml_str = """
off:
    yes: "Flavor text for yes"  # quotes around value dropped
    no: "Flavor text for no"
"""

data = yaml.round_trip_load(yaml_str)
assert 'off' in data
print(yaml.round_trip_dump(data, indent=4))

Which gives:

off:
    yes: Flavor text for yes    # quotes around value dropped
    no: Flavor text for no

If your output needs to be version 1.1 compatible then you can dump with
an explicit version=(1, 1).

Since the quotes around the nested mapping’s scalar values are unnecessary they are not emitted on writing out.

---

If you need to do this with PyYAML, rewrite the (global) rules it uses for boolean recognition:

import  yaml
from yaml.resolver import Resolver
import re

yaml_str = """
off:
    yes: "Flavor text for yes"  # quotes around value dropped
    no: "Flavor text for no"
"""

# remove resolver entries for On/Off/Yes/No
for ch in "OoYyNn":
    if len(Resolver.yaml_implicit_resolvers[ch]) == 1:
        del Resolver.yaml_implicit_resolvers[ch]
    else:
        Resolver.yaml_implicit_resolvers[ch] = [x for x in
                Resolver.yaml_implicit_resolvers[ch] if x[0] != 'tag:yaml.org,2002:bool']

data = yaml.load(yaml_str)
print(data)
assert 'off' in data
print(yaml.dump(data))

Which gives:

{'off': {'yes': 'Flavor text for yes', 'no': 'Flavor text for no'}}
off: {no: Flavor text for no, yes: Flavor text for yes}

This works because PyYAML keeps a global dict (Resolver.yaml_implicit_resolvers) which maps first letters to a list of (tag, re.match_pattern) values. For for o, O, y and Y there is only one such pattern (and it can be deleted), but for n/N you can also match null/Null, so you have to delete the right pattern.

After that removal yes, no, on, Off are no longer recognised as bool, but True and False still are.

Simply sanitize your input:

import  yaml


def sanitize_load(s):
    s = ' ' + s
    for w in "yes no Yes No Off off On on".split():
        s = s.replace(' ' + w + ':', ' "' + w + '":')
    return yaml.load(s[1:])

with open(filename) as f:
    data = sanitize_load(f.read())
print data

This is mucht better than blindly poking in the horrible depths of pyyaml. That packages comes with two, almost but not quite identical, sources and is a maintenance nightmare.

Ran into this problem at work and had to implement it the “correct” way. Here are the steps that I took. Note, I am using the SafeLoader, not the regular Loader. The steps would be VERY similar.

General steps are

1. Create custom SafeConstuctor
2. Create custom SafeLoader that imports this custom SafeConstructor
3. Call yaml.load‘s “load” function, passing in the custom SafeLoader we
   created with the custom SafeConstructor

MySafeConstructor.py

from yaml.constructor import SafeConstructor

# Create custom safe constructor class that inherits from SafeConstructor
class MySafeConstructor(SafeConstructor):

    # Create new method handle boolean logic
    def add_bool(self, node):
        return self.construct_scalar(node)

# Inject the above boolean logic into the custom constuctor
MySafeConstructor.add_constructor('tag:yaml.org,2002:bool',
                                      MySafeConstructor.add_bool)

4. I then create a brand new loader class using the same format as the rest of the loaders defined except we pass in our newly created custom Constructor. We are essentially just “adding” to this list.

MySafeLoader.py

from yaml.reader import *
from yaml.scanner import *
from yaml.parser import *
from yaml.composer import *
from MySafeConstructor import *
from yaml.resolver import *


class MySafeLoader(Reader, Scanner, Parser, Composer, MySafeConstructor, Resolver):

    def __init__(self, stream):
        Reader.__init__(self, stream)
        Scanner.__init__(self)
        Parser.__init__(self)
        Composer.__init__(self)
        MySafeConstructor.__init__(self)
        Resolver.__init__(self)

5. Finally, we will import the custom safe loader into the main.py or wherever you are doing your load (works in __init__() too)

main.py

# Mandatory imports
from yaml import load
from MySafeLoader import MySafeLoader

def main():

    filepath_to_yaml = "/home/your/filepath/here.yml"

    # Open the stream, load the yaml doc using the custom SafeLoader
    file_stream: TextIO = open(filepath_to_yaml , 'r')
    yaml_as_dict = load(file_stream, MySafeLoader)
    file_stream.close()

    # Print our result
    print(yaml_as_dict)

Now we can use either the standard loader or our custom loader modified for the boolean logic we want. If you want other values than the strings you can try overriding the bool_values list in the MySafeConstructor class, as this is a global list containing the logic for translation.

constructor.py

    bool_values = {
        'yes':      True,
        'no':       False,
        'true':     True,
        'false':    False,
        'on':       True,
        'off':      False,
    }

Note: If you do this, you will not want to override the boolean logic, just override this list.

Just for completeness, I combined the answers of @Anthon and @wski which were both good because they

• still return values true and false as bools, only omitting bool conversion for on, off, yes, no (in any case variation)
• do not interfere with the global yaml package, i.e. affect other code

Here’s the module:

# strict_bool_yaml.py

import yaml
from yaml.loader import Reader, Scanner, Parser, Composer, SafeConstructor, Resolver


class StrictBoolSafeResolver(Resolver):
    pass

# remove resolver entries for On/Off/Yes/No
for ch in "OoYyNn":
    if len(StrictBoolSafeResolver.yaml_implicit_resolvers[ch]) == 1:
        del StrictBoolSafeResolver.yaml_implicit_resolvers[ch]
    else:
        StrictBoolSafeResolver.yaml_implicit_resolvers[ch] = [x for x in
                StrictBoolSafeResolver.yaml_implicit_resolvers[ch] if x[0] != 'tag:yaml.org,2002:bool']

class StrictBoolSafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, StrictBoolSafeResolver):
    def __init__(self, stream):
        Reader.__init__(self, stream)
        Scanner.__init__(self)
        Parser.__init__(self)
        Composer.__init__(self)
        SafeConstructor.__init__(self)
        StrictBoolSafeResolver.__init__(self)

def load(stream):
    """ Parse stream using StrictBoolSafeLoader. """
    return yaml.load(stream, Loader=StrictBoolSafeLoader)

Now use its load method instead of the one by yaml wherever strict boolean parsing is desired:

import strict_bool_yaml

strict_bool_yaml.load("""
- On
- Off
- on
- off
- true
- True
- false
- yes
- no
""")

Results in:

['On', 'Off', 'on', 'off', True, True, False, 'yes', 'no']