Python 服务器端表单验证插件

Python格式验证库 Cerberus

作者 MrStranger 关注

2016.08.02 14:44 字数 2140 阅读 79评论 0喜欢 1

Cerberus是一个验证Python对象、MongoDB格式的库，

安装(稳定版本)

http://docs.python-cerberus.org/en/stable/install.html

pip install cerberus

基本用法

1⃣️定义基本格式
2⃣️生成Validator类的实例v
3⃣️定义要验证的dictionary（Python字典）
4⃣️实例v调用validator（）函数（返回boolean值）

>>> schema = {'name': {'type': 'string'}}
>>> v = Validator(schema)

>>> document = {'name': 'john doe'}
>>> v.validate(document)
True

也可以这样：

>>> v = Validator()
>>> v.validate(document, schema)
True

在version 0.4.1之后，可以这样:

>>> document = {'name': 'john doe'}
>>> v(document)
True

Validator执行时不会抛出异常或因为异常发生而停止运行，整个函数会执行完毕。也就是说验证成功就返回true，否则返回false。可以通过调用errors（）函数来获取相关的信息。

>>> schema = {'name': {'type': 'string'}, 'age': {'type': 'integer', 'min': 10}}
>>> document = {'name': 1337, 'age': 5}
>>> v.validate(document, schema)
False
>>> v.errors
{'age': 'min value is 10', 'name': 'must be of string type'}

验证规则(验证语法中的一些参数规范)：

type：

type可有以下取值：

* string
* integer
* float
* number (integer or float)
* boolean
* datetime
* dict (formally collections.mapping)
* list (formally collections.sequence, excluding strings)
* set

可以定义多个取值范围

>>> v = Validator({'quotes': {'type': ['string', 'list']}})
>>> v.validate({'quotes': 'Hello world!'})
True
>>> v.validate({'quotes': ['Do not disturb my circles!', 'Heureka!']})
True
>>> v = Validator({'quotes': {'type': ['string', 'list'], 'schema': {'type': 'string'}}})
>>> v.validate({'quotes': 'Hello world!'})
True
>>> v.validate({'quotes': [1, 'Heureka!']})
False
>>> v.errors
{'quotes': {0: 'must be of string type'}}

required：

1⃣️如果设置了'required': True那么这个键值对是必须的，如果没有，那么将返回false
2⃣️可在validate（）函数调用时设置update=True，来忽略require规则
3⃣️对于string类型的规定，“”空字符串符合required规则

>>> schema = {'name': {'required': True, 'type': 'string'}, 'age': {'type': 'integer'}}
>>> v = Validator(schema)
>>> document = {'age': 10}
>>> v.validate(document)
False
>>> v.errors
{'name': 'must be of string type'}

>>> v.validate(document, update=True)
True

readonly：

nullable：

设置为true，则值可有两种属性 （**和None）

>>> schema = {'a_nullable_integer': {'nullable': True, 'type': 'integer'}, 'an_integer': {'type': 'integer'}}
>>> v = Validator(schema)

>>> v.validate({'a_nullable_integer': 3})
True
>>> v.validate({'a_nullable_integer': None})
True

>>> v.validate({'an_integer': 3})
True
>>> v.validate({'an_integer': None})
False
>>> v.errors
{'an_integer': 'must be of integer type'}

minlength, maxlength：

只针对于string和list

>>> schema = {'name': {'type': 'string', 'maxlength': 10}}

min, max：

integer，float和number

>>> schema = {'name': {'type': 'string'}, 'age': {'type': 'integer', 'min': 10}}
>>> document = {'name': 1337, 'age': 5}
>>> v.validate(document, schema)
False
>>> v.errors
{'age': 'min value is 10', 'name': 'must be of string type'}

allowed：

string , list and int
规定取值范围：

>>> schema = {'role': {'type': 'list', 'allowed': ['agent', 'client', 'supplier']}}
>>> v = Validator(schema)
>>> v.validate({'role': ['agent', 'supplier']})
True

>>> v.validate({'role': ['intern']})
False
>>> v.errors
{'role': "unallowed values ['intern']"}

>>> schema = {'role': {'type': 'string', 'allowed': ['agent', 'client', 'supplier']}}
>>> v = Validator(schema)
>>> v.validate({'role': 'supplier'})
True

>>> v.validate({'role': 'intern'})
False
>>> v.errors
{'role': 'unallowed value intern'}

>>> schema = {'a_restricted_integer': {'type': 'integer', 'allowed': [-1, 0, 1]}}
>>> v = Validator(schema)
>>> v.validate({'a_restricted_integer': -1})
True

>>> v.validate({'a_restricted_integer': 2})
False
>>> v.errors
{'a_restricted_unteger': 'unallowed value 2'}

empty：

只适用于string
默认为true（字符串可为“”）

>>> schema = {'name': {'type': 'string', 'empty': False}}
>>> document = {'name': ''}
>>> v.validate(document, schema)
False

>>> v.errors
{'name': 'empty values not allowed'}

schema (dict)：

字典dict内的键值对规则 (子规则)

>>> schema = {'a_dict': {'type': 'dict', 'schema': {'address': {'type': 'string'}, 'city': {'type': 'string', 'required': True}}}}
>>> document = {'a_dict': {'address': 'my address', 'city': 'my town'}}
>>> v.validate(document, schema)
True

schema (list)：

列表list内的键值对规则 (子规则)

>>> schema = {'a_list': {'type': 'list', 'schema': {'type': 'integer'}}}
>>> document = {'a_list': [3, 4, 5]}
>>> v.validate(document, schema)
True

valueschema：

规定了dict内所有值的规则？

