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
