Validation error python

Введение

Пример использования

Рассмотрим скрипт

PydanticDemo.py

from dataclasses import dataclass
from typing import Tuple
from enum import Enum


@dataclass
class IceCreamMix:
name: str
flavor: str
toppings: Tuple[str, ...]
scoops: int

def main():
ice_cream_mix = IceCreamMix(
"PB&J",
"peanut butter",
("strawberries", "sprinkles"),
2
)

print(ice_cream_mix)

if __name__ == '__main__':
main()

python PydanticDemo.py

IceCreamMix(name=’PB&J’, flavor=’peanut butter’, toppings=(‘strawberries’, ‘sprinkles’), scoops=2)

Этот скрипт успешно демонстрирует тип мороженого

Добавим ещё немного ООП

from dataclasses import dataclass
from typing import Tuple
from enum import Enum


class Flavor(str, Enum):
chocolate = 'chocolate'
vanilla = 'vanilla'
strawberry = 'strawberry'
mint = 'mint'
coffeee = 'coffee'
peanut_butter = 'peanut butter'

class Topping(str, Enum):
sprinkles = 'sprinkles'
hot_fudge = 'hot fudge'
cookies = 'cookies'
brownie = 'brownie'
whipped_cream = 'whipped cream'
strawberries = 'strawberries'


@dataclass
class IceCreamMix:
name: str
flavor: Flavor
toppings: Tuple[Topping, ...]
scoops: int

def main():
ice_cream_mix = IceCreamMix(
"PB&J",
Flavor.peanut_butter,
(Topping.strawberries, Topping.sprinkles),
2
)

print(ice_cream_mix)

if __name__ == '__main__':
main()

$ python PydanticDemo.py

IceCreamMix(name=’PB&J’, flavor=<Flavor.peanut_butter: ‘peanut butter’>, toppings=(<Topping.strawberries: ‘strawberries’>, <Topping.sprinkles: ‘sprinkles’>), scoops=2)

Скрипт по-прежнему работает

Что если мы по ошибке выберем несуществующий запах или топпинг

def main():
ice_cream_mix = IceCreamMix(
"PB&J",
"smells like shit",
(Topping.strawberries, 111),
2
)

python PydanticDemo.py

IceCreamMix(name=’PB&J’, flavor=’smells like shit‘, toppings=(<Topping.strawberries: ‘strawberries’>, 111), scoops=2)

Скрипт не замечает подвоха.

Чтобы проверять данные автоматически установите pydantic и внесите всего одно изменение
в первую строку

from pydantic.dataclasses import dataclass

python PydanticDemo.py

