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