api

This is raised in response to invalid input. It has several public attributes:

msg:

The message, without values substituted. For instance, if you want HTML quoting of values, you can apply that.

substituteArgs:

The arguments (a dictionary) to go with msg .

str(self):

The message describing the error, with values substituted.

value:

The offending (invalid) value.

state:

The state that went with this validator. This is an application-specific object.

error_list:

If this was a compound validator that takes a repeating value, and sub-validator(s) had errors, then this is a list of those exceptions. The list will be the same length as the number of values -- valid values will have None instead of an exception.

error_dict:

Like error_list , but for dictionary compound validators.

This class contains 3 members.

The base class of most validators. See IValidator for more, and FancyValidator for the more common (and more featureful) class.

Messages

This class contains 20 members.

FancyValidator is the (abstract) superclass for various validators and converters. A subclass can validate, convert, or do both. There is no formal distinction made here.

Validators have two important external methods:

• .to_python(value, state): Attempts to convert the value. If there is a problem, or the value is not valid, an Invalid exception is raised. The argument for this exception is the (potentially HTML-formatted) error message to give the user.
• .from_python(value, state): Reverses to_python.

There are five important methods for subclasses to override, however none of these have to be overridden, only the ones that are appropriate for the validator:

• __init__(): if the declarative.Declarative model doesn't work for this.
• .validate_python(value, state): This should raise an error if necessary. The value is a Python object, either the result of to_python, or the input to from_python.
• .validate_other(value, state): Validates the source, before to_python, or after from_python. It's more common to use .validate_python() however.
• ._to_python(value, state): This returns the converted value, or raises an Invalid exception if there is an error. The argument to this exception should be the error message.
• ._from_python(value, state): Should undo .to_python() in some reasonable way, returning a string.

Validators should have no internal state besides the values given at instantiation. They should be reusable and reentrant.

All subclasses can take the arguments/instance variables:

• if_empty: If set, then this value will be returned if the input evaluates to false (empty list, empty string, None, etc), but not the 0 or False objects. This only applies to .to_python().
• not_empty: If true, then if an empty value is given raise an error. (Both with .to_python() and also .from_python() if .validate_python is true).
• strip: If true and the input is a string, strip it (occurs before empty tests).
• if_invalid: If set, then when this validator would raise Invalid during .to_python(), instead return this value.
• if_invalid_python: If set, when the Python value (converted with .from_python()) is invalid, this value will be returned.
• accept_python: If True (the default), then .validate_python() and .validate_other() will not be called when .from_python() is used.

Messages

badType:

The input must be a string (not a %(type)s: %(value)r)

empty:

Please enter a value

noneType:

The input must be a string (not None)

This class contains 32 members.