Traceback (most recent call last):
File «PydanticDemo.py», line 41, in <module>
main()
File «PydanticDemo.py», line 31, in main
ice_cream_mix = IceCreamMix(
File «<string>», line 7, in __init__
File «C:UsersAndreipythonpydanticvenvlibsite-packagespydanticdataclasses.py», line 99, in _pydantic_post_init
raise validation_error
pydantic.error_wrappers.ValidationError: 2 validation errors for IceCreamMix
flavor
value is not a valid enumeration member; permitted: ‘chocolate’, ‘vanilla’, ‘strawberry’, ‘mint’, ‘coffee’, ‘peanut butter’ (type=type_error.enum; enum_values=[<Flavor.chocolate: ‘chocolate’>, <Flavor.vanilla: ‘vanilla’>, <Flavor.strawberry: ‘strawberry’>, <Flavor.mint: ‘mint’>, <Flavor.coffeee: ‘coffee’>, <Flavor.peanut_butter: ‘peanut butter’>])
toppings -> 1
value is not a valid enumeration member; permitted: ‘sprinkles’, ‘hot fudge’, ‘cookies’, ‘brownie’, ‘whipped cream’, ‘strawberries’ (type=type_error.enum; enum_values=[<Topping.sprinkles: ‘sprinkles’>, <Topping.hot_fudge: ‘hot fudge’>, <Topping.cookies: ‘cookies’>, <Topping.brownie: ‘brownie’>, <Topping.whipped_cream: ‘whipped cream’>, <Topping.strawberries: ‘strawberries’>])

pydantic не пропустил наш код. Разберём выдачу подробнее

pydantic.error_wrappers.ValidationError: 2 validation errors for IceCreamMix

Указано количество ошибок и класс. Это помогло бы с дебагом, если бы мы не знали заранее где ошибки
и сколько их

flavor
value is not a valid enumeration member; permitted:

‘chocolate’,
‘vanilla’,
‘strawberry’,
‘mint’,
‘coffee’,
‘peanut butter’

(type=type_error.enum; enum_values=[<Flavor.chocolate: ‘chocolate’>, <Flavor.vanilla: ‘vanilla’>, <Flavor.strawberry: ‘strawberry’>, <Flavor.mint: ‘mint’>, <Flavor.coffeee: ‘coffee’>, <Flavor.peanut_butter: ‘peanut butter’>])

Pydantic подсказывает допустимые значения.

Тоже самое и с топпингами, где вместо допустимого значения стоит 111

toppings -> 1
value is not a valid enumeration member; permitted: ‘sprinkles’, ‘hot fudge’, ‘cookies’, ‘brownie’, ‘whipped cream’, ‘strawberries’ (type=type_error.enum; enum_values=[<Topping.sprinkles: ‘sprinkles’>, <Topping.hot_fudge: ‘hot fudge’>, <Topping.cookies: ‘cookies’>, <Topping.brownie: ‘brownie’>, <Topping.whipped_cream: ‘whipped cream’>, <Topping.strawberries: ‘strawberries’>])

Верните корректные значения для Flavor и Topping но замените scoops с 2 на ‘2’

def main():
ice_cream_mix = IceCreamMix(
"PB&J",
Flavor.peanut_butter,
(Topping.strawberries, Topping.sprinkles),
'2'
)

python PydanticDemo.py

IceCreamMix(name=’PB&J’, flavor=<Flavor.peanut_butter: ‘peanut butter’>, toppings=(<Topping.strawberries: ‘strawberries’>, <Topping.sprinkles: ‘sprinkles’>), scoops=2)

BaseModel

Чтобы получить доступ к дополнительным возможностям таким как сериализация (Serialization)
и поддержка JSON воспользуемся классом BaseModel

Просто напомню, что сперва у нас было

from dataclasses import dataclass

Затем

from pydantic.dataclasses import dataclass

А сейчас нужно сделать

from pydantic import BaseModel

strawberries = 'strawberries'


class IceCreamMix(BaseModel):
name: str
flavor: Flavor
toppings: Tuple[Topping, ...]
scoops: int

def main():
ice_cream_mix = IceCreamMix(
name = "PB&J",
flavor = Flavor.peanut_butter,
toppings = (Topping.strawberries, Topping.sprinkles),
scoops = 2
)

python PydanticDemo.py

IceCreamMix(name=’PB&J’, flavor=<Flavor.peanut_butter: ‘peanut butter’>, toppings=(<Topping.strawberries: ‘strawberries’>, <Topping.sprinkles: ‘sprinkles’>), scoops=2)

print(ice_cream_mix.json())

python PydanticDemo.py

{«name»: «PB&J», «flavor»: «peanut butter», «toppings»: [«strawberries», «brownie»], «scoops»: 2}

another_mix = IceCreamMix.parse_raw('{"name": "New mix", "flavor": "mint", "toppings": ["cookies", "hot fudge"], "scoops": 2}')
print(another_mix.json())

{«name»: «New mix», «flavor»: «mint», «toppings»: [«cookies», «hot fudge»], «scoops»: 2}

Если случайно ошибиться со значением аттрибута — pydantic не даст соврать

another_mix = IceCreamMix.parse_raw('{"name": "New mix", "flavor": "novichoke", "toppings": ["cookies", "hot fudge"], "scoops": 2}')
print(another_mix.json())

python PydanticDemo.py

Traceback (most recent call last):
File «/home/avorotyn/python/pydantic/PydanticDemo.py», line 45, in <module>
main()
File «/home/avorotyn/python/pydantic/PydanticDemo.py», line 40, in main
another_mix = IceCreamMix.parse_raw(‘{«name»: «New mix», «flavor»: «novichoke«, «toppings»: [«cookies», «hot fudge»], «scoops»: 2}’)
File «pydantic/main.py», line 543, in pydantic.main.BaseModel.parse_raw
File «pydantic/main.py», line 520, in pydantic.main.BaseModel.parse_obj
File «pydantic/main.py», line 362, in pydantic.main.BaseModel.__init__
pydantic.error_wrappers.ValidationError: 1 validation error for IceCreamMix
flavor
value is not a valid enumeration member; permitted: ‘chocolate’, ‘vanilla’, ‘strawberry’, ‘mint’, ‘coffee’, ‘peanut butter’ (type=type_error.enum; enum_values=[<Flavor.chocolate: ‘chocolate’>, <Flavor.vanilla: ‘vanilla’>, <Flavor.strawberry: ‘strawberry’>, <Flavor.mint: ‘mint’>, <Flavor.coffeee: ‘coffee’>, <Flavor.peanut_butter: ‘peanut butter’>])

ValidationError как JSON

В JSON можно также оформить сообщения об ошибках. Нужно импортировать из pydantic ValidationError
и воспользоваться try: except

from pydantic import BaseModel, ValidationError
…

def main():
try:
ice_cream_mix = IceCreamMix(
name = "PB&J",
flavor = "spring",
toppings = (Topping.strawberries, Topping.sprinkles),
scoops = 2
)
except ValidationError as e:
print(e.json())

python PydanticDemo.py

[
{
«loc»: [
«flavor»
],
«msg»: «value is not a valid enumeration member; permitted: ‘chocolate’, ‘vanilla’, ‘strawberry’, ‘mint’, ‘coffee’, ‘peanut butter'»,
«type»: «type_error.enum»,
«ctx»: {
«enum_values»: [
«chocolate»,
«vanilla»,
«strawberry»,
«mint»,
«coffee»,
«peanut butter»
]
}
}
]

Границы допустимых значений

Допустим вы хотите, чтобы число ложечек было обязательным аттрибутом со значениями от 0 до 5 не включая границы

from pydantic import BaseModel, ValidationError, Field
…

strawberries = 'strawberries'


class IceCreamMix(BaseModel):
name: str
flavor: Flavor
toppings: Tuple[Topping, ...]
scoops: int = Field(..., gt=0, lt=5)

python PydanticDemo.py

{«name»: «PB&J», «flavor»: «peanut butter», «toppings»: [«strawberries», «brownie»], «scoops»: 2}

Задано 2 ложечки, так что ошибок нет.

Попробуем 5 ложечек

def main():
try:
ice_cream_mix = IceCreamMix(
name = "PB&J",
flavor = "spring",
toppings = (Topping.strawberries, Topping.sprinkles),
scoops = 5
)
except ValidationError as e:
print(e.json())

python PydanticDemo.py

[
{
«loc»: [
«scoops»
],
«msg»: «ensure this value is less than 5«,
«type»: «value_error.number.not_lt»,
«ctx»: {
«limit_value»: 5
}
}
]
Traceback (most recent call last):
File «/home/avorotyn/python/pydantic/PydanticDemo.py», line 50, in <module>
main()
File «/home/avorotyn/python/pydantic/PydanticDemo.py», line 41, in main
print(ice_cream_mix.json())
UnboundLocalError: local variable ‘ice_cream_mix’ referenced before assignment

Не обращайте внимание на Traceback — можно было вложить print в try, но если всё ок, то объёкт создается и
этой ошибки нет, а если не ок, то pydantic ловит несоответствие и выдает value_error

Валидация с помощью декоратора validator

from pydantic import BaseModel, ValidationError, Field, validator
…

class IceCreamMix(BaseModel):
name: str
flavor: Flavor
toppings: Tuple[Topping, ...]
scoops: int = Field(..., gt=0, lt=5)

@validator('toppings')
def check_toppings(cls, toppings):
if len(toppings) > 4:
raise ValueError('Too many toppings')
return toppings

Если запустить этот код с двумя топпингами никаких ошибок не будет, поэтому сразу добавим ещё три, чтобы
в сумме стало пять.

def main():
try:
ice_cream_mix = IceCreamMix(
name = "PB&J",
flavor = "spring",
toppings = (Topping.strawberries, Topping.brownie,Topping.sprinkles,Topping.hot_fudge,Topping.whipped_cream),

python PydanticDemo.py

[
{
«loc»: [
«toppings»
],
«msg»: «Too many toppings»,
«type»: «value_error»
}
]

Теперь можно уменьшить число топпингов до четырёх и убедиться что ошибки нет.

@root_validator

Применяется когда нужно следить за всей моделью. Например за сочетаниями разных аттрибутов.

from pydantic import BaseModel, ValidationError, Field, validator, root_validator
…

Создайте ещё один класс — Container

strawberries = 'strawberries'

class Container(str, Enum):
cup = 'cup'
cone = 'cone'
waffle_cone = 'waffle cone'

class IceCreamMix(BaseModel):
name: str
flavor: Flavor

@validator('toppings')
def check_toppings(cls, toppings):
if len(toppings) > 4:
raise ValueError('Too many toppings')
return toppings

@root_validator
def check_cone_toppings(cls, toppings):
container = values.get('container')
toppings = values.get('toppings')
if container == Container.cone or container == Container.waffle_cone:
if Topping.hot_fudge in toppings:
raise ValueError('Cones cannot have hot fudge')
return values

def main():
try:
ice_cream_mix = IceCreamMix(
name = "PB&J",
container = Container.waffle_cone,
flavor = "spring",

У вас как раз должен был остаться топпинг hot fudge с прошлого примера, если нет — добавьте и запустите

python PydanticDemo.py

[
{
«loc»: [
«__root__»
],
«msg»: «Cones cannot have hot fudge»,
«type»: «value_error»
}
]

Окончательный код примера

from pydantic import BaseModel,
ValidationError, Field, validator, root_validator
from typing import Tuple
from enum import Enum


class Flavor(str, Enum):
chocolate = 'chocolate'
vanilla = 'vanilla'
strawberry = 'strawberry'
mint = 'mint'
coffeee = 'coffee'
peanut_butter = 'peanut butter'


class Topping(str, Enum):
sprinkles = 'sprinkles'
hot_fudge = 'hot fudge'
cookies = 'cookies'
brownie = 'brownie'
whipped_cream = 'whipped cream'
strawberries = 'strawberries'


class Container(str, Enum):
cup = 'cup'
cone = 'cone'
waffle_cone = 'waffle cone'


class IceCreamMix(BaseModel):
name: str
container: Container
flavor: Flavor
toppings: Tuple[Topping, ...]
scoops: int = Field(..., gt=0, lt=5)

@validator('toppings')
def check_toppings(cls, toppings):
if len(toppings) > 4:
raise ValueError('Too many toppings')
return toppings

@root_validator
def check_cone_toppings(cls, values):
container = values.get('container')
toppings = values.get('toppings')
if container == Container.cone or container == Container.waffle_cone:
if Topping.hot_fudge in toppings:
raise ValueError('Cones cannot have hot fudge')
return values


def main():
try:
ice_cream_mix = IceCreamMix(
name="PB&J",
container=Container.waffle_cone,
flavor=Flavor.peanut_butter,
# flavor='unknown flavour'
toppings=(Topping.strawberries, Topping.brownie,
Topping.sprinkles),
# на validator
# toppings=(Topping.strawberries, Topping.brownie,
# Topping.sprinkles,Topping.cookies, Topping.sprinkles),
# на root_validator
# toppings=(Topping.strawberries, Topping.brownie,
# Topping.sprinkles,Topping.hot_fudge),
scoops=2
# scoops=5
)
print(ice_cream_mix.json())

except ValidationError as e:
print(e.json())


if __name__ == '__main__':
main()

Вторая часть статьи

from typing import Dict


def validate_input_settings(params_in: Dict) -> Dict:
    params_validated = {}
    for key, value in params_in.items():
        if key == "interpolation_factor":
            if not int(value) == value:
                raise ValueError(f"{key} has a non-int value")
            if not int(value) >= 2:
                raise ValueError(f"{key}: {value} should be >= 2")
            value = int(value)
        elif key == "interpolation_method":
            allowed_set = {
                "repeat", "distribute", "linear", "cubic", "akima"
            }
            if value not in allowed_set:
                raise ValueError(f"{key} should be one of {allowed_set}, got {value}")
        elif key == "interpolate_on_integral":
            if not isinstance(value, bool):
                raise ValueError(f"{key} should be bool, got {value}")
        else:
            raise ValueError(f"{key} not a recognized key")
        params_validated[key] = value
    return params_validated

from pydantic import BaseModel


class InterpolationSetting(BaseModel):
    interpolation_factor: int
    interpolation_method: str
    interpolate_on_integral: bool

Pydantic models are simply classes inheriting from the BaseModel class. We can create an instance of the new class as:

InterpolationSetting(
    interpolation_factor=2, 
    interpolation_method="linear", 
    interpolate_on_integral=True
)

from pydantic import ValidationError


try:
    InterpolationSetting(
        interpolation_factor="text",
        interpolation_method="linear",
        interpolate_on_integral=True,
    )
except ValidationError as e:
    print(e)

which outputs:

    1 validation error for InterpolationSetting
    interpolation_factor
      value is not a valid integer (type=type_error.integer)

from typing import Dict

from pydantic import BaseModel, conint, validator, root_validator


class InterpolationSetting(BaseModel):
    interpolation_factor: conint(gt=1)
    interpolation_method: str
    interpolate_on_integral: bool

    @validator("interpolation_method")
    def method_is_valid(cls, method: str) -> str:
        allowed_set = {"repeat", "distribute", "linear", "cubic", "akima"}
        if method not in allowed_set:
            raise ValueError(f"must be in {allowed_set}, got '{method}'")
        return method

    @root_validator()
    def valid_combination_of_method_and_on_integral(cls, values: Dict) -> Dict:
        on_integral = values.get("interpolate_on_integral")
        method = values.get("interpolation_method")
        if on_integral is False and method == "distribute":
            raise ValueError(
                f"Invalid combination of interpolation_method "
                f"{method} and interpolate_on_integral {on_integral}"
            )
        return values

from pydantic import ValidationError


try:
    InterpolationSetting(
        interpolation_factor=1,
        interpolation_method="distribute",
        interpolate_on_integral=False,
    )
except ValidationError as e:
    print(e)

which outputs:

    2 validation errors for InterpolationSetting
    interpolation_factor
      ensure this value is greater than 1 (type=value_error.number.not_gt; limit_value=1)
    __root__
      Invalid combination of interpolation_method distribute and interpolate_on_integral False (type=value_error)

from typing import Dict, Optional

from pydantic import BaseModel, conint, validator, root_validator


class InterpolationSetting(BaseModel):
    interpolation_factor: Optional[conint(gt=2)]
    interpolation_method: Optional[str]
    interpolate_on_integral: Optional[bool]

    @validator("interpolation_method")
    def method_is_valid(cls, method: Optional[str]) -> Optional[str]:
        allowed_set = {"repeat", "distribute", "linear", "cubic", "akima"}
        if method is not None and method not in allowed_set:
            raise ValueError(f"must be in {allowed_set}, got '{method}'")
        return method

    @root_validator()
    def valid_combination_of_method_and_on_integral(cls, values: Dict) -> Dict:
        on_integral = values.get("interpolate_on_integral")
        method = values.get("interpolation_method")
        if on_integral is False and method == "distribute":
            raise ValueError(
                f"Invalid combination of interpolation_method "
                f"{method} and interpolate_on_integral {on_integral}"
            )
        return values

    @root_validator()
    def set_method_given_interpolation_factor(cls, values: Dict) -> Dict:
        factor = values.get("interpolation_factor")
        method = values.get("interpolation_method")
        if method is None and factor is not None:
            values["interpolation_method"] = "linear"
        return values

    @root_validator()
    def set_on_integral_given_interpolation_factor(cls, values: Dict) -> Dict:
        on_integral = values.get("interpolate_on_integral")
        factor = values.get("interpolation_factor")
        if on_integral is None and factor is not None:
            values["interpolate_on_integral"] = False
        return values

We can verify that the default values are set only when interpolation_factor
is provided, running InterpolationSetting(interpolation_factor=3) returns:

InterpolationSetting(interpolation_factor=3, interpolation_method='linear', interpolate_on_integral=None)

whereas supplying no input parameters, InterpolationSetting(), returns a data model with all parameters set to None:

InterpolationSetting(interpolation_factor=None, interpolation_method=None, interpolate_on_integral=None)

Note: If we have static defaults, we can simply set them for the fields:

class InterpolationSetting(BaseModel):
    interpolation_factor: Optional[int] = 42

InterpolationSetting(interpolation_factor=None, interpolation_method=None, interpolate_on_integral=None)

Often, an unknown field name is the result of a typo
in the toml file. Therefore we want to raise an error to alert the user.
We do this using a the model config, controlling the behaviour of the model. The extra attribute of the config determines what we do with extra fields. The default is ignore, which we can see in the example above, where the field is ignored, and not added to the model, as the option allow does. We can use the forbid option to raise an exception when extra fields are supplied.

from typing import Dict, Optional

from pydantic import BaseModel, conint, validator, root_validator


class InterpolationSetting(BaseModel):
    interpolation_factor: Optional[conint(gt=2)]
    interpolation_method: Optional[str]
    interpolate_on_integral: Optional[bool]

    class Config:
        extra = "forbid"

    @validator("interpolation_method")
    def method_is_valid(cls, method: Optional[str]) -> Optional[str]:
        allowed_set = {"repeat", "distribute", "linear", "cubic", "akima"}
        if method is not None and method not in allowed_set:
            raise ValueError(f"must be in {allowed_set}, got '{method}'")
        return method

    @root_validator()
    def valid_combination_of_method_and_on_integral(cls, values: Dict) -> Dict:
        on_integral = values.get("interpolate_on_integral")
        method = values.get("interpolation_method")
        if on_integral is False and method == "distribute":
            raise ValueError(
                f"Invalid combination of interpolation_method "
                f"{method} and interpolate_on_integral {on_integral}"
            )
        return values

    @root_validator()
    def set_method_given_interpolation_factor(cls, values: Dict) -> Dict:
        factor = values.get("interpolation_factor")
        method = values.get("interpolation_method")
        if method is None and factor is not None:
            values["interpolation_method"] = "linear"
        return values

    @root_validator()
    def set_on_integral_given_interpolation_factor(cls, values: Dict) -> Dict:
        on_integral = values.get("interpolate_on_integral")
        factor = values.get("interpolation_factor")
        if on_integral is None and factor is not None:
            values["interpolation_factor"] = False
        return values

If we try again with an unknown key, we now get a ValidationError:

from pydantic import ValidationError


try:
    InterpolationSetting(hello=True)
except ValidationError as e:
    print(e)

This raises a validation error for the unknown field:

1 validation error for InterpolationSetting
hello
  extra fields not permitted (type=value_error.extra)

Adapting our existing code is easy

Now we have implemented all our checks, and can go on to adapt our existing code to use the new data model. In our original implementation, we would do something like

params_in = toml.load(path_to_settings_file)
params_validated = validate_input_settings(params_in)
interpolate_result(params_validated)

We can replace the call to validate_input_settings with instantiation of the pydantic model: params_validated = InterpolationSetting(params_in). Each pydantic data model has a .dict() method that returns the parameters as a dictionary, so we can use it in the input argument to interpolate_result directly: interpolate_result(params_validated.dict()). Another option is to refactor interpolate_result to use the attributes of the InterpolationSetting objects, such as params_validated.interpolation_method instead of the values of a dictionary.

Hopefully this will help you determine whether or not you should consider using pydantic models in your projects. In a later post, we will show how we use pydantic data models to share metadata between machine learning applications, and to share data requirements between the applications.

Form and field validation¶

Form validation happens when the data is cleaned. If you want to customize
this process, there are various places to make changes, each one serving a
different purpose. Three types of cleaning methods are run during form
processing. These are normally executed when you call the is_valid()
method on a form. There are other things that can also trigger cleaning and
validation (accessing the errors attribute or calling full_clean()
directly), but normally they won’t be needed.

In general, any cleaning method can raise ValidationError if there is a
problem with the data it is processing, passing the relevant information to
the ValidationError constructor. See below
for the best practice in raising ValidationError. If no ValidationError
is raised, the method should return the cleaned (normalized) data as a Python
object.

Most validation can be done using validators — helpers that can be reused.
Validators are functions (or callables) that take a single argument and raise
ValidationError on invalid input. Validators are run after the field’s
to_python and validate methods have been called.

Validation of a form is split into several steps, which can be customized or
overridden:

• The to_python() method on a Field is the first step in every
  validation. It coerces the value to a correct datatype and raises
  ValidationError if that is not possible. This method accepts the raw
  value from the widget and returns the converted value. For example, a
  FloatField will turn the data into a Python float or raise a
  ValidationError.

• The validate() method on a Field handles field-specific validation
  that is not suitable for a validator. It takes a value that has been
  coerced to a correct datatype and raises ValidationError on any error.
  This method does not return anything and shouldn’t alter the value. You
  should override it to handle validation logic that you can’t or don’t
  want to put in a validator.

• The run_validators() method on a Field runs all of the field’s
  validators and aggregates all the errors into a single
  ValidationError. You shouldn’t need to override this method.

• The clean() method on a Field subclass is responsible for running
  to_python(), validate(), and run_validators() in the correct
  order and propagating their errors. If, at any time, any of the methods
  raise ValidationError, the validation stops and that error is raised.
  This method returns the clean data, which is then inserted into the
  cleaned_data dictionary of the form.

• The clean_<fieldname>() method is called on a form subclass – where
  <fieldname> is replaced with the name of the form field attribute.
  This method does any cleaning that is specific to that particular
  attribute, unrelated to the type of field that it is. This method is not
  passed any parameters. You will need to look up the value of the field
  in self.cleaned_data and remember that it will be a Python object
  at this point, not the original string submitted in the form (it will be
  in cleaned_data because the general field clean() method, above,
  has already cleaned the data once).

  For example, if you wanted to validate that the contents of a
  CharField called serialnumber was unique,
  clean_serialnumber() would be the right place to do this. You don’t
  need a specific field (it’s a CharField), but you want a
  formfield-specific piece of validation and, possibly, cleaning/normalizing
  the data.

  The return value of this method replaces the existing value in
  cleaned_data, so it must be the field’s value from cleaned_data (even
  if this method didn’t change it) or a new cleaned value.

• The form subclass’s clean() method can perform validation that requires
  access to multiple form fields. This is where you might put in checks such as
  “if field A is supplied, field B must contain a valid email address”.
  This method can return a completely different dictionary if it wishes, which
  will be used as the cleaned_data.

  Since the field validation methods have been run by the time clean() is
  called, you also have access to the form’s errors attribute which
  contains all the errors raised by cleaning of individual fields.

  Note that any errors raised by your Form.clean() override will not
  be associated with any field in particular. They go into a special
  “field” (called __all__), which you can access via the
  non_field_errors() method if you need to. If you
  want to attach errors to a specific field in the form, you need to call
  add_error().

  Also note that there are special considerations when overriding
  the clean() method of a ModelForm subclass. (see the
  ModelForm documentation for more information)

These methods are run in the order given above, one field at a time. That is,
for each field in the form (in the order they are declared in the form
definition), the Field.clean() method (or its override) is run, then
clean_<fieldname>(). Finally, once those two methods are run for every
field, the Form.clean() method, or its override, is executed whether
or not the previous methods have raised errors.

Examples of each of these methods are provided below.

As mentioned, any of these methods can raise a ValidationError. For any
field, if the Field.clean() method raises a ValidationError, any
field-specific cleaning method is not called. However, the cleaning methods
for all remaining fields are still executed.

raise ValidationError(
    _('Invalid value: %(value)s'),
    code='invalid',
    params={'value': '42'},
)

ValidationError(_('Invalid value: %s') % value)

# Good
raise ValidationError([
    ValidationError(_('Error 1'), code='error1'),
    ValidationError(_('Error 2'), code='error2'),
])

# Bad
raise ValidationError([
    _('Error 1'),
    _('Error 2'),
])

from django.core import validators
from django.forms import CharField

class SlugField(CharField):
    default_validators = [validators.validate_slug]

slug = forms.CharField(validators=[validators.validate_slug])

from django import forms
from django.core.validators import validate_email

class MultiEmailField(forms.Field):
    def to_python(self, value):
        """Normalize data to a list of strings."""
        # Return an empty list if no input was given.
        if not value:
            return []
        return value.split(',')

    def validate(self, value):
        """Check if value consists only of valid emails."""
        # Use the parent's handling of required fields, etc.
        super().validate(value)
        for email in value:
            validate_email(email)

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField()
    sender = forms.EmailField()
    recipients = MultiEmailField()
    cc_myself = forms.BooleanField(required=False)

from django import forms
from django.core.exceptions import ValidationError

class ContactForm(forms.Form):
    # Everything as before.
    ...

    def clean_recipients(self):
        data = self.cleaned_data['recipients']
        if "fred@example.com" not in data:
            raise ValidationError("You have forgotten about Fred!")

        # Always return a value to use as the new cleaned data, even if
        # this method didn't change it.
        return data

from django import forms
from django.core.exceptions import ValidationError

class ContactForm(forms.Form):
    # Everything as before.
    ...

    def clean(self):
        cleaned_data = super().clean()
        cc_myself = cleaned_data.get("cc_myself")
        subject = cleaned_data.get("subject")

        if cc_myself and subject:
            # Only do something if both fields are valid so far.
            if "help" not in subject:
                raise ValidationError(
                    "Did not send for 'help' in the subject despite "
                    "CC'ing yourself."
                )

def clean(self):
    super().clean()
    cc_myself = self.cleaned_data.get("cc_myself")
    ...

from django import forms

class ContactForm(forms.Form):
    # Everything as before.
    ...

    def clean(self):
        cleaned_data = super().clean()
        cc_myself = cleaned_data.get("cc_myself")
        subject = cleaned_data.get("subject")

        if cc_myself and subject and "help" not in subject:
            msg = "Must put 'help' in subject when cc'ing yourself."
            self.add_error('cc_myself', msg)
            self.add_error('subject', msg)

Валидация форм и полей¶

Валидация формы происходит при очистке данных. Если вы хотите настроить этот процесс, есть различные места для внесения изменений, каждое из которых служит для разных целей. В процессе обработки формы выполняются три типа методов очистки. Обычно они выполняются, когда вы вызываете метод is_valid() на форме. Есть и другие вещи, которые также могут вызвать очистку и проверку (обращение к атрибуту errors или прямой вызов full_clean()), но обычно они не нужны.

В общем, любой метод очистки может поднять ValidationError, если есть проблема с данными, которые он обрабатывает, передавая соответствующую информацию конструктору ValidationError. See below для лучшей практики поднятия ValidationError. Если не поднимается ValidationError, метод должен вернуть очищенные (нормализованные) данные в виде объекта Python.

Большинство валидаций можно выполнить с помощью validators — помощников, которые можно использовать повторно. Валидаторы — это функции (или callables), которые принимают один аргумент и вызывают ValidationError при недопустимом вводе. Валидаторы запускаются после вызова методов to_python и validate поля.

Валидация формы разбита на несколько этапов, которые можно настроить или отменить:

• Метод to_python() на Field является первым шагом в каждой валидации. Он преобразует значение к правильному типу данных и выдает сообщение ValidationError, если это невозможно. Этот метод принимает необработанное значение от виджета и возвращает преобразованное значение. Например, FloatField превратит данные в Python float или выдаст ValidationError.

• Метод validate() на Field обрабатывает специфическую для поля валидацию, которая не подходит для валидатора. Он принимает значение, которое было приведено к правильному типу данных, и при любой ошибке выдает сообщение ValidationError. Этот метод ничего не возвращает и не должен изменять значение. Вы должны переопределить его для обработки логики валидации, которую вы не можете или не хотите поместить в валидатор.

• Метод run_validators() на поле Field запускает все валидаторы поля и объединяет все ошибки в один ValidationError. Вам не нужно переопределять этот метод.

• Метод clean() в подклассе Field отвечает за выполнение to_python(), validate() и run_validators() в правильном порядке и распространение их ошибок. Если в любой момент времени какой-либо из методов вызывает ошибку ValidationError, валидация останавливается, и эта ошибка выдается. Этот метод возвращает чистые данные, которые затем вставляются в словарь cleaned_data формы.

• Метод clean_<fieldname>() вызывается на подклассе формы – где <fieldname> заменяется на имя атрибута поля формы. Этот метод выполняет любую очистку, специфичную для данного атрибута, не связанную с типом поля, которым он является. Этому методу не передаются никакие параметры. Вам нужно будет найти значение поля в self.cleaned_data и помнить, что в этот момент это будет объект Python, а не исходная строка, представленная в форме (она будет в cleaned_data, потому что метод general field clean(), описанный выше, уже однажды очистил данные).

  Например, если вы хотите проверить, что содержимое CharField под названием serialnumber является уникальным, clean_serialnumber() будет подходящим местом для этого. Вам не нужно конкретное поле (это CharField), но вам нужен специфический для поля формы фрагмент проверки и, возможно, очистки/нормализации данных.

  Возвращаемое значение этого метода заменяет существующее значение в cleaned_data, поэтому это должно быть значение поля из cleaned_data (даже если этот метод не изменил его) или новое очищенное значение.

• Метод clean() подкласса формы может выполнять валидацию, требующую доступа к нескольким полям формы. Сюда можно отнести такие проверки, как «если поле A предоставлено, то поле B должно содержать действительный адрес электронной почты». При желании этот метод может вернуть совершенно другой словарь, который будет использован в качестве cleaned_data.

  Поскольку методы валидации полей были запущены к моменту вызова clean(), у вас также есть доступ к атрибуту errors формы, который содержит все ошибки, возникшие при очистке отдельных полей.

  Обратите внимание, что любые ошибки, возникающие при переопределении Form.clean(), не будут связаны с каким-либо конкретным полем. Они попадают в специальное «поле» (называемое __all__), к которому вы можете получить доступ через метод non_field_errors(), если вам это необходимо. Если вы хотите прикрепить ошибки к определенному полю формы, вам нужно вызвать add_error().

  Также обратите внимание, что существуют особые соображения при переопределении метода clean() подкласса ModelForm. (см. ModelForm documentation для получения дополнительной информации)

Эти методы выполняются в указанном выше порядке, по одному полю за раз. То есть, для каждого поля формы (в порядке их объявления в определении формы) выполняется метод Field.clean() (или его переопределение), затем clean_<fieldname>(). Наконец, когда эти два метода выполнены для каждого поля, выполняется метод Form.clean(), или его переопределение, независимо от того, вызвали ли предыдущие методы ошибки.

Примеры каждого из этих методов приведены ниже.

Как уже упоминалось, любой из этих методов может вызвать ошибку ValidationError. Для любого поля, если метод Field.clean() вызывает ValidationError, любой метод очистки, специфичный для данного поля, не вызывается. Однако методы очистки для всех оставшихся полей все равно выполняются.

raise ValidationError(
    _('Invalid value: %(value)s'),
    code='invalid',
    params={'value': '42'},
)

ValidationError(_('Invalid value: %s') % value)

# Good
raise ValidationError([
    ValidationError(_('Error 1'), code='error1'),
    ValidationError(_('Error 2'), code='error2'),
])

# Bad
raise ValidationError([
    _('Error 1'),
    _('Error 2'),
])

from django.core import validators
from django.forms import CharField

class SlugField(CharField):
    default_validators = [validators.validate_slug]

slug = forms.CharField(validators=[validators.validate_slug])

from django import forms
from django.core.validators import validate_email

class MultiEmailField(forms.Field):
    def to_python(self, value):
        """Normalize data to a list of strings."""
        # Return an empty list if no input was given.
        if not value:
            return []
        return value.split(',')

    def validate(self, value):
        """Check if value consists only of valid emails."""
        # Use the parent's handling of required fields, etc.
        super().validate(value)
        for email in value:
            validate_email(email)

class ContactForm(forms.Form):
    subject = forms.CharField(max_length=100)
    message = forms.CharField()
    sender = forms.EmailField()
    recipients = MultiEmailField()
    cc_myself = forms.BooleanField(required=False)

from django import forms
from django.core.exceptions import ValidationError

class ContactForm(forms.Form):
    # Everything as before.
    ...

    def clean_recipients(self):
        data = self.cleaned_data['recipients']
        if "fred@example.com" not in data:
            raise ValidationError("You have forgotten about Fred!")

        # Always return a value to use as the new cleaned data, even if
        # this method didn't change it.
        return data

from django import forms
from django.core.exceptions import ValidationError

class ContactForm(forms.Form):
    # Everything as before.
    ...

    def clean(self):
        cleaned_data = super().clean()
        cc_myself = cleaned_data.get("cc_myself")
        subject = cleaned_data.get("subject")

        if cc_myself and subject:
            # Only do something if both fields are valid so far.
            if "help" not in subject:
                raise ValidationError(
                    "Did not send for 'help' in the subject despite "
                    "CC'ing yourself."
                )

def clean(self):
    super().clean()
    cc_myself = self.cleaned_data.get("cc_myself")
    ...

from django import forms

class ContactForm(forms.Form):
    # Everything as before.
    ...

    def clean(self):
        cleaned_data = super().clean()
        cc_myself = cleaned_data.get("cc_myself")
        subject = cleaned_data.get("subject")

        if cc_myself and subject and "help" not in subject:
            msg = "Must put 'help' in subject when cc'ing yourself."
            self.add_error('cc_myself', msg)
            self.add_error('subject', msg)