>>> schema = {'numbers': {'type': 'dict', 'valueschema': {'type': 'integer', min: 10}}}
>>> document = {'numbers': {'an integer': 10, 'another integer': 100}}
>>> v.validate(document, schema)
True

>>> document = {'numbers': {'an integer': 9}}
>>> v.validate(document, schema)
False

>>> v.errors
{'numbers': {'an integer': 'min value is 10'}}

propertyschema：

>>> schema = 'a_dict': {'type': 'dict', 'propertyschema': {'type': 'string', 'regex': '[a-z]+'}}
>>> document = {'a_dict': {'key': 'value'}}
>>> v.validate(document, schema)
True

>>> document = {'a_dict': {'KEY': 'value'}}
>>> v.validate(document, schema)
False

regex：

正则表达式

>>> schema = {'email': {'type': 'string', 'regex': '^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'}}
>>> document = {'email': 'john@example.com'}
>>> v.validate(document, schema)
True

>>> document = {'email': 'john_at_example_dot_com'}
>>> v.validate(document, schema)
False

>>> v.errors
{'email': 'value does not match regex "^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"}

dependencies：

依赖链

>>> schema = {'field1': {'required': False}, 'field2': {'required': False, 'dependencies': ['field1']}}
>>> document = {'field1': 7}
>>> v.validate(document, schema)
True

>>> document = {'field2': 7}
>>> v.validate(document, schema)
False

>>> v.errors
{'field2': 'field "field1" is required'}

>>> schema = {'field1': {'required': False}, 'field2': {'required': True, 'dependencies': {'field1': ['one', 'two']}}}
>>> document = {'field1': 'one', 'field2': 7}
>>> v.validate(document, schema)
True

>>> document = {'field1': 'three', 'field2': 7}
False

>>> v.errors
{'field2': "field 'field1' is required with values: ['one', 'two']"}

>>> # same as using a dependencies list
>>> document = {'field2': 7}
>>> v.validate(document, schema)
{'field2': "field 'field1' is required"}

>>> # one can also pass a single dependency value
>>> schema = {'field1': {'required': False}, 'field2': {'dependencies': {'field1': 'one'}}}
>>> document = {'field1': 'one', 'field2': 7}
>>> v.validate(document, schema)
True

>>> document = {'field1': 'two', 'field2': 7}
False

>>> v.errors
{'field2': "field 'field1' is required with values: one"}

anyof、allof、noneof、oneof

>>> schema = {'prop1':
...           {'type': 'number',
...            'anyof':
...            [{'min': 0, 'max': 10}, {'min': 100, 'max': 110}]}}
>>> doc = {'prop1': 5}
>>> v.validate(document, schema)
True
>>> doc = {'prop1': 105}
>>> v.validate(document, schema)
True
>>> doc = {'prop1': 55}
>>> v.validate(document, schema)
False
>>> print v.errors
{'prop1': {'anyof': 'no definitions validated', 'definition 1': 'min value is 100', 'definition 0': 'max value is 10'}}

Allowing the Unknown：

>>> schema = {'name': {'type': 'string', 'maxlength': 10}}
>>> v.validate({'name': 'john', 'sex': 'M'})
False
>>> v.errors
{'sex': 'unknown field'}

>>> v = Validator(schema={})
>>> v.allow_unknown = True
>>> v.validate({'name': 'john', 'sex': 'M'})
True

>>> v = Validator(schema={})
>>> v.allow_unknown = {'type': 'string'}
>>> v.validate({'an_unknown_field': 'john'})
True
>>> v.validate({'an_unknown_field': 1})
False
>>> v.errors
{'an_unknown_field': 'must be of string type'}

>>> v = Validator(schema=schema, allow_unknown=True)
>>> v.validate({'name': 'john', 'sex': 'M'})
True

>>> # by default allow_unknown is False for the whole document.
>>> v = Validator()
>>> v.allow_unknown
False

>>> # we can switch it on (or set it to a validation schema) for individual subdocuments
>>> schema = {
...   'name': {'type': 'string'},
...   'a_dict': {
...     'type': 'dict',
...     'allow_unknown': True,
...     'schema': {
...       'address': {'type': 'string'}
...     }
...   }
... }

>>> v.validate({'name': 'john', 'a_dict':{'an_unknown_field': 'is allowed'}}, schema)
True

>>> # this fails as allow_unknown is still False for the parent document.
>>> v.validate({'name': 'john', 'an_unknown_field': 'is not allowed', 'a_dict':{'an_unknown_field': 'is allowed'}}, schema)
False

>>> v.errors
{'an_unknown_field': 'unknown field'}

Type Coercion：

回调函数的值代替原值

>>> v = Validator({'amount': {'type': 'integer'}})
>>> v.validate({'amount': '1'})
False

>>> v = Validator({'amount': {'type': 'integer', 'coerce': int}})
>>> v.validate({'amount': '1'})
True
>>> v.document
{'amount': 1}

>>> to_bool = lambda v: v.lower() in ['true', '1']
>>> v = Validator({'flag': {'type': 'boolean', 'coerce': to_bool}})
>>> v.validate({'flag': 'true'})
True
>>> v.document
{'flag': True}

Validated Method：

v = Validator(schema)
valid_documents = [x for x in [v.validated(y) for y in documents] if x is not None]

Vanilla Python：

>>> import yaml
>>> schema_text = '''
...name:
...  type: string
...age':
...  type: integer
...  min: 10
...'''
>>> schema = yaml.load(schema_text)
>>> document = {'name': 1337, 'age': 5}
>>> v.validate(document, schema)
False
>>> v.errors
{'age': 'min value is 10', 'name': 'must be of string type'}

参考来源：http://www.jianshu.com/p/ca852f679fcc
http://docs.python-cerberus.org/en/stable/index.html