# Documentation Django 6.0.7

# Validateurs

## Écriture de validateurs

Un validateur est un exécutable acceptant une valeur et générant `ValidationError` si celle-ci ne répond pas à certains critères. Les validateurs peuvent être utiles pour réutiliser la logique de validation entre différents types de champs.

Par exemple, voici un validateur qui n’autorise que les nombres pairs :

    from django.core.exceptions import ValidationError
    from django.utils.translation import gettext_lazy as _

    def validate_even(value):
        if value % 2 != 0:
            raise ValidationError(
                _("%(value)s is not an even number"),
                params={"value": value},
            )

Vous pouvez l’ajouter à un champ de modèle via le paramètre `validators` du champ :

    from django.db import models

    class MyModel(models.Model):
        even_field = models.IntegerField(validators=[validate_even])

Comme les valeurs sont converties en Python avant que les validateurs ne soient exécutés, vous pouvez même utiliser les mêmes validateurs avec les formulaires :

    from django import forms

    class MyForm(forms.Form):
        even_field = forms.IntegerField(validators=[validate_even])

Vous pouvez aussi utiliser une classe avec une méthode `__call__()` pour des validateurs plus complexes ou configurables. Par exemple, `RegexValidator` utilise cette technique. Si un validateur basé sur une classe est utilisé dans l’option de champ de modèle `validators`, vérifiez qu’il puisse être sérialisé par le système des migrations en lui ajoutant les méthodes deconstruct() et `__eq__()`.

## Exécution des validateurs

Consultez la validation des formulaires pour plus d’informations sur la manière dont les validateurs sont exécutés dans les formulaires, et validation d’objets sur leur manière d’être exécutés pour les modèles. Notez que les validateurs ne sont pas exécutés automatiquement lorsque vous enregistrez un modèle, mais si vous utilisez un formulaire `ModelForm`, celui-ci applique les validateurs sur tous les champs inclus dans le formulaire. Consultez la documentation des ModelForm pour plus d’informations sur la manière dont la validation des modèles interagit avec les formulaires.

## Validateurs intégrés

Le module `django.core.validators` contient une collection de validateurs exécutables à destination des champs de modèles et de formulaires. Ils sont utilisés en interne mais sont aussi à disposition pour vos propres champs. Ils peuvent être employés en plus ou à la place de méthodes `field.clean()` personnalisées.

### `RegexValidator`

class RegexValidator(regex=None, message=None, code=None, inverse_match=None, flags=0)
  Paramètres:

    - regex – Si différent de `None`, surcharge `regex`. Cela peut être une chaîne d’expression régulière ou une expression régulière précompilée.

    - message – Si différent de `None`, surcharge `message`.

    - code – Si différent de `None`, surcharge `code`.

    - inverse_match – Si différent de `None`, surcharge `inverse_match`.

    - flags – Si différent de `None`, surcharge `flags`. Dans ce cas, `regex` doit être une chaîne d’expression régulière sous peine de générer une exception `TypeError`.

  Un validateur `RegexValidator` recherche dans la valeur `value` fournie avec l’expression régulière indiquée au moyen de `re.search()`. Par défaut, génère une exception `ValidationError` avec `message` et `code` quand aucune correspondance n’est trouvée. Son comportement peut être inversé en définissant `inverse_match` à `True`, auquel cas une erreur `ValidationError` est générée dans le cas où une correspondance est trouvée.

  regex

    Le motif d’expression régulière à utiliser pour chercher dans la valeur `value` fournie, utilisant `re.search()`. Ce peut être une chaîne ou une expression régulière précompilée créée avec `re.compile()`. Contient par défaut la chaîne vide qui sera trouvée dans n’importe quelle valeur possible de `value`.

  message

    Le message d’erreur utilisé par `ValidationError` si la validation échoue. La valeur par défaut est `"Saisissez une valeur valide"`.

  code

    Le code d’erreur utilisé par `ValidationError` si la validation échoue. La valeur par défaut est `"invalid"`.

  inverse_match

    Le mode de correspondance pour `regex`. Sa valeur par défaut est `False`.

  flags

    Les drapeaux regex utilisés lors de la compilation de la chaîne d’expression régulière `regex`. Si `regex` est une expression régulière précompilée et que `flags` est défini, une exception `TypeError` est générée. La valeur par défaut est `0`.

