mirror of
https://github.com/encode/django-rest-framework.git
synced 2024-09-21 19:39:01 +03:00
279 lines
9.5 KiB
Markdown
279 lines
9.5 KiB
Markdown
<a class="github" href="fields.py"></a>
|
|
|
|
# Serializer fields
|
|
|
|
> Flat is better than nested.
|
|
>
|
|
> — [The Zen of Python][cite]
|
|
|
|
Serializer fields handle converting between primative values and internal datatypes. They also deal with validating input values, as well as retrieving and setting the values from their parent objects.
|
|
|
|
---
|
|
|
|
**Note:** The serializer fields are declared in fields.py, but by convention you should import them using `from rest_framework import serializers` and refer to fields as `serializers.<FieldName>`.
|
|
|
|
---
|
|
|
|
## Core arguments
|
|
|
|
Each serializer field class constructor takes at least these arguments. Some Field classes take additional, field-specific arguments, but the following should always be accepted:
|
|
|
|
### `source`
|
|
|
|
The name of the attribute that will be used to populate the field. May be a method that only takes a `self` argument, such as `Field(source='get_absolute_url')`, or may use dotted notation to traverse attributes, such as `Field(source='user.email')`.
|
|
|
|
The value `source='*'` has a special meaning, and is used to indicate that the entire object should be passed through to the field. This can be useful for creating nested representations. (See the implementation of the `PaginationSerializer` class for an example.)
|
|
|
|
Defaults to the name of the field.
|
|
|
|
### `read_only`
|
|
|
|
Set this to `True` to ensure that the field is used when serializing a representation, but is not used when updating an instance dureing deserialization.
|
|
|
|
Defaults to `False`
|
|
|
|
### `required`
|
|
|
|
Normally an error will be raised if a field is not supplied during deserialization.
|
|
Set to false if this field is not required to be present during deserialization.
|
|
|
|
Defaults to `True`.
|
|
|
|
### `default`
|
|
|
|
If set, this gives the default value that will be used for the field if none is supplied. If not set the default behaviour is to not populate the attribute at all.
|
|
|
|
### `validators`
|
|
|
|
A list of Django validators that should be used to validate deserialized values.
|
|
|
|
### `error_messages`
|
|
|
|
A dictionary of error codes to error messages.
|
|
|
|
### `widget`
|
|
|
|
Used only if rendering the field to HTML.
|
|
This argument sets the widget that should be used to render the field.
|
|
|
|
|
|
---
|
|
|
|
# Generic Fields
|
|
|
|
These generic fields are used for representing arbitrary model fields or the output of model methods.
|
|
|
|
## Field
|
|
|
|
A generic, **read-only** field. You can use this field for any attribute that does not need to support write operations.
|
|
|
|
For example, using the following model.
|
|
|
|
class Account(models.Model):
|
|
owner = models.ForeignKey('auth.user')
|
|
name = models.CharField(max_length=100)
|
|
created = models.DateTimeField(auto_now_add=True)
|
|
payment_expiry = models.DateTimeField()
|
|
|
|
def has_expired(self):
|
|
now = datetime.datetime.now()
|
|
return now > self.payment_expiry
|
|
|
|
A serializer definition that looked like this:
|
|
|
|
class AccountSerializer(serializers.HyperlinkedModelSerializer):
|
|
expired = Field(source='has_expired')
|
|
|
|
class Meta:
|
|
fields = ('url', 'owner', 'name', 'expired')
|
|
|
|
Would produce output similar to:
|
|
|
|
{
|
|
'url': 'http://example.com/api/accounts/3/',
|
|
'owner': 'http://example.com/api/users/12/',
|
|
'name': 'FooCorp business account',
|
|
'expired': True
|
|
}
|
|
|
|
By default, the `Field` class will perform a basic translation of the source value into primative datatypes, falling back to unicode representations of complex datatypes when necessary.
|
|
|
|
You can customize this behaviour by overriding the `.to_native(self, value)` method.
|
|
|
|
## WritableField
|
|
|
|
A field that supports both read and write operations. By itself `WriteableField` does not perform any translation of input values into a given type. You won't typically use this field directly, but you may want to override it and implement the `.to_native(self, value)` and `.from_native(self, value)` methods.
|
|
|
|
## ModelField
|
|
|
|
A generic field that can be tied to any arbitrary model field. The `ModelField` class delegates the task of serialization/deserialization to it's associated model field. This field can be used to create serializer fields for custom model fields, without having to create a new custom serializer field.
|
|
|
|
**Signature:** `ModelField(model_field=<Django ModelField class>)`
|
|
|
|
---
|
|
|
|
# Typed Fields
|
|
|
|
These fields represent basic datatypes, and support both reading and writing values.
|
|
|
|
## BooleanField
|
|
|
|
A Boolean representation.
|
|
|
|
Corresponds to `django.db.models.fields.BooleanField`.
|
|
|
|
## CharField
|
|
|
|
A text representation, optionally validates the text to be shorter than `max_length` and longer than `min_length`.
|
|
|
|
Corresponds to `django.db.models.fields.CharField`
|
|
or `django.db.models.fields.TextField`.
|
|
|
|
**Signature:** `CharField(max_length=None, min_length=None)`
|
|
|
|
## ChoiceField
|
|
|
|
A field that can accept a value out of a limited set of choices.
|
|
|
|
## EmailField
|
|
|
|
A text representation, validates the text to be a valid e-mail address.
|
|
|
|
Corresponds to `django.db.models.fields.EmailField`
|
|
|
|
## DateField
|
|
|
|
A date representation.
|
|
|
|
Corresponds to `django.db.models.fields.DateField`
|
|
|
|
## DateTimeField
|
|
|
|
A date and time representation.
|
|
|
|
Corresponds to `django.db.models.fields.DateTimeField`
|
|
|
|
## IntegerField
|
|
|
|
An integer representation.
|
|
|
|
Corresponds to `django.db.models.fields.IntegerField`, `django.db.models.fields.SmallIntegerField`, `django.db.models.fields.PositiveIntegerField` and `django.db.models.fields.PositiveSmallIntegerField`
|
|
|
|
## FloatField
|
|
|
|
A floating point representation.
|
|
|
|
Corresponds to `django.db.models.fields.FloatField`.
|
|
|
|
---
|
|
|
|
# Relational Fields
|
|
|
|
Relational fields are used to represent model relationships. They can be applied to `ForeignKey`, `ManyToManyField` and `OneToOneField` relationships, as well as to reverse relationships, and custom relationships such as `GenericForeignKey`.
|
|
|
|
## RelatedField
|
|
|
|
This field can be applied to any of the following:
|
|
|
|
* A `ForeignKey` field.
|
|
* A `OneToOneField` field.
|
|
* A reverse OneToOne relationship
|
|
* Any other "to-one" relationship.
|
|
|
|
By default `RelatedField` will represent the target of the field using it's `__unicode__` method.
|
|
|
|
You can customise this behaviour by subclassing `ManyRelatedField`, and overriding the `.to_native(self, value)` method.
|
|
|
|
## ManyRelatedField
|
|
|
|
This field can be applied to any of the following:
|
|
|
|
* A `ManyToManyField` field.
|
|
* A reverse ManyToMany relationship.
|
|
* A reverse ForeignKey relationship
|
|
* Any other "to-many" relationship.
|
|
|
|
By default `ManyRelatedField` will represent the targets of the field using their `__unicode__` method.
|
|
|
|
For example, given the following models:
|
|
|
|
class TaggedItem(models.Model):
|
|
"""
|
|
Tags arbitrary model instances using a generic relation.
|
|
|
|
See: https://docs.djangoproject.com/en/dev/ref/contrib/contenttypes/
|
|
"""
|
|
tag = models.SlugField()
|
|
content_type = models.ForeignKey(ContentType)
|
|
object_id = models.PositiveIntegerField()
|
|
content_object = GenericForeignKey('content_type', 'object_id')
|
|
|
|
def __unicode__(self):
|
|
return self.tag
|
|
|
|
|
|
class Bookmark(models.Model):
|
|
"""
|
|
A bookmark consists of a URL, and 0 or more descriptive tags.
|
|
"""
|
|
url = models.URLField()
|
|
tags = GenericRelation(TaggedItem)
|
|
|
|
And a model serializer defined like this:
|
|
|
|
class BookmarkSerializer(serializers.ModelSerializer):
|
|
tags = serializers.ManyRelatedField(source='tags')
|
|
|
|
class Meta:
|
|
model = Bookmark
|
|
exclude = ('id',)
|
|
|
|
Then an example output format for a Bookmark instance would be:
|
|
|
|
{
|
|
'tags': [u'django', u'python'],
|
|
'url': u'https://www.djangoproject.com/'
|
|
}
|
|
|
|
## PrimaryKeyRelatedField
|
|
|
|
This field can be applied to any "to-one" relationship, such as a `ForeignKey` field.
|
|
|
|
`PrimaryKeyRelatedField` will represent the target of the field using it's primary key.
|
|
|
|
Be default, `PrimaryKeyRelatedField` is read-write, although you can change this behaviour using the `read_only` flag.
|
|
|
|
## ManyPrimaryKeyRelatedField
|
|
|
|
This field can be applied to any "to-many" relationship, such as a `ManyToManyField` field, or a reverse `ForeignKey` relationship.
|
|
|
|
`PrimaryKeyRelatedField` will represent the targets of the field using their primary key.
|
|
|
|
Be default, `ManyPrimaryKeyRelatedField` is read-write, although you can change this behaviour using the `read_only` flag.
|
|
|
|
## HyperlinkedRelatedField
|
|
|
|
This field can be applied to any "to-one" relationship, such as a `ForeignKey` field.
|
|
|
|
`HyperlinkedRelatedField` will represent the target of the field using a hyperlink. You must include a named URL pattern in your URL conf, with a name like `'{model-name}-detail'` that corresponds to the target of the hyperlink.
|
|
|
|
Be default, `HyperlinkedRelatedField` is read-write, although you can change this behaviour using the `read_only` flag.
|
|
|
|
## ManyHyperlinkedRelatedField
|
|
|
|
This field can be applied to any "to-many" relationship, such as a `ManyToManyField` field, or a reverse `ForeignKey` relationship.
|
|
|
|
`ManyHyperlinkedRelatedField` will represent the targets of the field using hyperlinks. You must include a named URL pattern in your URL conf, with a name like `'{model-name}-detail'` that corresponds to the target of the hyperlink.
|
|
|
|
Be default, `ManyHyperlinkedRelatedField` is read-write, although you can change this behaviour using the `read_only` flag.
|
|
|
|
## HyperLinkedIdentityField
|
|
|
|
This field can be applied as an identity relationship, such as the `'url'` field on a HyperlinkedModelSerializer.
|
|
|
|
You must include a named URL pattern in your URL conf, with a name like `'{model-name}-detail'` that corresponds to the model.
|
|
|
|
This field is always read-only.
|
|
|
|
[cite]: http://www.python.org/dev/peps/pep-0020/
|