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):
"""
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):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data)
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__
)
raise ValidationError({
api_settings.NON_FIELD_ERRORS_KEY: [message]
})
ret = []
errors = []
for item in data:
try:
validated = self.child.run_validation(item)
except ValidationError as exc:
errors.append(exc.detail)
else:
ret.append(validated)
errors.append({})
if any(errors):
raise ValidationError(errors)
return ret
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 to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data)
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__
)
raise ValidationError({
api_settings.NON_FIELD_ERRORS_KEY: [message]
})
ret = []
errors = []
for item in data:
try:
validated = self.child.run_validation(item)
except ValidationError as exc:
errors.append(exc.detail)
else:
ret.append(validated)
errors.append({})
if any(errors):
raise ValidationError(errors)
return ret
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data)
return [self.child.run_validation(item) for item in 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 self.run_child_validation(data)
def get_value(self, dictionary): if html.is_html_input(dictionary): # NOTE: with form/urlencoded we get [u'opt,opt'] for some reason, gotta work around try: return dictionary.getlist(self.field_name)[0] except IndexError: return super(MultiSelectField, self).get_value(dictionary) else: return super(MultiSelectField, self).get_value(dictionary)
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 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):
if self.field_name not in dictionary:
if getattr(self.root, 'partial', False):
return empty
# We override the default field access in order to support
# lists in HTML forms.
if html.is_html_input(dictionary):
return dictionary.getlist(self.field_name)
return dictionary.get(self.field_name, empty)
def get_value(self, dictionary):
# We override the default field access in order to support
# lists in HTML forms.
if html.is_html_input(dictionary):
return html.parse_html_list(dictionary, prefix=self.field_name)
value = dictionary.get(self.field_name, empty)
#if isinstance(value, type('')):
# return json.loads(value)
return value
def get_value(self, dictionary):
"""
Given the input dictionary, return the field value.
"""
# We override the default field access in order to support
# lists in HTML forms.
if html.is_html_input(dictionary):
return html.parse_html_list(dictionary, prefix=self.field_name)
return dictionary.get(self.field_name, empty)
def get_value(self, dictionary):
"""
Given the input dictionary, return the field value.
"""
# We override the default field access in order to support
# lists in HTML forms.
if html.is_html_input(dictionary):
return html.parse_html_list(dictionary, prefix=self.field_name)
return dictionary.get(self.field_name, empty)
def to_internal_value(self, data):
if html.is_html_input(data):
data = html.parse_html_list(data, default=[])
if isinstance(data, (str, Mapping)) or not hasattr(data, "__iter__"):
self.fail("not_a_list", input_type=type(data).__name__)
if not self.allow_empty and len(data) == 0:
self.fail("empty")
# Begin code retained from < drf 3.8.x.
return [self.child.run_validation(item) for item in data]
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data)
if isinstance(data, type('')) or not hasattr(data, '__iter__'):
self.fail('not_a_list', input_type=type(data).__name__)
return [self.child.run_validation(item) for item in data]
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data)
if isinstance(data, type('')) or not hasattr(data, '__iter__'):
self.fail('not_a_list', input_type=type(data).__name__)
return [self.child.run_validation(item) for item in data]
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if not self.instance:
return super().to_internal_value(data)
if html.is_html_input(data):
data = html.parse_html_list(data)
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__
)
raise ValidationError({
api_settings.NON_FIELD_ERRORS_KEY: [message]
}, code='not_a_list')
if not self.allow_empty and len(data) == 0:
if self.parent and self.partial:
raise SkipField()
message = self.error_messages['empty']
raise ValidationError({
api_settings.NON_FIELD_ERRORS_KEY: [message]
}, code='empty')
ret = []
errors = []
for item in data:
try:
# prepare child serializer to only handle one instance
if 'id' in item:
pk = item["id"]
elif 'pk' in item:
pk = item["pk"]
else:
raise ValidationError("id or pk not in data")
child = self.instance.get(id=pk) if self.instance else None
self.child.instance = child
self.child.initial_data = item
# raw
validated = self.child.run_validation(item)
except ValidationError as exc:
errors.append(exc.detail)
except ObjectDoesNotExist as e:
errors.append(e)
else:
ret.append(validated)
errors.append({})
if any(errors):
raise ValidationError(errors)
return ret
def get_value(self, dictionary):
if html.is_html_input(
dictionary
): # NOTE: with form/urlencoded we get [u'opt,opt'] for some reason, gotta work around
try:
return dictionary.getlist(self.field_name)[0]
except IndexError:
return super(MultiSelectField, self).get_value(dictionary)
else:
return super(MultiSelectField, self).get_value(dictionary)
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 get_value(self, dictionary):
"""
Given the *incoming* primitive data, return the value for this field
that should be validated and transformed to a native value.
"""
if html.is_html_input(dictionary):
# HTML forms will represent empty fields as '', and cannot
# represent None or False values directly.
ret = dictionary.get(self.field_name, '')
return self.default_empty_html if (ret == '') else ret
return dictionary.get(self.field_name, empty)
def get_value(self, dictionary):
"""
Given the *incoming* primitive data, return the value for this field
that should be validated and transformed to a native value.
"""
if html.is_html_input(dictionary):
# HTML forms will represent empty fields as '', and cannot
# represent None or False values directly.
ret = dictionary.get(self.field_name, '')
return self.default_empty_html if (ret == '') else ret
return dictionary.get(self.field_name, empty)
def get_value(self, dictionary):
# We override the default field access in order to support
# lists in HTML forms.
if html.is_html_input(dictionary):
# Don't return [] if the update is partial
if self.field_name not in dictionary:
if getattr(self.root, 'partial', False):
return empty
return dictionary.getlist(self.field_name)
return dictionary.get(self.field_name, empty)
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 get_value(self, dictionary):
if html.is_html_input(dictionary) and self.field_name in dictionary:
# When HTML form input is used, mark up the input
# as being a JSON string, rather than a JSON primitive.
class JSONString(six.text_type):
def __new__(self, value):
ret = six.text_type.__new__(self, value)
ret.is_json_string = True
return ret
return JSONString(dictionary[self.field_name])
return dictionary.get(self.field_name, serializers.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):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
_data = data[0].split(',') if len(data) > 0 else data
if html.is_html_input(_data):
data = html.parse_html_list(_data)
if isinstance(_data, type('')) or isinstance(
_data, collections.Mapping) or not hasattr(data, '__iter__'):
self.fail('not_a_list', input_type=type(_data).__name__)
if not self.allow_empty and len(_data) == 0:
self.fail('empty')
return [self.child.run_validation(item) for item in _data]
def get_value(self, dictionary):
if self.field_name not in dictionary:
if getattr(self.root, 'partial', False):
return empty
# We override the default field access in order to support
# lists in HTML forms.
if html.is_html_input(dictionary):
val = dictionary.getlist(self.field_name, [])
if len(val) > 0:
# Support QueryDict lists in HTML input.
return val
return html.parse_html_list(dictionary, prefix=self.field_name)
return dictionary.getlist(self.field_name, empty)
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data)
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__
)
raise ValidationError({
api_settings.NON_FIELD_ERRORS_KEY: [message]
}, code='not_a_list')
if not self.allow_empty and len(data) == 0:
if self.parent and self.partial:
raise SkipField()
message = self.error_messages['empty']
raise ValidationError({
api_settings.NON_FIELD_ERRORS_KEY: [message]
}, code='empty')
ret = []
errors = []
for item in data:
try:
# prepare child serializer to only handle one instance
if 'id' in item.keys():
self.child.instance = self.instance.get(id=item['id']) if self.instance else None
if 'pk' in item.keys():
self.child.instance = self.instance.get(id=item['pk']) if self.instance else None
self.child.initial_data = item
# raw
validated = self.child.run_validation(item)
except ValidationError as exc:
errors.append(exc.detail)
else:
ret.append(validated)
errors.append({})
if any(errors):
raise ValidationError(errors)
return ret
def to_internal_value(self, data):
"""
Data transformation to python list object.
:param object data: Data for transformation.
:return: Transformed data.
:rtype: list
:raise ValidationError: If data not valid.
"""
# Parse data.
if html.is_html_input(data):
data = html.parse_html_list(data)
# Initial validation that came in an array.
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__)
raise ValidationError(detail={'non_field_errors': [message]},
code='not_a_list')
# Validation that this is not an empty value and whether it is empty.
if not self.allow_empty and len(data) == 0:
message = self.error_messages['empty']
raise ValidationError(detail={'non_field_errors': [message]},
code='empty')
res, errors = [], [] # Make storage for results.
# Validating each item from the list.
for item in data:
try:
value = self.child.run_validation(item)
except ValidationError as e:
res.append({})
errors.append(e.detail)
else:
res.append(value)
errors.append({})
# If the conversion and validation failed.
if any(errors):
raise ValidationError(detail=errors)
# We return the transformed and validated data.
return res
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
serializer_field = self.fields[self.model_field.name]
if html.is_html_input(data):
data = html.parse_html_list(data)
if isinstance(data, type('')) or not hasattr(data, '__iter__'):
self.fail('not_a_dict', input_type=type(data).__name__)
native = OrderedDict()
for key in data:
native[key] = serializer_field.run_validation(data[key])
return native
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data)
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__)
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]},
code='not_a_list')
if not self.allow_empty and len(data) == 0:
if self.parent and self.partial:
raise SkipField()
message = self.error_messages['empty']
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]}, code='empty')
id_attr = getattr(self.child.Meta, 'update_lookup_field', 'id')
ret = []
errors = []
for item in data:
try:
view = self.context.get('view')
if view and view.action != 'create':
if id_attr not in item:
raise ValidationError(
{id_attr: ['This field is required.']})
instance = self.instance.get(**{id_attr: item[id_attr]})
self.child.instance = instance
self.child.initial_data = item
# Until here
validated = self.child.run_validation(item)
except ValidationError as exc:
errors.append(exc.detail)
else:
ret.append(validated)
errors.append({})
return {'ret': ret, 'errors': errors}
def to_internal_value(self, data):
"""
各个数据放入子序列化器中验证
"""
# 解析 html 输入数据
if html.is_html_input(data):
data = html.parse_html_list(data)
# 确认数据是列表
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__)
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]},
code='not_a_list')
# 确认非允许空的情况下数据不为空
if not self.allow_empty and len(data) == 0:
message = self.error_messages['empty']
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]}, code='empty')
# 将各个数据放入子序列化器中验证
ret = []
errors = []
for item in data:
try:
# 区分是否当前是否为更新操作
if self.instance is not None:
view = self.context.get('view')
id_attr = view.lookup_url_kwarg or view.lookup_field
instance = self.instance.get(**{id_attr: item[id_attr]})
self.child.instance = instance
validated = self.child.run_validation(item)
except ValidationError as exc:
errors.append(exc.detail)
else:
ret.append(validated)
errors.append({})
if any(errors):
raise ValidationError(errors)
# 还原子序列化器对象的 instance 属性
self.child.instance = self.instance
return ret
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data, default=[])
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__)
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]},
code='not_a_list')
if not self.allow_empty and len(data) == 0:
if self.parent and self.partial:
raise SkipField()
message = self.error_messages['empty']
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]}, code='empty')
ret = []
errors = []
for item in data:
try:
if self.instance:
try:
self.child.instance = self.instance.get(id=item['id'])
self.child.initial_data = item
except getattr(self.child.Meta.model,
'DoesNotExist') as exc:
raise ValidationError({'non_field_errors': [str(exc)]})
validated = self.child.run_validation(item)
except ValidationError as exc:
errors.append(exc.detail)
else:
ret.append(validated)
errors.append({})
if any(errors):
raise ValidationError(errors)
return ret
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data)
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__)
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]})
if not self.allow_empty and len(data) == 0:
message = self.error_messages['empty']
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]})
result = []
errors = []
id_attrs = self.get_id_attrs()
for item in data:
error = {}
for id_attr in id_attrs:
if id_attr in item:
try:
self.child.instance = self.instance.get(
**{id_attr: item[id_attr]
}) if self.instance else None
except (ObjectDoesNotExist, MultipleObjectsReturned) as e:
error.update({id_attr: [str(e)]})
break
if not error:
try:
# Do validation
validated = self.child.run_validation(item)
except ValidationError as exc:
error = exc.detail
else:
result.append(validated)
errors.append(error)
if any(errors):
del self.initial_data
raise ValidationError(errors)
return result
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 to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
Modified from https://github.com/encode/django-rest-framework/blob/master/rest_framework/serializers.py
based on suggestions from https://github.com/miki725/django-rest-framework-bulk/issues/68
This is to prevent an error whereby the DRF Unique validator fails when the instance on the child
serializer is a queryset and not an object.
"""
if html.is_html_input(data):
data = html.parse_html_list(data, default=[])
if not isinstance(data, list):
message = self.error_messages["not_a_list"].format(
input_type=type(data).__name__
)
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]}, code="not_a_list"
)
if not self.allow_empty and len(data) == 0:
message = self.error_messages["empty"]
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]}, code="empty"
)
ret = []
errors = []
data_lookup = self._data_lookup_dict()
for item in data:
try:
# prepare child serializer to only handle one instance
self.child.instance = data_lookup.get(self.child.id_value_lookup(item))
self.child.initial_data = item
validated = self.child.run_validation(item)
except ValidationError as exc:
errors.append(exc.detail)
else:
ret.append(validated)
errors.append({})
if any(errors):
raise ValidationError(errors)
return ret
def to_internal_value(self, data):
"""
List of dicts of native values <- List of dicts of primitive datatypes.
"""
if html.is_html_input(data):
data = html.parse_html_list(data, default=[])
if not isinstance(data, list):
message = self.error_messages['not_a_list'].format(
input_type=type(data).__name__)
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]},
code='not_a_list')
if not self.allow_empty and len(data) == 0:
if self.parent and self.partial:
raise SkipField()
message = self.error_messages['empty']
raise ValidationError(
{api_settings.NON_FIELD_ERRORS_KEY: [message]}, code='empty')
ret = []
errors = []
id_attr = getattr(self.child.Meta, 'update_lookup_field', 'id')
for item in data:
try:
# --------------------- patched pieces --------------------------------
self.child.instance = self.instance.get(
**{id_attr: item.get(id_attr)})
self.child.initial_data = item
# ---------------------------------------------------------------------
validated = self.child.run_validation(item)
except ValidationError as exc:
errors.append(exc.detail)
else:
ret.append(validated)
errors.append({})
if any(errors):
raise ValidationError(errors)
return ret
def validate_field_value(wrapped, instance, args, kwargs):
"""验证字段数据"""
field = args[0]
data = args[1]
if html.is_html_input(data):
if field.field_name not in data:
if getattr(field.root, 'partial', False):
return empty
return field.default_empty_html
ret = wrapped(*args, **kwargs)
if ret == '' and field.allow_null:
return '' if getattr(field, 'allow_blank', False) else None
elif ret == '' and not field.required:
return '' if getattr(field, 'allow_blank', False) else empty
return ret
return wrapped(*args, **kwargs)
def get_value(self, dictionary):
"""
Given the *incoming* primitive data, return the value for this field
that should be validated and transformed to a native value.
"""
if html.is_html_input(dictionary):
# HTML forms will represent empty fields as '', and cannot
# represent None or False values directly.
if self.field_name not in dictionary:
if getattr(self.root, 'partial', False):
return empty
return self.default_empty_html
ret = dictionary[self.field_name]
if ret == '' and self.allow_null:
# If the field is blank, and null is a valid value then
# determine if we should use null instead.
return '' if getattr(self, 'allow_blank', False) else None
return ret
return dictionary.get(self.field_name, empty)
def get_value(self, dictionary):
"""
Given the *incoming* primitive data, return the value for this field
that should be validated and transformed to a native value.
"""
if html.is_html_input(dictionary):
# HTML forms will represent empty fields as '', and cannot
# represent None or False values directly.
if self.field_name not in dictionary:
if getattr(self.root, 'partial', False):
return empty
return self.default_empty_html
ret = dictionary[self.field_name]
if ret == '' and self.allow_null:
# If the field is blank, and null is a valid value then
# determine if we should use null instead.
return '' if getattr(self, 'allow_blank', False) else None
return ret
return dictionary.get(self.field_name, empty)
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 get_value(self, dictionary):
if html.is_html_input(dictionary):
content = dictionary.get(self.field_name, [''])
return [x.strip() for x in content.splitlines() if x.strip()]
return dictionary.get(self.field_name, [])
def get_value(self, dictionary):
# We override the default field access in order to support
# lists in HTML forms.
if html.is_html_input(dictionary):
return dictionary.getlist(self.field_name)
return dictionary.get(self.field_name, empty)
def to_internal_value(self, data):
if html.is_html_input(data):
data = parse_json_form(data)
return super(JSONFormSerializer, self).to_internal_value(data)
def html_safe_get(obj, key, default=None):
if html.is_html_input(obj):
return obj.getlist(key, default)
return obj.get(key, default)
def get_value(self, dictionary):
if html.is_html_input(dictionary):
return dictionary.getlist(self.field_name)
return dictionary.get(self.field_name, None)
