strictyaml 0.4.0

Strict, typed YAML parser

StrictYAML is a type-safe YAML parser built atop ruamel.yaml that parses a restricted subset of the YAML specificaton.

Priorities:

• Readability of YAML.

• Ease of use of API.

• Secure by default.

• Strict validation of markup and straightforward type casting.

• Clear, human readable exceptions with line numbers.

• Acting as a drop in replacement for pyyaml, ruamel.yaml or poyo.

• Letting you worry about more interesting things than parsing config files.

Simple example:

name: Ford Prefect
age: 42
posessions:
  - Towel

Default parse result:

>>> strictyaml.load(yaml) \
  == {"name": "Ford Prefect", "age": "42", "possessions": ["Towel", ]}   # All data is str, list or dict

Example using optional validator - using 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

Install It

$ pip install strictyaml

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 features does StrictYAML remove?

• 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 name is going to be in a map but you know what type the keys and values will be, use “MapPattern”.

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]"}}

Optional values

If you want to use a mapping with a number of required keys and a number of optional keys use “Optional”:

arthur:
  email: [e-mail]
zaphod:
  email: [e-mail]
  job: President of the Galaxy
ford:
  email: [e-mail]
  job: Freelance "journalist"

This would be parsed like so:

>>> from strictyaml import load, MapPattern, Map, Str, Optional
>>> load(yaml, MapPattern(Str(), Map({"email": Str(), Optional("job"): Str()}))) \
  == {
         "arthur": {'email': '[e-mail]',},
         "zaphod": {'email': '[e-mail]', 'job': 'President of the Galaxy'},
         "ford": {'email': '[e-mail]', 'job': 'Freelance "journalist"'},
     }

Either/Or

If, for example, you want to parse something as a list of strings or an individual string, you can use a pipe operator to distinguish between them - like so: |

zaphod:
  email: [e-mail]
  victims: Good taste
ford:
  email: [e-mail]
  victims: Journalistic integrity
arthur:
  email: [e-mail]
  victims:
    - A bowl of petunias
    - Agrajag
    - A sperm whale

This would be parsed like so:

>>> from strictyaml import load, Seq, Map, Str, Optional
>>> load(yaml, MapPattern(Str(), Map({"email": Str(), "victims": Str() | Seq(Str())}))) \
  == {
         "zaphod": {'email': '[e-mail]', 'victims': 'President of the Galaxy'},
         "arthur": {'email': '[e-mail]', 'victims': 'Journalistic integrity'},
         "ford": {'email': '[e-mail]', 'victims': ['A bowl of petunias', 'Agrajag', 'A sperm whale', ]},
     }

Numbers

StrictYAML will parse a string into integers, floating point or decimal (non-floating point) numbers if you specify it:

>>> import from strictyaml import load, Map
>>> load("int: 42", Map({"int": strictyaml.Int()})) == {"int": 42}
>>> load("float: 42.3333", Map({"float": strictyaml.Float()})) == {"float": 42.3333}
>>> load("price: 35.42811", Map({"price": strictyaml.Decimal()})) == {"price": decimal.Decimal('35.42811')}

Booleans

Upper case or lower case - it doesn’t matter. Yes, on and true are treated as True and no, off and false are treated as False.

>>> 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}

Empty values

Empty values can be be validated and returned as None, {} and []:

>>> load("empty: ", Map({"empty": strictyaml.EmptyNone()})) == {"empty": None}
>>> load("empty: ", Map({"empty": strictyaml.EmptyDict()})) == {"empty": {}}
>>> load("empty: ", Map({"empty": strictyaml.EmptyList()})) == {"empty": []}

Enums

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

Datetimes

This datetime parser uses dateutil’s datetime parser, which is used, among others, by arrow, delorean and pendulum.

>>> load("date: 2016-10-22T14:23:12+00:00", Map({"date": strictyaml.Datetime()})) == {"date": datetime(2016, 10, 22, 14, 23, 12)}

Comma Separated Values

Scalar strings can be parsed a second time into comma separated values.

>>> load("a: 1, 2, 3", Map({"a": strictyaml.CommaSepaeated(strictyaml.Int())})) == {"a": [1, 2, 3, ]}

Custom scalar types

COMING SOON

Using YAML Valdation

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

COMING SOON

Roundtripping YAML

COMING SOON

Contributors

• @gvx

• @ AlexandreDecan

• @lots0logs