def __call__(self, value):
digit_tuple, exponent = value.as_tuple()[1:]
decimals = abs(exponent)
# digit_tuple doesn't include any leading zeros.
digits = len(digit_tuple)
if decimals > digits:
# We have leading zeros up to or past the decimal point. Count
# everything past the decimal point as a digit. We do not count
# 0 before the decimal point as a digit since that would mean
# we would not allow max_digits = decimal_places.
digits = decimals
whole_digits = digits - decimals
if self.max_digits is not None and digits > self.max_digits:
raise ValidationError(
self.messages['max_digits'],
code='max_digits',
params={'max': self.max_digits},
)
if self.decimal_places is not None and decimals > self.decimal_places:
raise ValidationError(
self.messages['max_decimal_places'],
code='max_decimal_places',
params={'max': self.decimal_places},
)
if (self.max_digits is not None and self.decimal_places is not None
and whole_digits > (self.max_digits - self.decimal_places)):
raise ValidationError(
self.messages['max_whole_digits'],
code='max_whole_digits',
params={'max': (self.max_digits - self.decimal_places)},
)
async def clean(self, value):
if self.required and value is empty:
raise ValidationError(self.error_messages['required'],
code='required')
if value is empty:
value = [] if self.many else {}
elif not isinstance(value, (dict, list)):
raise ValidationError(self.error_messages['type_error'],
code='type_error',
params=dict(input_type=type(value).__name__))
form_data_size = len(value)
if self.allow_empty and form_data_size == 0:
return [] if self.many else {}
# elif form_data_size == 0:
# raise ValidationError(self.error_messages['empty'], code='empty')
if isinstance(value, dict):
value = [value]
form_cls = self.form_class(data=value)
is_valid = await form_cls.is_valid()
if is_valid:
result = await form_cls.cleaned_data
return result if self.many else result[0]
errors = await form_cls.errors
raise ValidationError(errors)
def validate(self, value):
if value is empty and self.required:
raise ValidationError(self.error_messages["required"],
code="required")
if self.disabled is False and value in self.empty_values and not self.null:
raise ValidationError(self.error_messages["null"], code="null")
async def clean(self, form_data, form_files):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
clean_data = []
errors = {}
for field in self.fields:
field_value = field.value_from_datadict(form_data, form_files)
try:
field_value = await field.clean(field_value)
if field_value is empty:
continue
clean_data.append(field_value)
except ValidationError as e:
errors[field.field_name] = e.detail
if errors:
raise ValidationError(errors)
if self.required and not clean_data:
raise ValidationError(self.error_messages['required'],
code='required')
out = self.compress(clean_data)
self.validate(out)
await self.run_validators(out)
return out
def __call__(self, value):
value = force_text(value)
if not value or not value.isdigit():
raise ValidationError(self.message, code=self.code)
if not self.phone_regex.match(value):
raise ValidationError(self.message, code=self.code)
async def clean(self, value):
if value is empty:
value = []
elif isinstance(value, type('')) or isinstance(value, collections.Mapping)\
or not hasattr(value, '__iter__'):
raise ValidationError(self.error_messages['not_a_list'],
code='not_a_list',
params=dict(input_type=type(value).__name__))
if not self.allow_empty and len(value) == 0:
raise ValidationError(self.error_messages['empty'], code='empty')
return [await self.child.clean(item) for item in value]
def validate(self, value):
"""
Validates that the input is a list or tuple.
"""
if self.required and not value:
raise ValidationError(self.error_messages['required'], code='required')
# Validate that each value in the value list is in self.choices.
for val in value:
if not self.valid_value(val):
raise ValidationError(
self.error_messages['invalid_choice'],
code='invalid_choice',
params={'input': val},
)
def to_python(self, value):
if not value:
return []
elif not isinstance(value, (list, tuple)):
raise ValidationError(self.error_messages['invalid_list'],
code='invalid_list')
return [force_text(val) for val in value]
def __call__(self, value):
if not value or '\x00' in value:
raise ValidationError(self.message[self.protocol], code=self.code)
if self.protocol == "both":
valid = self.is_valid_ip(value)
elif self.protocol == "ipv4":
valid = self.check_ipv4(value)
elif self.protocol == "ipv6":
valid = self.check_ipv6(value)
if not valid:
raise ValidationError(self.message[self.protocol], code=self.code)
def to_python(self, value):
"""Returns a Python boolean object."""
if value in self.TRUE_VALUES:
return True
elif value in self.FALSE_VALUES:
return False
else:
raise ValidationError(self.error_messages['invalid'], code='invalid', params=value)
def validate(self, value):
super(FloatField, self).validate(value)
# Check for NaN (which is the only thing not equal to itself) and +/- infinity
if value != value or value in (Decimal('Inf'), Decimal('-Inf')):
raise ValidationError(self.error_messages['invalid'], code='invalid')
return value
def __call__(self, value):
"""
Validates that the input matches the regular expression
if inverse_match is False, otherwise raises ValidationError.
"""
if not (self.inverse_match is not bool(
self.regex.search(force_text(value)))):
raise ValidationError(self.message, code=self.code)
def __call__(self, value):
if self.level == "any" or self.password_regex is None:
return
valid = self.password_regex.match(value)
if not valid:
raise ValidationError(self.message[self.level], code=self.code)
def to_python(self, value):
if value in self.TRUE_VALUES:
return True
elif value in self.FALSE_VALUES:
return False
elif value in self.NULL_VALUES:
return None
else:
raise ValidationError(self.error_messages['invalid'], code='invalid', params=value)
def __call__(self, req_params):
self.enforce_required_fields(req_params)
queryset = self.queryset
queryset = self.filter_queryset(req_params, queryset)
queryset = self.exclude_current_instance(queryset)
checked_values = [value for field, value in req_params.items() if field in self.fields]
if None not in checked_values and (yield from qs_exists(queryset)):
raise ValidationError(self.message, code='unique', field=self.error_field)
def __call__(self, value):
cleaned = self.clean(value)
params = {
'limit_value': self.limit_value,
'show_value': cleaned,
'value': value
}
if self.compare(cleaned, self.limit_value):
raise ValidationError(self.message, code=self.code, params=params)
def __call__(self, value):
queryset = self.queryset
queryset = self.filter_queryset(value, queryset)
queryset = self.exclude_current_instance(queryset)
if (yield from qs_exists(queryset)):
raise ValidationError(
self.message, code='unique',
params={"field_name": self.field_name}
)
def validate(self, value):
super(DecimalField, self).validate(value)
if value in self.empty_values:
return
# Check for NaN, Inf and -Inf values. We can't compare directly for NaN,
# since it is never equal to itself. However, NaN is the only value that
# isn't equal to itself, so we can use this to identify NaN
if value != value or value == Decimal("Inf") or value == Decimal("-Inf"):
raise ValidationError(self.error_messages['invalid'], code='invalid')
async def clean(self, data):
if not isinstance(data, dict):
raise ValidationError(
self.error_messages['not_a_dict'],
code='not_a_dict',
params=dict(input_type=type(data).__name__)
)
return {str(key): await self.child.clean(value) for key, value in data.items()}
def split_url(url):
"""
Returns a list of url parts via ``urlparse.urlsplit`` (or raises a
``ValidationError`` exception for certain).
"""
try:
return list(urlsplit(url))
except ValueError:
raise ValidationError(self.error_messages['invalid'], code='invalid')
async def filter_queryset(self, request_handler, queryset):
filter_class = self.get_filter_class(request_handler, queryset)
if filter_class:
filterset = filter_class(request_handler.request.data, queryset)
if not await filterset.is_valid() and self.raise_exception:
raise ValidationError(await filterset.errors)
return await filterset.qs
return queryset
def __call__(self, value):
if not value:
raise ValidationError(self.message[self.protocol], code=self.code)
if self.protocol == "both":
if "@" in value:
validate_email(value)
elif value.isdigit():
validate_phone(value)
else:
raise ValidationError(self.message[self.protocol],
code=self.code)
elif self.protocol == "email":
validate_email(value)
elif self.protocol == "phone":
validate_phone(value)
def to_python(self, data):
if data in self.empty_values:
return None
try:
file_name = data.name
file_size = data.size
except AttributeError:
raise ValidationError(self.error_messages['invalid'], code='invalid')
if self.max_length is not None and len(file_name) > self.max_length:
params = {'max': self.max_length, 'length': len(file_name)}
raise ValidationError(self.error_messages['max_length'], code='max_length', params=params)
if not file_name:
raise ValidationError(self.error_messages['invalid'], code='invalid')
if not self.allow_empty_file and not file_size:
raise ValidationError(self.error_messages['empty'], code='empty')
return data
def to_python(self, value):
try:
return self.choice_strings_to_values[force_text(value)]
except KeyError:
choices = ', '.join(self.choice_strings_to_values.keys())
raise ValidationError(
self.error_messages['invalid_choice'],
code='invalid_choice',
params={'choices': choices, "input": value},
)
def to_python(self, value):
value = super(UUIDField, self).to_python(value)
if value in self.empty_values:
return None
if not isinstance(value, uuid.UUID):
try:
value = uuid.UUID(value)
except ValueError:
raise ValidationError(self.error_messages['invalid'], code='invalid')
return value
def __call__(self, value):
value = force_text(value)
# Check first if the scheme is valid
scheme = value.split('://')[0].lower()
if scheme not in self.schemes:
raise ValidationError(self.message, code=self.code)
# Then check full URL
try:
super(URLValidator, self).__call__(value)
except ValidationError as e:
# Trivial case failed. Try for possible IDN domain
if value:
try:
scheme, netloc, path, query, fragment = urlsplit(value)
except ValueError: # for example, "Invalid IPv6 URL"
raise ValidationError(self.message, code=self.code)
try:
netloc = netloc.encode('idna').decode(
'ascii') # IDN -> ACE
except UnicodeError: # invalid domain part
raise e
url = urlunsplit((scheme, netloc, path, query, fragment))
super(URLValidator, self).__call__(url)
else:
raise
else:
# Now verify IPv6 in the netloc part
host_match = re.search(r'^\[(.+)\](?::\d{2,5})?$',
urlsplit(value).netloc)
if host_match:
potential_ip = host_match.groups()[0]
if not IPAddressValidator.check_ipv6(potential_ip):
raise ValidationError(self.message, code=self.code)
# url = value
# The maximum length of a full host name is 253 characters per RFC 1034
# section 3.1. It's defined to be 255 bytes or less, but this includes
# one byte for the length of the name and one byte for the trailing dot
# that's used to indicate absolute names in DNS.
if len(urlsplit(value).netloc) > 253:
raise ValidationError(self.message, code=self.code)
def enforce_required_fields(self, req_params):
if self.instance is not None:
return
missing_items = {
field_name: self.missing_message
for field_name in self.fields
if field_name not in req_params
}
if missing_items:
raise ValidationError(missing_items, code='required')
def __call__(self, value):
extension = os.path.splitext(value.name)[1][1:].lower()
if self.allowed_extensions is not None and extension not in self.allowed_extensions:
raise ValidationError(self.message,
code=self.code,
params={
'extension':
extension,
'allowed_extensions':
', '.join(self.allowed_extensions)
})
def __call__(self, value):
value = force_text(value)
if not value or '@' not in value:
raise ValidationError(self.message, code=self.code)
user_part, domain_part = value.rsplit('@', 1)
if not self.user_regex.match(user_part):
raise ValidationError(self.message, code=self.code)
if (domain_part not in self.domain_whitelist
and not self.validate_domain_part(domain_part)):
# Try for possible IDN domain-part
try:
domain_part = domain_part.encode('idna').decode('ascii')
if self.validate_domain_part(domain_part):
return
except UnicodeError:
pass
raise ValidationError(self.message, code=self.code)
async def full_clean(self):
"""
Cleans all of self.data and populates self._errors and
self._non_form_errors.
"""
self._errors = {}
if not self.is_bound:
return
if not isinstance(self.data, list):
raise ValidationError(
detail=_("The form data format must be a list structure, not a %s structure."),
code='FormDataFormatError',
params=type(self.data).__name__
)
for i in range(0, self.total_form_count):
form = self.forms[i]
form_error = await form.part_errors
if form_error:
for k, v in form_error.items():
self._errors["%s-%d" % (k, i+1)] = v
try:
if self.max_num is not None and self.total_form_count > self.max_num:
raise ValidationError(
detail=_("Please submit %d or fewer forms"),
code='too_many_forms',
params=self.max_num
)
if self.min_num is not None and self.total_form_count < self.min_num:
raise ValidationError(
detail=_("Please submit %d or more forms"),
code='too_few_forms',
params=self.min_num
)
self.clean()
except ValidationError as e:
self._errors[settings.NON_FIELD_ERRORS] = e.detail