### `EmailValidator`

class EmailValidator(message=None, code=None, allowlist=None)
  Paramètres:

    - message – Si différent de `None`, surcharge `message`.

    - code – Si différent de `None`, surcharge `code`.

    - allowlist – Si différent de `None`, surcharge `allowlist`.

  An `EmailValidator` ensures that a value looks like an email address, and raises a `ValidationError` with `message` and `code` if it doesn’t. Values longer than 320 characters are always considered invalid.

  message

    Le message d’erreur utilisé par `ValidationError` si la validation échoue. La valeur par défaut est `"Saisissez une adresse de courriel valide"`.

  code

    Le code d’erreur utilisé par `ValidationError` si la validation échoue. La valeur par défaut est `"invalid"`.

  allowlist

    Liste autorisée de domaines de messagerie. Par défaut, une expression régulière (l’attribut `domain_regex`) est utilisée pour valider tout ce qui apparaît après le signe `@`. Cependant, si cette chaîne apparaît dans la liste `allowlist`, cette validation est ignorée. Si ce paramètre n’est pas indiqué, sa valeur par défaut est `['localhost']`. D’autres domaines qui ne contiennent pas de point ne passeront pas la validation, il est donc nécessaire de les ajouter à la liste autorisée `allowlist` s’ils sont valides selon vous.

### `DomainNameValidator`

class DomainNameValidator(accept_idna=True, message=None, code=None)

  Une sous-classe de `RegexValidator` s’assurant qu’une valeur ressemble à un nom de domaine. Les valeurs plus longues que 255 ne sont jamais considérées comme valides. Les adresse IP ne sont pas acceptées comme des noms de domaine valides.

  En plus des paramètres facultatifs de sa classe parente `RegexValidator`, `DomainNameValidator` accepte un attribut facultatif supplémentaire :

  accept_idna

    Détermine s’il faut accepter les noms de domaine internationalisés, c’est-à-dire les noms de domaine qui contiennent des caractères non ASCII. La valeur par défaut est `True`.

### `URLValidator`

class URLValidator(schemes=None, regex=None, message=None, code=None)

  Une sous-classe de `RegexValidator` s’assurant qu’une valeur réponde aux critères d’une URL, et générant un code d’erreur `'invalid'` dans le cas contraire. Les valeurs plus longues que `max_length` caractères sont toujours considérées comme non valides.

  Les adresses de type « loopback » (boucle locale) et les espaces IP réservés sont considérés comme valides. Les adresses IPv6 littérales (RFC 3986 Section 3.2.2) et les domaines Unicode sont tous deux pris en charge.

  En plus des paramètres facultatifs de sa classe parente `RegexValidator`, `URLValidator` accepte un attribut facultatif supplémentaire :

  schemes

    Liste de protocoles URL/URI à valider. Lorsque ce paramètre est omis, la liste par défaut est `['http', 'https', 'ftp', 'ftps']`. Le site web de la IANA fournit comme référence la liste complète des protocoles d’URI valides.

    Avertissement

    Les valeurs commençant par `file:///` ne passeront pas la validation, même quand le protocole `file` est fourni. Les valeurs doivent contenir un nom d’hôte pour être valables.

  max_length

    La longueur maximale des valeurs pouvant être considérées comme valides. Contient 2048 caractères par défaut.

### `validate_email`

validate_email

  Une instance `EmailValidator` sans aucune personnalisation.

### `validate_domain_name`

validate_domain_name

  Une instance `DomainNameValidator` sans aucune personnalisation.

### `validate_slug`

validate_slug

  Une instance de `RegexValidator` s’assurant qu’une valeur ne soit composée que de lettres, de chiffres, de soulignements ou de tirets.

### `validate_unicode_slug`

validate_unicode_slug

  Une instance de `RegexValidator` s’assurant qu’une valeur ne soit composée que de lettres Unicode, de chiffres, de soulignements ou de tirets.

### `validate_ipv4_address`

validate_ipv4_address

  Une instance de `RegexValidator` s’assurant qu’une valeur réponde aux critères d’une adresse IPv4.

### `validate_ipv6_address`

