Package: voluptuous
CONTRIBUTIONS ONLYWhat does this mean?I do not have time to fix issues myself. The only way fixes or new features will be added is by people submitting PRs.Current status:Voluptuous is largely feature stable. There hasn't been a need to add new features in a while, but there are some bugs that should be fixed.Why?I no longer use Voluptuous personally (in fact I no longer regularly write Python code). Rather than leave the project in a limbo of people filing issues and wondering why they're not being worked on, I believe this notice will more clearly set expectations.Voluptuous is a Python data validation libraryVoluptuous,despitethe name, is a Python data validation library. It
is primarily intended for validating data coming into Python as JSON,
YAML, etc.It has three goals:Simplicity.Support for complex data structures.Provide useful error messages.ContactVoluptuous now has a mailing list! Send a mail tovoluptuous@librelist.comto subscribe. Instructions
will follow.You can also contact me directly viaemailorTwitter.To file a bug, create anew issueon GitHub with a short example of how to replicate the issue.DocumentationThe documentation is providedhere.Contribution to DocumentationDocumentation is built usingSphinx. You can install it bypip install -r requirements.txtFor buildingsphinx-apidocfrom scratch you need to set PYTHONPATH tovoluptuous/voluptuousrepository.The documentation is providedhere.ChangelogSeeCHANGELOG.md.Why use Voluptuous over another validation library?Validators are simple callables:No need to subclass anything, just use a function.Errors are simple exceptions:A validator can justraise Invalid(msg)and expect the user to get
useful messages.Schemas are basic Python data structures:Should your data be a dictionary of integer keys to strings?{int: str}does what you expect. List of integers, floats or
strings?[int, float, str].Designed from the ground up for validating more than just forms:Nested data structures are treated in the same way as any other
type. Need a list of dictionaries?[{}]Consistency:Types in the schema are checked as types. Values are compared as
values. Callables are called to validate. Simple.Show me an exampleTwitter'suser search APIaccepts
query URLs like:$curl'https://api.twitter.com/1.1/users/search.json?q=python&per_page=20&page=1'To validate this we might use a schema like:>>>fromvoluptuousimportSchema>>>schema=Schema({...'q':str,...'per_page':int,...'page':int,...})This schema very succinctly and roughly describes the data required by
the API, and will work fine. But it has a few problems. Firstly, it
doesn't fully express the constraints of the API. According to the API,per_pageshould be restricted to at most 20, defaulting to 5, for
example. To describe the semantics of the API more accurately, our
schema will need to be more thoroughly defined:>>>fromvoluptuousimportRequired,All,Length,Range>>>schema=Schema({...Required('q'):All(str,Length(min=1)),...Required('per_page',default=5):All(int,Range(min=1,max=20)),...'page':All(int,Range(min=0)),...})This schema fully enforces the interface defined in Twitter's
documentation, and goes a little further for completeness."q" is required:>>>fromvoluptuousimportMultipleInvalid,Invalid>>>try:...schema({})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="required key not provided @ data['q']"True...must be a string:>>>try:...schema({'q':123})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="expected str for dictionary value @ data['q']"True...and must be at least one character in length:>>>try:...schema({'q':''})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="length of value must be at least 1 for dictionary value @ data['q']"True>>>schema({'q':'#topic'})=={'q':'#topic','per_page':5}True"per_page" is a positive integer no greater than 20:>>>try:...schema({'q':'#topic','per_page':900})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="value must be at most 20 for dictionary value @ data['per_page']"True>>>try:...schema({'q':'#topic','per_page':-10})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="value must be at least 1 for dictionary value @ data['per_page']"True"page" is an integer >= 0:>>>try:...schema({'q':'#topic','per_page':'one'})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)"expected int for dictionary value @ data['per_page']">>>schema({'q':'#topic','page':1})=={'q':'#topic','page':1,'per_page':5}TrueDefining schemasSchemas are nested data structures consisting of dictionaries, lists,
scalars andvalidators. Each node in the input schema is pattern
matched against corresponding nodes in the input data.LiteralsLiterals in the schema are matched using normal equality checks:>>>schema=Schema(1)>>>schema(1)1>>>schema=Schema('a string')>>>schema('a string')'a string'TypesTypes in the schema are matched by checking if the corresponding value
is an instance of the type:>>>schema=Schema(int)>>>schema(1)1>>>try:...schema('one')...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="expected int"TrueURLsURLs in the schema are matched by usingurlparselibrary.>>>fromvoluptuousimportUrl>>>schema=Schema(Url())>>>schema('http://w3.org')'http://w3.org'>>>try:...schema('one')...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="expected a URL"TrueListsLists in the schema are treated as a set of valid values. Each element
in the schema list is compared to each value in the input data:>>>schema=Schema([1,'a','string'])>>>schema([1])[1]>>>schema([1,1,1])[1, 1, 1]>>>schema(['a',1,'string',1,'string'])['a', 1, 'string', 1, 'string']However, an empty list ([]) is treated as is. If you want to specify a list that can
contain anything, specify it aslist:>>>schema=Schema([])>>>try:...schema([1])...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="not a valid value @ data[1]"True>>>schema([])[]>>>schema=Schema(list)>>>schema([])[]>>>schema([1,2])[1, 2]Sets and frozensetsSets and frozensets are treated as a set of valid values. Each element
in the schema set is compared to each value in the input data:>>>schema=Schema({42})>>>schema({42})=={42}True>>>try:...schema({43})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="invalid value in set"True>>>schema=Schema({int})>>>schema({1,2,3})=={1,2,3}True>>>schema=Schema({int,str})>>>schema({1,2,'abc'})=={1,2,'abc'}True>>>schema=Schema(frozenset([int]))>>>try:...schema({3})...raiseAssertionError('Invalid not raised')...exceptInvalidase:...exc=e>>>str(exc)=='expected a frozenset'TrueHowever, an empty set (set()) is treated as is. If you want to specify a set
that can contain anything, specify it asset:>>>schema=Schema(set())>>>try:...schema({1})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="invalid value in set"True>>>schema(set())==set()True>>>schema=Schema(set)>>>schema({1,2})=={1,2}TrueValidation functionsValidators are simple callables that raise anInvalidexception when
they encounter invalid data. The criteria for determining validity is
entirely up to the implementation; it may check that a value is a valid
username withpwd.getpwnam(), it may check that a value is of a
specific type, and so on.The simplest kind of validator is a Python function that raises
ValueError when its argument is invalid. Conveniently, many builtin
Python functions have this property. Here's an example of a date
validator:>>>fromdatetimeimportdatetime>>>defDate(fmt='%Y-%m-%d'):...returnlambdav:datetime.strptime(v,fmt)>>>schema=Schema(Date())>>>schema('2013-03-03')datetime.datetime(2013, 3, 3, 0, 0)>>>try:...schema('2013-03')...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="not a valid value"TrueIn addition to simply determining if a value is valid, validators may
mutate the value into a valid form. An example of this is theCoerce(type)function, which returns a function that coerces its
argument to the given type:defCoerce(type,msg=None):"""Coerce a value to a type.If the type constructor throws a ValueError, the value will be marked asInvalid."""deff(v):try:returntype(v)exceptValueError:raiseInvalid(msgor('expected%s'%type.__name__))returnfThis example also shows a common idiom where an optional human-readable
message can be provided. This can vastly improve the usefulness of the
resulting error messages.DictionariesEach key-value pair in a schema dictionary is validated against each
key-value pair in the corresponding data dictionary:>>>schema=Schema({1:'one',2:'two'})>>>schema({1:'one'}){1: 'one'}Extra dictionary keysBy default any additional keys in the data, not in the schema will
trigger exceptions:>>>schema=Schema({2:3})>>>try:...schema({1:2,2:3})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="extra keys not allowed @ data[1]"TrueThis behaviour can be altered on a per-schema basis. To allow
additional keys useSchema(..., extra=ALLOW_EXTRA):>>>fromvoluptuousimportALLOW_EXTRA>>>schema=Schema({2:3},extra=ALLOW_EXTRA)>>>schema({1:2,2:3}){1: 2, 2: 3}To remove additional keys useSchema(..., extra=REMOVE_EXTRA):>>>fromvoluptuousimportREMOVE_EXTRA>>>schema=Schema({2:3},extra=REMOVE_EXTRA)>>>schema({1:2,2:3}){2: 3}It can also be overridden per-dictionary by using the catch-all marker
tokenextraas a key:>>>fromvoluptuousimportExtra>>>schema=Schema({1:{Extra:object}})>>>schema({1:{'foo':'bar'}}){1: {'foo': 'bar'}}Required dictionary keysBy default, keys in the schema are not required to be in the data:>>>schema=Schema({1:2,3:4})>>>schema({3:4}){3: 4}Similarly to how extra_ keys work, this behaviour can be overridden
per-schema:>>>schema=Schema({1:2,3:4},required=True)>>>try:...schema({3:4})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="required key not provided @ data[1]"TrueAnd per-key, with the marker tokenRequired(key):>>>schema=Schema({Required(1):2,3:4})>>>try:...schema({3:4})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="required key not provided @ data[1]"True>>>schema({1:2}){1: 2}Optional dictionary keysIf a schema hasrequired=True, keys may be individually marked as
optional using the marker tokenOptional(key):>>>fromvoluptuousimportOptional>>>schema=Schema({1:2,Optional(3):4},required=True)>>>try:...schema({})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="required key not provided @ data[1]"True>>>schema({1:2}){1: 2}>>>try:...schema({1:2,4:5})...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="extra keys not allowed @ data[4]"True>>>schema({1:2,3:4}){1: 2, 3: 4}Recursive / nested schemaYou can usevoluptuous.Selfto define a nested schema:>>>fromvoluptuousimportSchema,Self>>>recursive=Schema({"more":Self,"value":int})>>>recursive({"more":{"value":42},"value":41})=={'more':{'value':42},'value':41}TrueExtending an existing SchemaOften it comes handy to have a baseSchemathat is extended with more
requirements. In that case you can useSchema.extendto create a newSchema:>>>fromvoluptuousimportSchema>>>person=Schema({'name':str})>>>person_with_age=person.extend({'age':int})>>>sorted(list(person_with_age.schema.keys()))['age', 'name']The originalSchemaremains unchanged.ObjectsEach key-value pair in a schema dictionary is validated against each
attribute-value pair in the corresponding object:>>>fromvoluptuousimportObject>>>classStructure(object):...def__init__(self,q=None):...self.q=q...def__repr__(self):...return'<Structure(q={0.q!r})>'.format(self)...>>>schema=Schema(Object({'q':'one'},cls=Structure))>>>schema(Structure(q='one'))<Structure(q='one')>Allow None valuesTo allow value to be None as well, use Any:>>>fromvoluptuousimportAny>>>schema=Schema(Any(None,int))>>>schema(None)>>>schema(5)5Error reportingValidators must throw anInvalidexception if invalid data is passed
to them. All other exceptions are treated as errors in the validator and
will not be caught.EachInvalidexception has an associatedpathattribute representing
the path in the data structure to our currently validating value, as well
as anerror_messageattribute that contains the message of the original
exception. This is especially useful when you want to catchInvalidexceptions and give some feedback to the user, for instance in the context of
an HTTP API.>>>defvalidate_email(email):..."""Validate email."""...ifnot"@"inemail:...raiseInvalid("This email is invalid.")...returnemail>>>schema=Schema({"email":validate_email})>>>exc=None>>>try:...schema({"email":"whatever"})...exceptMultipleInvalidase:...exc=e>>>str(exc)"This email is invalid. for dictionary value @ data['email']">>>exc.path['email']>>>exc.msg'This email is invalid.'>>>exc.error_message'This email is invalid.'Thepathattribute is used during error reporting, but also during matching
to determine whether an error should be reported to the user or if the next
match should be attempted. This is determined by comparing the depth of the
path where the check is, to the depth of the path where the error occurred. If
the error is more than one level deeper, it is reported.The upshot of this is thatmatching is depth-first and fail-fast.To illustrate this, here is an example schema:>>>schema=Schema([[2,3],6])Each value in the top-level list is matched depth-first in-order. Given
input data of[[6]], the inner list will match the first element of
the schema, but the literal6will not match any of the elements of
that list. This error will be reported back to the user immediately. No
backtracking is attempted:>>>try:...schema([[6]])...raiseAssertionError('MultipleInvalid not raised')...exceptMultipleInvalidase:...exc=e>>>str(exc)=="not a valid value @ data[0][0]"TrueIf we pass the data[6], the6is not a list type and so will not
recurse into the first element of the schema. Matching will continue on
to the second element in the schema, and succeed:>>>schema([6])[6]Multi-field validationValidation rules that involve multiple fields can be implemented as
custom validators. It's recommended to useAll()to do a two-pass
validation - the first pass checking the basic structure of the data,
and only after that, the second pass applying your cross-field
validator:defpasswords_must_match(passwords):ifpasswords['password']!=passwords['password_again']:raiseInvalid('passwords must match')returnpasswordsschema=Schema(All(# First "pass" for field types{'password':str,'password_again':str},# Follow up the first "pass" with your multi-field rulespasswords_must_match))# validschema({'password':'123','password_again':'123'})# raises MultipleInvalid: passwords must matchschema({'password':'123','password_again':'and now for something completely different'})With this structure, your multi-field validator will run with
pre-validated data from the first "pass" and so will not have to do
its own type checking on its inputs.The flipside is that if the first "pass" of validation fails, your
cross-field validator will not run:# raises Invalid because password_again is not a string# passwords_must_match() will not run because first-pass validation already failedschema({'password':'123','password_again':1337})Running testsVoluptuous is usingpytest:$pipinstallpytest
$pytestTo also include a coverage report:$pipinstallpytestpytest-covcoverage>=3.0
$pytest--cov=voluptuousvoluptuous/tests/Other libraries and inspirationsVoluptuous is heavily inspired byValidino, and to a lesser extent,jsonvalidatorandjson_schema.pytest-voluptuousis apytestplugin that helps in
using voluptuous validators inasserts.I greatly prefer the light-weight style promoted by these libraries to
the complexity of libraries like FormEncode.