def get_value(self, dictionary):
# We override the default field access in order to support
# nested HTML forms.
if html.is_html_input(dictionary):
return html.parse_html_dict(dictionary,
prefix=self.field_name) or empty
return dictionary.get(self.field_name, empty)
def to_internal_value(self, data):
"""Dicts of native values <- Dicts of primitive datatypes."""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail("not_a_dict", input_type=type(data).__name__)
return self.run_child_validation(data)
def to_internal_value(self, data):
"""
Range instances <- Dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail('not_a_dict', input_type=type(data).__name__)
validated_dict = {}
for key in ('lower', 'upper'):
try:
value = data.pop(key)
except KeyError:
continue
validated_dict[six.text_type(key)] = self.child.run_validation(
value)
for key in ('bounds', 'empty'):
try:
value = data.pop(key)
except KeyError:
continue
validated_dict[six.text_type(key)] = value
if data:
self.fail('too_much_content',
extra=', '.join(map(str, data.keys())))
return self.range_type(**validated_dict)
def to_internal_value(self, data):
"""
Range instances <- Dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail('not_a_dict', input_type=type(data).__name__)
extra_content = list(
set(data) - set(["lower", "upper", "bounds", "empty"]))
if extra_content:
self.fail('too_much_content',
extra=', '.join(map(str, extra_content)))
validated_dict = {}
for key in ('lower', 'upper'):
try:
value = data[key]
except KeyError:
continue
validated_dict[str(key)] = self.child.run_validation(value)
for key in ('bounds', 'empty'):
try:
value = data[key]
except KeyError:
continue
validated_dict[str(key)] = value
return self.range_type(**validated_dict)
def get_value(self, dictionary):
"""
Override the default field access in order to support dictionaries in
HTML forms.
"""
if html.is_html_input(dictionary):
return html.parse_html_dict(dictionary, prefix=self.field_name)
return dictionary.get(self.field_name, serializers.empty)
def get_value(self, dictionary):
# We override the default field access in order to support
# nested HTML forms.
if html.is_html_input(dictionary):
return html.parse_html_dict(
dictionary, prefix=self.field_name
) or empty
return dictionary.get(self.field_name, empty)
def to_internal_value(self, data):
"""
Dicts of native values <- Dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail('not_a_dict', input_type=type(data).__name__)
return dict([(six.text_type(key), self.child.run_validation(value))
for key, value in data.items()])
def to_internal_value(self, data):
"""
Ensure incoming data is a dictionary and run validation on entries.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail("not_a_dict", input_type=type(data).__name__)
if not self.allow_empty and len(data) == 0:
self.fail("empty")
return self.run_child_validation(data)
def to_internal_value(self, data):
"""
Dicts of native values <- Dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail('not_a_dict', input_type=type(data).__name__)
return dict([
(six.text_type(key), self.child.run_validation(value))
for key, value in data.items()
])
def to_internal_value(self, data):
"""
Dicts of native values <- Dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail('not_a_dict', input_type=type(data).__name__)
if not self.allow_empty and len(data.keys()) == 0:
message = self.error_messages['empty']
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]})
return {
str(key): self.child.run_validation(value)
for key, value in data.items()
}
def get_value(self, dictionary):
# get just field name
value = dictionary.get(self.field_name, dict())
if value is None:
return empty
if not isinstance(value, dict):
raise ValidationError("Must be an object or null")
# then merge in fields with keys like `content_defaults.author`
multi_value = MultiValueDict()
multi_value.update(dictionary)
html_value = unnest_dict(
html.parse_html_dict(multi_value, prefix=self.field_name).dict())
value.update(html_value)
return value if len(value.keys()) else empty
def to_internal_value(self, data):
"""
Range instances <- Dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail('not_a_dict', input_type=type(data).__name__)
# allow_empty is added to DictField in DRF Version 3.9.3
if hasattr(self,
"allow_empty") and not self.allow_empty and len(data) == 0:
self.fail('empty')
extra_content = list(
set(data) - set(["lower", "upper", "bounds", "empty"]))
if extra_content:
self.fail('too_much_content',
extra=', '.join(map(str, extra_content)))
validated_dict = {}
for key in ('lower', 'upper'):
try:
value = data[key]
except KeyError:
continue
validated_dict[str(key)] = self.child.run_validation(value)
lower, upper = validated_dict.get('lower'), validated_dict.get('upper')
if lower is not None and upper is not None and lower > upper:
self.fail('bound_ordering')
for key in ('bounds', 'empty'):
try:
value = data[key]
except KeyError:
continue
validated_dict[str(key)] = value
return self.range_type(**validated_dict)
def to_internal_value(self, data):
"""
Data transformation to python JSON object.
:param str data: Data for transformation.
:return: Transformed data.
:rtype: dict
:raise ValidationError: If not valid data.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail('not_a_dict', input_type=type(data).__name__)
return {
six.text_type(key): self.child.run_validation(value)
for key, value in six.iteritems(data)
}
def to_internal_value(self, data):
"""
Range instances <- Lists of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, (list, tuple,)):
self.fail('not_a_list', input_type=type(data).__name__)
validated_dict = {}
for field in ('lower', 'upper',):
try:
validated_dict[field] = self.child.run_validation(data.pop(0))
except:
validated_dict[field] = None
try:
validated_dict['bounds'] = data.pop(0)
except IndexError:
pass
if data:
self.fail('too_much_content', extra=', '.join(map(str, data)))
return self.range_type(**validated_dict)
def to_internal_value(self, data):
"""
Range instances <- Dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_dict(data)
if not isinstance(data, dict):
self.fail('not_a_dict', input_type=type(data).__name__)
validated_dict = {}
for key in ('lower', 'upper'):
try:
value = data.pop(key)
except KeyError:
continue
validated_dict[six.text_type(key)] = self.child.run_validation(value)
for key in ('bounds', 'empty'):
try:
value = data.pop(key)
except KeyError:
continue
validated_dict[six.text_type(key)] = value
if data:
self.fail('too_much_content', extra=', '.join(map(str, data.keys())))
return self.range_type(**validated_dict)
def getFromRequestData(dictionary, key):
if html.is_html_input(dictionary):
return html.parse_html_dict(dictionary, prefix=key) or None
return dictionary.get(key, None)
def get_value(self, dictionary):
if html.is_html_input(dictionary):
data = html.parse_html_dict(dictionary, prefix=self.field_name)
data = dictionary.get(self.field_name, empty)
print('my dict field %s' % data)
return data
