class WritableField

from rest_framework.fields import WritableField
Documentation Source code
    Base for read/write fields.
    

Ancestors (MRO)

  1. WritableField
  2. Field

Attributes

  Defined in
creation_counter = 4 Field
default = None WritableField
default_error_messages = {u'invalid': <django.utils.functional.__proxy__ object at 0x7febe7e1ced0>, u'required': <django.utils.functional.__proxy__ object at 0x7febe7e1ce90>} WritableField
default_validators = [] WritableField
empty = Field
form_field_class = <class 'django.forms.fields.CharField'> Field
partial = False Field
read_only = True Field
type_name = None Field
use_files = False Field
widget = <class 'django.forms.widgets.TextInput'> WritableField
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 field_from_native(self, data, files, field_name, into):

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:
            if self.use_files:
                files = files or {}
                native = files[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.default
            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): 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, value): 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 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.
        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
        self.partial = self.root.partial
        if self.partial:
            self.required = False

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 to_native(self, value): 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, six.string_types)):
            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_text(value)

def validate(self, value): WritableField

    def validate(self, value):
        if value in validators.EMPTY_VALUES and self.required:
            raise ValidationError(self.error_messages['required'])