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:
- TowelDefault parse result:
>>> strictyaml.load(yaml) \
== {"name": "Ford Prefect", "age": "42", "possessions": ["Towel", ]} # All data is str, list or dictExample 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$ pip install strictyamlFrom learning programmers:
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?
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: [email protected]
zaphod: [email protected]
ford: [email protected]>>> from strictyaml import load, Map, MapPattern, Str
>>> load(yaml, Map({"emails": MapPattern({Str(), Str()})}) \
== {"emails": {"arthur": "[email protected]", "zaphod": "[email protected]", "ford": "[email protected]"}}If you want to use a mapping with a number of required keys and a number of optional keys use "Optional":
arthur:
email: [email protected]
zaphod:
email: [email protected]
job: President of the Galaxy
ford:
email: [email protected]
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': '[email protected]',},
"zaphod": {'email': '[email protected]', 'job': 'President of the Galaxy'},
"ford": {'email': '[email protected]', 'job': 'Freelance "journalist"'},
}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: [email protected]
victims: Good taste
ford:
email: [email protected]
victims: Journalistic integrity
arthur:
email: [email protected]
victims:
- A bowl of petunias
- Agrajag
- A sperm whaleThis 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': '[email protected]', 'victims': 'President of the Galaxy'},
"arthur": {'email': '[email protected]', 'victims': 'Journalistic integrity'},
"ford": {'email': '[email protected]', 'victims': ['A bowl of petunias', 'Agrajag', 'A sperm whale', ]},
}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')}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 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": []}>>> load("day: monday", Map({"day": strictyaml.Enum(["monday", "tuesday", "wednesday"])})) == {"day": "monday"}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)}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, ]}COMING SOON
See: What is kwalify and when should I use it?
COMING SOON
COMING SOON
- @gvx
- @ AlexandreDecan
- @lots0logs
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent