class Serializer
from rest_framework.serializers import Serializer
Ancestors (MRO)
- Serializer
- BaseSerializer
- WritableField
- Field
Descendants
Attributes
Defined in | |
---|---|
Meta = <class 'rest_framework.serializers.Meta'>
|
BaseSerializer |
_dict_class = <class 'rest_framework.serializers.SortedDictWithMetadata'>
|
BaseSerializer |
_options_class = <class 'rest_framework.serializers.SerializerOptions'>
|
BaseSerializer |
base_fields = {}
|
Serializer |
creation_counter = 3
|
Field |
data = <property object at 0x7f5efc8df680>
|
BaseSerializer |
default = None
|
WritableField |
default_error_messages = {u'invalid': <django.utils.functional.__proxy__ object at 0x7f5efc8d53d0>, u'required': <django.utils.functional.__proxy__ object at 0x7f5efc8d5390>}
|
WritableField |
default_validators = []
|
WritableField |
empty =
|
Field |
errors = <property object at 0x7f5efc8df628>
|
BaseSerializer |
errors = <property object at 0x7f5efc8cf470>
|
Field |
form_field_class = <class 'django.forms.fields.CharField'>
|
Field |
partial = False
|
Field |
read_only = True
|
Field |
type_label = field
|
Field |
type_name = None
|
Field |
use_files = False
|
Field |
widget = <class 'django.forms.widgets.TextInput'>
|
WritableField |
widget = None
|
Field |
write_only = False
|
WritableField |
Methods
def
attributes(self):
¶
Field
Returns a dictionary of attributes to be used when serializing to xml.
def attributes(self):
"""
Returns a dictionary of attributes to be used when serializing to xml.
"""
if self.type_name:
return {'type': self.type_name}
return {}
def
augment_field(self, field, field_name, key, value):
¶
BaseSerializer
def augment_field(self, field, field_name, key, value):
# This horrible stuff is to manage serializers rendering to HTML
field._errors = self._errors.get(key) if self._errors else None
field._name = field_name
field._value = self.init_data.get(key) if self._errors and self.init_data else value
if not field.label:
field.label = pretty_name(key)
return field
def
delete_object(self, obj):
¶
BaseSerializer
def delete_object(self, obj):
obj.delete()
def
field_from_native(self, data, files, field_name, into):
¶
BaseSerializer
Override default so that the serializer can be used as a writable nested field across relationships.
def field_from_native(self, data, files, field_name, into):
"""
Override default so that the serializer can be used as a writable
nested field across relationships.
"""
if self.read_only:
return
try:
value = data[field_name]
except KeyError:
if self.default is not None and not self.partial:
# Note: partial updates shouldn't set defaults
value = copy.deepcopy(self.default)
else:
if self.required:
raise ValidationError(self.error_messages['required'])
return
if self.source == '*':
if value:
reverted_data = self.restore_fields(value, {})
if not self._errors:
into.update(reverted_data)
else:
if value in (None, ''):
into[(self.source or field_name)] = None
else:
# Set the serializer object if it exists
obj = get_component(self.parent.object, self.source or field_name) if self.parent.object else None
# If we have a model manager or similar object then we need
# to iterate through each instance.
if (self.many and
not hasattr(obj, '__iter__') and
is_simple_callable(getattr(obj, 'all', None))):
obj = obj.all()
kwargs = {
'instance': obj,
'data': value,
'context': self.context,
'partial': self.partial,
'many': self.many,
'allow_add_remove': self.allow_add_remove
}
serializer = self.__class__(**kwargs)
if serializer.is_valid():
into[self.source or field_name] = serializer.object
else:
# Propagate errors up to our parent
raise NestedValidationError(serializer.errors)
WritableField
Given a dictionary and a field name, updates the dictionary `into`, with the field and it's deserialized value.
def field_from_native(self, data, files, field_name, into):
"""
Given a dictionary and a field name, updates the dictionary `into`,
with the field and it's deserialized value.
"""
if self.read_only:
return
try:
data = data or {}
if self.use_files:
files = files or {}
try:
native = files[field_name]
except KeyError:
native = data[field_name]
else:
native = data[field_name]
except KeyError:
if self.default is not None and not self.partial:
# Note: partial updates shouldn't set defaults
native = self.get_default_value()
else:
if self.required:
raise ValidationError(self.error_messages['required'])
return
value = self.from_native(native)
if self.source == '*':
if value:
into.update(value)
else:
self.validate(value)
self.run_validators(value)
into[self.source or field_name] = value
Field
Given a dictionary and a field name, updates the dictionary `into`, with the field and it's deserialized value.
def field_from_native(self, data, files, field_name, into):
"""
Given a dictionary and a field name, updates the dictionary `into`,
with the field and it's deserialized value.
"""
return
def
field_to_native(self, obj, field_name):
¶
BaseSerializer
Override default so that the serializer can be used as a nested field across relationships.
def field_to_native(self, obj, field_name):
"""
Override default so that the serializer can be used as a nested field
across relationships.
"""
if self.write_only:
return None
if self.source == '*':
return self.to_native(obj)
# Get the raw field value
try:
source = self.source or field_name
value = obj
for component in source.split('.'):
if value is None:
break
value = get_component(value, component)
except ObjectDoesNotExist:
return None
if is_simple_callable(getattr(value, 'all', None)):
return [self.to_native(item) for item in value.all()]
if value is None:
return None
if self.many is not None:
many = self.many
else:
many = hasattr(value, '__iter__') and not isinstance(value, (Page, dict, six.text_type))
if many:
return [self.to_native(item) for item in value]
return self.to_native(value)
WritableField
def field_to_native(self, obj, field_name):
if self.write_only:
return None
return super(WritableField, self).field_to_native(obj, field_name)
Field
Given and object and a field name, returns the value that should be serialized for that field.
def field_to_native(self, obj, field_name):
"""
Given and object and a field name, returns the value that should be
serialized for that field.
"""
if obj is None:
return self.empty
if self.source == '*':
return self.to_native(obj)
source = self.source or field_name
value = obj
for component in source.split('.'):
value = get_component(value, component)
if value is None:
break
return self.to_native(value)
def
from_native(self, data, files=None):
¶
BaseSerializer
Deserialize primitives -> objects.
def from_native(self, data, files=None):
"""
Deserialize primitives -> objects.
"""
self._errors = {}
if data is not None or files is not None:
attrs = self.restore_fields(data, files)
if attrs is not None:
attrs = self.perform_validation(attrs)
else:
self._errors['non_field_errors'] = ['No input provided']
if not self._errors:
return self.restore_object(attrs, instance=getattr(self, 'object', None))
WritableField
Reverts a simple representation back to the field's value.
def from_native(self, value):
"""
Reverts a simple representation back to the field's value.
"""
return value
def
get_default_fields(self):
¶
BaseSerializer
Return the complete set of default fields for the object, as a dict.
def get_default_fields(self):
"""
Return the complete set of default fields for the object, as a dict.
"""
return {}
def
get_default_value(self):
¶
WritableField
def get_default_value(self):
if is_simple_callable(self.default):
return self.default()
return self.default
def
get_field_key(self, field_name):
¶
BaseSerializer
Return the key that should be used for a given field.
def get_field_key(self, field_name):
"""
Return the key that should be used for a given field.
"""
return field_name
def
get_fields(self):
¶
BaseSerializer
Returns the complete set of fields for the object as a dict. This will be the set of any explicitly declared fields, plus the set of fields returned by get_default_fields().
def get_fields(self):
"""
Returns the complete set of fields for the object as a dict.
This will be the set of any explicitly declared fields,
plus the set of fields returned by get_default_fields().
"""
ret = SortedDict()
# Get the explicitly declared fields
base_fields = copy.deepcopy(self.base_fields)
for key, field in base_fields.items():
ret[key] = field
# Add in the default fields
default_fields = self.get_default_fields()
for key, val in default_fields.items():
if key not in ret:
ret[key] = val
# If 'fields' is specified, use those fields, in that order.
if self.opts.fields:
assert isinstance(self.opts.fields, (list, tuple)), '`fields` must be a list or tuple'
new = SortedDict()
for key in self.opts.fields:
new[key] = ret[key]
ret = new
# Remove anything in 'exclude'
if self.opts.exclude:
assert isinstance(self.opts.exclude, (list, tuple)), '`exclude` must be a list or tuple'
for key in self.opts.exclude:
ret.pop(key, None)
for key, field in ret.items():
field.initialize(parent=self, field_name=key)
return ret
def
get_identity(self, data):
¶
BaseSerializer
This hook is required for bulk update. It is used to determine the canonical identity of a given object. Note that the data has not been validated at this point, so we need to make sure that we catch any cases of incorrect datatypes being passed to this method.
def get_identity(self, data):
"""
This hook is required for bulk update.
It is used to determine the canonical identity of a given object.
Note that the data has not been validated at this point, so we need
to make sure that we catch any cases of incorrect datatypes being
passed to this method.
"""
try:
return data.get('id', None)
except AttributeError:
return None
def
initialize(self, parent, field_name):
¶
Field
Called to set up a field prior to field_to_native or field_from_native. parent - The parent serializer. field_name - The name of the field being initialized.
def initialize(self, parent, field_name):
"""
Called to set up a field prior to field_to_native or field_from_native.
parent - The parent serializer.
field_name - The name of the field being initialized.
"""
self.parent = parent
self.root = parent.root or parent
self.context = self.root.context
self.partial = self.root.partial
if self.partial:
self.required = False
def
is_valid(self):
¶
BaseSerializer
def is_valid(self):
return not self.errors
def
label_tag(self):
¶
Field
def label_tag(self):
return '<label for="%s">%s:</label>' % (self._name, self.label)
def
metadata(self):
¶
BaseSerializer
Return a dictionary of metadata about the fields on the serializer. Useful for things like responding to OPTIONS requests, or generating API schemas for auto-documentation.
def metadata(self):
"""
Return a dictionary of metadata about the fields on the serializer.
Useful for things like responding to OPTIONS requests, or generating
API schemas for auto-documentation.
"""
return SortedDict(
[(field_name, field.metadata())
for field_name, field in six.iteritems(self.fields)]
)
Field
def metadata(self):
metadata = SortedDict()
metadata['type'] = self.type_label
metadata['required'] = getattr(self, 'required', False)
optional_attrs = ['read_only', 'label', 'help_text',
'min_length', 'max_length']
for attr in optional_attrs:
value = getattr(self, attr, None)
if value is not None and value != '':
metadata[attr] = force_text(value, strings_only=True)
return metadata
def
perform_validation(self, attrs):
¶
BaseSerializer
Run `validate_()` and `validate()` methods on the serializer
def perform_validation(self, attrs):
"""
Run `validate_<fieldname>()` and `validate()` methods on the serializer
"""
for field_name, field in self.fields.items():
if field_name in self._errors:
continue
source = field.source or field_name
if self.partial and source not in attrs:
continue
try:
validate_method = getattr(self, 'validate_%s' % field_name, None)
if validate_method:
attrs = validate_method(attrs, source)
except ValidationError as err:
self._errors[field_name] = self._errors.get(field_name, []) + list(err.messages)
# If there are already errors, we don't run .validate() because
# field-validation failed and thus `attrs` may not be complete.
# which in turn can cause inconsistent validation errors.
if not self._errors:
try:
attrs = self.validate(attrs)
except ValidationError as err:
if hasattr(err, 'message_dict'):
for field_name, error_messages in err.message_dict.items():
self._errors[field_name] = self._errors.get(field_name, []) + list(error_messages)
elif hasattr(err, 'messages'):
self._errors['non_field_errors'] = err.messages
return attrs
def
restore_fields(self, data, files):
¶
BaseSerializer
Core of deserialization, together with `restore_object`. Converts a dictionary of data into a dictionary of deserialized fields.
def restore_fields(self, data, files):
"""
Core of deserialization, together with `restore_object`.
Converts a dictionary of data into a dictionary of deserialized fields.
"""
reverted_data = {}
if data is not None and not isinstance(data, dict):
self._errors['non_field_errors'] = ['Invalid data']
return None
for field_name, field in self.fields.items():
field.initialize(parent=self, field_name=field_name)
try:
field.field_from_native(data, files, field_name, reverted_data)
except ValidationError as err:
self._errors[field_name] = list(err.messages)
return reverted_data
def
restore_object(self, attrs, instance=None):
¶
BaseSerializer
Deserialize a dictionary of attributes into an object instance. You should override this method to control how deserialized objects are instantiated.
def restore_object(self, attrs, instance=None):
"""
Deserialize a dictionary of attributes into an object instance.
You should override this method to control how deserialized objects
are instantiated.
"""
if instance is not None:
instance.update(attrs)
return instance
return attrs
def
run_validators(self, value):
¶
WritableField
def run_validators(self, value):
if value in validators.EMPTY_VALUES:
return
errors = []
for v in self.validators:
try:
v(value)
except ValidationError as e:
if hasattr(e, 'code') and e.code in self.error_messages:
message = self.error_messages[e.code]
if e.params:
message = message % e.params
errors.append(message)
else:
errors.extend(e.messages)
if errors:
raise ValidationError(errors)
def
save(self, **kwargs):
¶
BaseSerializer
Save the deserialized object and return it.
def save(self, **kwargs):
"""
Save the deserialized object and return it.
"""
# Clear cached _data, which may be invalidated by `save()`
self._data = None
if isinstance(self.object, list):
[self.save_object(item, **kwargs) for item in self.object]
if self.object._deleted:
[self.delete_object(item) for item in self.object._deleted]
else:
self.save_object(self.object, **kwargs)
return self.object
def
save_object(self, obj, **kwargs):
¶
BaseSerializer
def save_object(self, obj, **kwargs):
obj.save(**kwargs)
def
to_native(self, obj):
¶
BaseSerializer
Serialize objects -> primitives.
def to_native(self, obj):
"""
Serialize objects -> primitives.
"""
ret = self._dict_class()
ret.fields = self._dict_class()
for field_name, field in self.fields.items():
if field.read_only and obj is None:
continue
field.initialize(parent=self, field_name=field_name)
key = self.get_field_key(field_name)
value = field.field_to_native(obj, field_name)
method = getattr(self, 'transform_%s' % field_name, None)
if callable(method):
value = method(obj, value)
if not getattr(field, 'write_only', False):
ret[key] = value
ret.fields[key] = self.augment_field(field, field_name, key, value)
return ret
Field
Converts the field's value into it's simple representation.
def to_native(self, value):
"""
Converts the field's value into it's simple representation.
"""
if is_simple_callable(value):
value = value()
if is_protected_type(value):
return value
elif (is_non_str_iterable(value) and
not isinstance(value, (dict, six.string_types))):
return [self.to_native(item) for item in value]
elif isinstance(value, dict):
# Make sure we preserve field ordering, if it exists
ret = SortedDict()
for key, val in value.items():
ret[key] = self.to_native(val)
return ret
return force_text(value)
def
validate(self, attrs):
¶
BaseSerializer
Stub method, to be overridden in Serializer subclasses
def validate(self, attrs):
"""
Stub method, to be overridden in Serializer subclasses
"""
return attrs
WritableField
def validate(self, value):
if value in validators.EMPTY_VALUES and self.required:
raise ValidationError(self.error_messages['required'])
def
widget_html(self):
¶
Field
def widget_html(self):
if not self.widget:
return ''
attrs = {}
if 'id' not in self.widget.attrs:
attrs['id'] = self._name
return self.widget.render(self._name, self._value, attrs=attrs)