def to_python(self, value): value = super(TypedDictField, self).to_python(value) if not value: return value value_dict = {} key_errors = [] value_errors = {} for key, value in value.items(): try: key = self.key_field.to_python(key) except exceptions.ValidationError as ve: key_errors += ve.error_messages # If we have key errors no point checking values any more. if key_errors: continue try: value_dict[key] = self.value_field.to_python(value) except exceptions.ValidationError as ve: value_errors[key] = ve.error_messages if key_errors: raise exceptions.ValidationError(key_errors) if value_errors: raise exceptions.ValidationError(value_errors) return value_dict
def run_validators(self, value): super(TypedDictField, self).run_validators(value) if value in EMPTY_VALUES: return key_errors = [] value_errors = {} for key, value in value.items(): try: key = self.key_field.run_validators(key) except exceptions.ValidationError as ve: key_errors += ve.error_messages # If we have key errors no point checking values any more. if key_errors: continue try: self.value_field.run_validators(value) except exceptions.ValidationError as ve: value_errors[key] = ve.error_messages if key_errors: raise exceptions.ValidationError(key_errors) if value_errors: raise exceptions.ValidationError(value_errors)
def to_python(self, value): if isinstance(value, uuid.UUID): return value elif isinstance(value, six.binary_type): if len(value) == 16: return uuid.UUID(bytes=value) try: value = value.decode('utf-8') except UnicodeDecodeError as e: raise exceptions.ValidationError(e.args[0], code='invalid') elif isinstance(value, six.integer_types): try: return uuid.UUID(int=value) except ValueError as e: raise exceptions.ValidationError(e.args[0], code='invalid') elif isinstance(value, (tuple, list)): try: return uuid.UUID(fields=value) except ValueError as e: raise exceptions.ValidationError(e.args[0], code='invalid') elif not isinstance(value, six.text_type): value = six.text_type(value) try: return uuid.UUID(value) except ValueError as e: raise exceptions.ValidationError(e.args[0], code='invalid')
def validate(self, value): if self.choices and value not in EMPTY_VALUES and not value_in_choices( value, self.choices): msg = self.error_messages['invalid_choice'] % value raise exceptions.ValidationError(msg) if not self.null and value is None: raise exceptions.ValidationError(self.error_messages['null'])
def __call__(self, value): cleaned = self.clean(value) params = {'limit_value': self.limit_value, 'show_value': cleaned} if self.compare(cleaned, self.limit_value): raise exceptions.ValidationError(self.message % params, code=self.code, params=params)
def validate(self, value): super(AmountField, self).validate(value) if self.allowed_currencies and value not in EMPTY_VALUES: if value.currency not in self.allowed_currencies: msg = self.error_messages['invalid_currency'] % str( value.currency) raise exceptions.ValidationError(msg)
def to_python(self, value): if value in EMPTY_VALUES: return if isinstance(value, arrow.Arrow): return value default_timezone = datetimeutil.local if self.assume_local else datetimeutil.utc if isinstance(value, datetime.datetime): if value.tzinfo: return arrow.Arrow.fromdatetime(value) else: return arrow.Arrow.fromdatetime(value, default_timezone) try: return arrow.Arrow.fromdatetime( datetimeutil.parse_iso_datetime_string(value, default_timezone)) except ValueError: pass try: return arrow.Arrow.fromdate( datetimeutil.parse_iso_date_string(value)) except ValueError: pass msg = self.error_messages['invalid'] raise exceptions.ValidationError(msg)
def to_python(self, value): if value is None: return value if isinstance(value, (list, tuple)): return value msg = self.error_messages['invalid'] raise exceptions.ValidationError(msg)
def test_with_string(self): test_message = "Test message" target = exceptions.ValidationError(test_message) assert [test_message] == target.messages assert not hasattr(target, 'message_dict') assert "['Test message']" == str(target) assert "ValidationError(['Test message'])" == repr(target)
def test_with_string(self): test_message = "Test message" target = exceptions.ValidationError(test_message) self.assertListEqual([test_message], target.messages) self.assertFalse(hasattr(target, 'message_dict')) self.assertEqual("['Test message']", str(target)) self.assertEqual("ValidationError(['Test message'])", repr(target))
def test_with_list(self): test_message_list = ["Test message", "Test message 2"] target = exceptions.ValidationError(test_message_list) self.assertListEqual(test_message_list, target.messages) self.assertFalse(hasattr(target, 'message_dict')) self.assertEqual("['Test message', 'Test message 2']", str(target)) self.assertEqual("ValidationError(['Test message', 'Test message 2'])", repr(target))
def to_python(self, value): if value in EMPTY_VALUES: return try: return self.scalar_type(value) except (TypeError, ValueError): msg = self.error_messages['invalid'] % value raise exceptions.ValidationError(msg)
def test_with_list(self): test_message_list = ["Test message", "Test message 2"] target = exceptions.ValidationError(test_message_list) assert test_message_list == target.messages assert not hasattr(target, 'message_dict') assert "['Test message', 'Test message 2']" == str(target) assert "ValidationError(['Test message', 'Test message 2'])" == repr(target)
def to_python(self, value): if value is None: return value try: val = dict(value) return val except (TypeError, ValueError): msg = self.error_messages['invalid'] raise exceptions.ValidationError(msg)
def to_python(self, value): if value is None: return None if isinstance(value, self.of): return value if isinstance(value, dict): return create_resource_from_dict(value, self.of._meta.resource_name) msg = self.error_messages['invalid'] % self.of raise exceptions.ValidationError(msg)
def validate(self, value): # Skip The direct super method and apply it to each list item. super(CompositeField, self).validate(value) # noqa if value is not None: super_validate = super(DictOf, self).validate self._process_dict(value, super_validate) if (value is not None) and (not value) and (not self.empty): raise exceptions.ValidationError(self.error_messages['empty'], code='empty')
def _process_dict(self, value_dict, method): values = {} errors = {} key_choices = self.key_choices for key, value in six.iteritems(value_dict): if key_choices and not value_in_choices(key, key_choices): msg = self.error_messages['invalid_key'] % value raise exceptions.ValidationError(msg) try: values[key] = method(value) except exceptions.ValidationError as ve: errors[key] = ve.error_messages if errors: raise exceptions.ValidationError(errors) return values
def __call__(self, value): if not value or '@' not in value: raise exceptions.ValidationError(self.message, code=self.code) user_part, domain_part = value.rsplit('@', 1) if not self.user_regex.match(user_part): raise exceptions.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 exceptions.ValidationError(self.message, code=self.code)
def to_python(self, value): if value in EMPTY_VALUES: return if isinstance(value, Amount): return value try: return Amount(value) except (ValueError, TypeError): msg = self.error_messages['invalid'] % value raise exceptions.ValidationError(msg)
def to_python(self, value): if value in EMPTY_VALUES: return if isinstance(value, datetime.datetime): return value try: return datetimeutil.parse_http_datetime_string(value) except ValueError: pass msg = self.error_messages['invalid'] raise exceptions.ValidationError(msg)
def to_python(self, value): if value in EMPTY_VALUES: return if isinstance(value, datetime.time): return value try: default_timezone = datetimeutil.local if self.assume_local else datetimeutil.utc return datetimeutil.parse_iso_time_string(value, default_timezone) except ValueError: pass msg = self.error_messages['invalid'] raise exceptions.ValidationError(msg)
def validate_ipv46_address(value): """ Validate is either an IPv4 or IPv6 address """ try: validate_ipv4_address(value) except exceptions.ValidationError: try: validate_ipv6_address(value) except exceptions.ValidationError: raise exceptions.ValidationError( 'Enter a valid IPv4 or IPv6 address.', code='invalid')
def to_python(self, value): if value in EMPTY_VALUES: return if isinstance(value, datetime.datetime): return value try: return datetime.datetime.fromtimestamp(long(value), tz=datetimeutil.utc) except ValueError: pass msg = self.error_messages['invalid'] raise exceptions.ValidationError(msg)
def run_validators(self, value): if value in EMPTY_VALUES: return errors = [] for v in self.validators: try: v(value) except registration.get_validation_error_list() as e: handler = registration.get_validation_error_handler(e) handler(e, self, errors) if errors: raise exceptions.ValidationError(errors)
def to_python(self, value): if value is None: return None if isinstance(value, (list, ResourceIterable)): super_to_python = super(ListOf, self).to_python def process(val): if val is None: raise exceptions.ValidationError(self.error_messages['null']) return super_to_python(val) return self._process_list(value, process) msg = self.error_messages['invalid'] % self.of raise exceptions.ValidationError(msg)
def to_python(self, value): if value is None: return None if isinstance(value, dict): super_to_python = super(DictOf, self).to_python def process(val): if val is None: raise exceptions.ValidationError(self.error_messages['null'], code='null') return super_to_python(val) return self._process_dict(value, process) msg = self.error_messages['invalid'] % self.of raise exceptions.ValidationError(msg)
def to_python(self, value): if value in EMPTY_VALUES: return if isinstance(value, datetime.time): if value.tzinfo and self.ignore_timezone: return value.replace(tzinfo=None) return value default_timezone = datetimeutil.IgnoreTimezone if self.ignore_timezone else None try: return datetimeutil.parse_iso_time_string(value, default_timezone) except ValueError: pass msg = self.error_messages['invalid'] raise exceptions.ValidationError(msg)
def _process_list(value_list, method): values = [] errors = {} for idx, value in enumerate(value_list): error_key = str(idx) try: values.append(method(value)) except exceptions.ValidationError as ve: errors[error_key] = ve.error_messages if errors: raise exceptions.ValidationError(errors) return values
def to_python(self, value): if value is None: return None if value in (True, False): # if value is 1 or 0 then it's equal to True or False, but we want # to return a true bool for semantic reasons. return bool(value) if isinstance(value, six.string_types): lvalue = value.lower() if lvalue in self.true_strings: return True if lvalue in self.false_strings: return False msg = self.error_messages['invalid'] % str(value) raise exceptions.ValidationError(msg)
def to_python(self, value): value = super(TypedListField, self).to_python(value) if not value: return value value_list = [] errors = {} for idx, item in enumerate(value): try: value_list.append(self.field.to_python(item)) except exceptions.ValidationError as ve: errors[idx] = ve.error_messages if errors: raise exceptions.ValidationError(errors) return value_list