Form processing/validation module.
See docs/index.rst for full documentation.
A specialism of Validator for processing HTTP forms. An Unpacker object will pre-process the data to arrange multi-valued lists into hierarchical data structures.
HTML forms do not distinguish between no value entered and an empty string. If empty_values_undefined is True, empty values are treated as undefined. Otherwise they are treated as empty strings.
Return processed data from source ob.
If this is called as a subvalidator, context should contain the validation context.
The unpacker object to use. See formalize.unpack
Validator for processing dictionary-like data structures
Base validator class, from which other Validators are derived.
To validate HTML form submissions you will want to use FormValidator. To validate other data structures you will need to use DictValidator, ListValidator, and the other subtypes of BaseValidator that represent primitive types, or own subclasses of BaseValidator.
Validator objects take an input value [typically from a web form] and process it through multiple stages, resulting in either a processed, valid python object being returned, or a ValidationError being raised.
- process_prefilters applies any prefilters (see addprefilter). These should do any necessary preprocessing of the raw input.
- process_main calls the from_source method to perform the type conversion.
- Additional subvalidation checks are performed (see add). These operate on the python object, so can perform tasks such as checking values are within given numerical ranges etc.
At any stage, a ValidationError may be raised. In this event no further processing of the value will be done.
Add subvalidators to this validator.
Add a prefilter to this validator.
Return a copy of the validator. If keyword arguments are specified, they will be taken as fields to add to the copy:
>>> from formalize import Unicode
>>> v = DictValidator()(firstname=Unicode())
>>> v2 = v.copy(surname=Unicode())
>>>
>>> v.process({'firstname': 'fred'})
{'firstname': u'fred'}
>>> v2.process({'firstname': 'fred'})
Traceback (most recent call last):
...
ValidationError: ValidationError([('surname', u'Value empty or invalid')])
Given source object ob (probably a string) return a python object of the destination type.
message property getter.
Recursively calls parent validator’s _get_message method. use_default flag is used to ensure that only the first call to self.message will return default_message if no instance-level message is found.
Main entry point for type conversion and validation.
Handle the main conversion and validation stage of processing
Handle the prefilter stage of processing
Handle the subvalidation stage of processing
Register the validator as belonging to context parent.
required_message property getter
Recursively calls parent validator’s _get_message method. use_default flag is used to ensure that only the first call to self.required_message will return default_message if no instance-level message is found.
Applies a type conversion and validation to a list of values.
Synopsis:
>>> from formalize.core import FormValidator
>>> from formalize.types import Int
>>> v = FormValidator()(
... a = ListValidator(Int())
... )
>>> v.process({'a' : ['1', '2', '-39']})
{'a': [1, 2, -39]}
See formalize.core.list_transform for a way to transform multiple HTTP form-fields submissions into lists.
Using instances wrap other validators to cause them to be called with an arbitrary values pulled from the parent validator.
Example:
>>> from formalize import FormValidator, Unicode, Using
>>> from formalize.checks import assert_true
>>> def check_password(p1, p2, message=u"Passwords do not match"):
... assert_true(p1 == p2, message)
... return p1
...
>>> v = FormValidator()(
... p1=Unicode(),
... p2=Unicode()(Using('p1', 'p2')(check_password))
... )
>>> v.process({'p1': 'shoe', 'p2': 'gnu'})
Traceback (most recent call last):
...
ValidationError: ValidationError([('p2', u'Passwords do not match')])
Group validators take a number of fields and group them together into a single value.
The constructor takes the following parameters:
- Source fields (as a tuple/list), eg (date_y, date_m, date_d)
- Individual keyword arguments to specify validators for the source fields, as per DictValidator, eg date_y=Int(), date_m=Int(), date_d=Int()
The required and default parameters are ignored in this validator type, specify these on the source fields as desired.
Add subvalidators, which act on the grouped value, and fieldvalidators which act on the source field values.
All validator keyword arguments and positional arguments with a non-None source attribute are treated as fieldvalidators. Positional arguments with source left as None are treated as subvalidators.
Return processed input data from value or raise a ValidationError
Register the validator as belonging to content parent, with fieldname fieldname.
Raise a ValidationError unless at least one of the subvalidators passes.
Example:
>>> from formalize.types import Int
>>> from formalize.checks import lessthan, greaterthan
>>> v = FormValidator()(
... a=Int()(
... Any(
... lessthan(3),
... greaterthan(7),
... message=u"Must be less than 3 or greater than 7"
... )
... )
... )
>>> v.process({'a': 2})
{'a': 2}
>>> v.process({'a': 8})
{'a': 8}
>>> v.process({'a': 5})
Traceback (most recent call last):
...
ValidationError: ValidationError([('a', u'Must be less than 3 or greater than 7')])
Register the validator as belonging to content parent, with fieldname fieldname.
When instances can be used to apply validation rules conditionally and may also be passed to the Case constructor as part of a When(...) ... Otherwise(...) series.
When objects work in the context of MappingValidator objects, conditionally applying validation rules.
Otherwise instances can be passed to the Case constructor as part of a When(...) ... Otherwise(...) series.