strictyaml 0.1.4

Strict, typed YAML parser

StrictYAML is a type-safe YAML parser, built on ruamel.yaml that eliminates most of the bullshit in the YAML spec.

It’s designed to serve as an easy drop in replacement parser for either pyyaml, ruamel.yaml or poyo.

Simple example:

name: Ford Prefect
age: 42
posessions:
  - Towel

>>> strictyaml.load(yaml) \
  == {"name": "Ford Prefect", "age": "42", "possessions": ["Towel", ]}   # note 42 is a string

Example using validator with mapping, sequence, string and integer:

>>> from strictyaml import load, Map, Str, Int, Seq
>>> load(yaml, Map({"name": Str(), "age": Int(), "possessions": Seq(Str())})) \
  == {"name": "Ford Prefect", "age": 42, "possessions": ["Towel", ]}     # 42 is now an int

FAQ

From learning programmers:

• What is YAML?

• Why should I care about YAML?

• When should I use a validator and when should I not?

If you’re looking at this and thinking “why not do/use X instead?” that’s a healthy response, and you deserve answers. These are probably the questions you’re asking:

• Why should I use strictyaml instead of ordinary YAML?

• What bullshit in ordinary YAML does strictyaml remove?

• What do you mean implicit typing is a terrible idea?

• Why not use JSON for configuration or DSLs?

• Why not use INI files for configuration or DSLs?

• Why shouldn’t I just use python for configuration?

• Why not use XML for configuration or DSLs?

• Why not use TOML?

• Why not use HJSON?

• Why not use JSON5?

• Why not use pykwalify to validate YAML instead?

• What if I still disagree with everything you wrote here?

Map Patterns

If you’re not sure what the key is going to be but you know what type the values will be, use this.

emails:
  arthur: [e-mail]
  zaphod: [e-mail]
  ford: [e-mail]

>>> from strictyaml import load, Map, MapPattern, Str
>>> load(yaml, Map({"emails": MapPattern({Str(), Str()})}) \
  == {"emails": {"arthur": "[e-mail]", "zaphod": "[e-mail]", "ford": "[e-mail]"}}

All Scalar Types

StrictYAML will parse a string into the correct data type if you specify it:

>>> import from strictyaml import load, Map
>>> load("string: string", Map({"string": strictyaml.Str()})) == {"string": "string"}
>>> load("float: 42.3333", Map({"float": strictyaml.Float()})) == {"string": 42.3333}
>>> load("price: 35.42811", Map({"price": strictyaml.Decimal()})) == {"price": decimal.Decimal('35.32811')}

>>> load("booltrue: yes", Map({"booltrue": strictyaml.Bool()})) == {"booltrue": True}
>>> load("boolfalse: no", Map({"boolfalse": strictyaml.Bool()})) == {"booltrue": True}
>>> load("booltrue: true", Map({"booltrue": strictyaml.Bool()})) == {"booltrue": True}
>>> load("boolfalse: False", Map({"boolfalse": strictyaml.Bool()})) == {"booltrue": False}

>>> load("enum: monday", Map({"enum": strictyaml.Enum(["monday", "tuesday", "wednesday"])})) == {"enum": "monday"}

Custom scalar types

COMING SOON

Using Kwalify

See: What is kwalify and when should I use it?

COMING SOON