validate_ipv6_address

  Utilise `django.utils.ipv6` pour vérifier la validité d’une adresse IPv6.

### `validate_ipv46_address`

validate_ipv46_address

  Utilise à la fois `validate_ipv4_address` et `validate_ipv6_address` pour s’assurer qu’une valeur soit une adresse IPv4 ou IPv6 valide.

### `validate_comma_separated_integer_list`

validate_comma_separated_integer_list

  Une instance de `RegexValidator` s’assurant qu’une valeur contienne une liste de nombres entiers séparés par des virgules.

### `int_list_validator`

int_list_validator(sep=',', message=None, code='invalid', allow_negative=False)

  Renvoie une instance de `RegexValidator` s’assurant qu’une chaîne ne contienne que des nombres entiers séparés par `sep`. Les entiers négatifs sont autorisés lorsque `allow_negative` vaut `True`.

### `MaxValueValidator`

class MaxValueValidator(limit_value, message=None)

  Génère une exception `ValidationError` avec le code `'max_value'` si la valeur `value` est plus grande que `limit_value`, qui peut être exécutable.

### `MinValueValidator`

class MinValueValidator(limit_value, message=None)

  Génère une exception `ValidationError` avec le code `'min_value'` si la valeur `value` est plus petite que `limit_value`, qui peut être exécutable.

### `MaxLengthValidator`

class MaxLengthValidator(limit_value, message=None)

  Génère une exception `ValidationError` avec le code `'max_length'` si la longueur de la valeur `value` est plus grande que `limit_value`, qui peut être exécutable.

### `MinLengthValidator`

class MinLengthValidator(limit_value, message=None)

  Génère une exception `ValidationError` avec le code `'min_length'` si la longueur de la valeur `value` est plus petite que `limit_value`, qui peut être exécutable.

### `DecimalValidator`

class DecimalValidator(max_digits, decimal_places)

  Génère une exception `ValidationError` avec les codes suivants :

  - `'max_digits'` si le nombre de chiffres est plus grand que `max_digits`.

  - `'max_decimal_places'` si le nombre de chiffres après la virgule est plus grand que `decimal_places`.

  - `'max_whole_digits'` si le nombre de chiffres de la partie entière est plus grand que la différence entre `max_digits` et `decimal_places`.

### `FileExtensionValidator`

class FileExtensionValidator(allowed_extensions, message, code)

  Génère une exception `ValidationError` avec le code `'invalid_extension'` si l’extension de `value.name` (`value` étant un objet `File`) ne se trouve pas dans `allowed_extensions`. La comparaison d’extension avec `allowed_extensions` est insensible à la casse.

  Avertissement

  Ne vous fiez pas à la validation de l’extension de fichier pour déterminer un type de fichier. Les fichiers peuvent être renommés avec n’importe quelle extension quel que soit leur contenu.

### `validate_image_file_extension`

validate_image_file_extension

  Uses Pillow to ensure that `value.name` (`value` is a `File`) has a valid image extension.

### `ProhibitNullCharactersValidator`

class ProhibitNullCharactersValidator(message=None, code=None)

  Génère une exception `ValidationError` si `str(value)` contient un ou plusieurs caractères nuls (`'\x00'`).

  Paramètres:

    - message – Si différent de `None`, surcharge `message`.

    - code – Si différent de `None`, surcharge `code`.

  message

    Le message d’erreur utilisé par `ValidationError` si la validation échoue. La valeur par défaut est `"Les caractères nuls ne sont pas autorisés"`.

  code

    Le code d’erreur utilisé par `ValidationError` si la validation échoue. La valeur par défaut est `"null_characters_not_allowed"`.

### `StepValueValidator`

class StepValueValidator(limit_value, message=None, offset=None)

  Génère une exception `ValidationError` ayant le code `'step_size'` si `value` n’est pas un multiple entier de `limit_value`, qui peut être un nombre à virgule, un entier, une valeur décimale ou un exécutable. Lorsque `offset` est défini, la validation s’applique à `limit_value` plus `offset`. Par exemple, pour `StepValueValidator(3, offset=1.4)`, les valeurs valides comprennent entre autres `1.4`, `4.4`, `7.4`, `10.4`.