class Serializer

from rest_framework.serializers import Serializer

Ancestors (MRO)

  1. Serializer
  2. BaseSerializer
  3. Field

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
_use_files = None Field
base_fields = {} Serializer
creation_counter = 4 Field
data = <property object at 0x1089b42b8> BaseSerializer
empty = Field
errors = <property object at 0x1089b4260> BaseSerializer
form_field_class = <class 'django.forms.fields.CharField'> Field
read_only = True Field
type_name = None Field
Expand Collapse

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 convert_object(self, obj): BaseSerializer

        Core of serialization.
        Convert an object into a dictionary of serialized field values.
        
    def convert_object(self, obj):
        """
        Core of serialization.
        Convert an object into a dictionary of serialized field values.
        """
        ret = self._dict_class()
        ret.fields = {}

        for field_name, field in self.fields.items():
            field.initialize(parent=self, field_name=field_name)
            key = self.get_field_key(field_name)
            value = field.field_to_native(obj, field_name)
            ret[key] = value
            ret.fields[key] = field
        return ret

def field_from_native(self, data, files, field_name, into): 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 we can apply ModelSerializer as a nested
        field to relationships.
        
    def field_to_native(self, obj, field_name):
        """
        Override default so that we can apply ModelSerializer as a nested
        field to relationships.
        """
        if self.source == '*':
            return self.to_native(obj)

        try:
            if self.source:
                for component in self.source.split('.'):
                    obj = getattr(obj, component)
                    if is_simple_callable(obj):
                        obj = obj()
            else:
                obj = getattr(obj, field_name)
                if is_simple_callable(obj):
                    obj = obj()
        except ObjectDoesNotExist:
            return None

        # If the object has an "all" method, assume it's a relationship
        if is_simple_callable(getattr(obj, 'all', None)):
            return [self.to_native(item) for item in obj.all()]

        if obj is None:
            return None

        return self.to_native(obj)

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)

        if self.source:
            value = obj
            for component in self.source.split('.'):
                value = getattr(value, component)
                if is_simple_callable(value):
                    value = value()
        else:
            value = getattr(obj, field_name)
        return self.to_native(value)

def from_native(self, data, files): BaseSerializer

        Deserialize primitives -> objects.
        
    def from_native(self, data, files):
        """
        Deserialize primitives -> objects.
        """
        if hasattr(data, '__iter__') and not isinstance(data, dict):
            # TODO: error data when deserializing lists
            return [self.from_native(item, None) for item in data]

        self._errors = {}
        if data is not None or files is not None:
            attrs = self.restore_fields(data, files)
            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))

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_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:
            new = SortedDict()
            for key in self.opts.fields:
                new[key] = ret[key]
            ret = new

        # Remove anything in 'exclude'
        if self.opts.exclude:
            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 initialize(self, parent, field_name):

BaseSerializer

        Same behaviour as usual Field, except that we need to keep track
        of state so that we can deal with handling maximum depth.
        
    def initialize(self, parent, field_name):
        """
        Same behaviour as usual Field, except that we need to keep track
        of state so that we can deal with handling maximum depth.
        """
        super(BaseSerializer, self).initialize(parent, field_name)
        if parent.opts.depth:
            self.opts.depth = parent.opts.depth - 1

Field

        Called to set up a field prior to field_to_native or field_from_native.

        parent - The parent serializer.
        model_field - The model field this field corresponds to, if one exists.
        
    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.
        model_field - The model field this field corresponds to, if one exists.
        """
        self.parent = parent
        self.root = parent.root or parent
        self.context = self.root.context
        if self.root.partial:
            self.required = False

def is_valid(self): BaseSerializer

    def is_valid(self):
        return not self.errors

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
            try:
                validate_method = getattr(self, 'validate_%s' % field_name, None)
                if validate_method:
                    source = field.source or field_name
                    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'] = [u'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 save(self): BaseSerializer

        Save the deserialized object and return it.
        
    def save(self):
        """
        Save the deserialized object and return it.
        """
        self.object.save()
        return self.object

def to_native(self, obj):

BaseSerializer

        Serialize objects -> primitives.
        
    def to_native(self, obj):
        """
        Serialize objects -> primitives.
        """
        # Note: At the moment we have an ugly hack to determine if we should
        # walk over iterables.  At some point, serializers will require an
        # explicit `many=True` in order to iterate over a set, and this hack
        # will disappear.
        if hasattr(obj, '__iter__') and not isinstance(obj, Page):
            return [self.convert_object(item) for item in obj]
        return self.convert_object(obj)

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 hasattr(value, '__iter__') and not isinstance(value, (dict, basestring)):
            return [self.to_native(item) for item in value]
        elif isinstance(value, dict):
            return dict(map(self.to_native, (k, v)) for k, v in value.items())
        return smart_unicode(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