mirror of
https://github.com/encode/django-rest-framework.git
synced 2024-11-26 19:43:59 +03:00
717 lines
48 KiB
HTML
717 lines
48 KiB
HTML
<!DOCTYPE html>
|
||
<html lang="en">
|
||
<head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
|
||
<meta charset="utf-8">
|
||
<title>Serializers - Django REST framework</title>
|
||
<link href="http://www.django-rest-framework.org/img/favicon.ico" rel="icon" type="image/x-icon">
|
||
<link rel="canonical" href="http://www.django-rest-framework.org/api-guide/serializers"/>
|
||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||
<meta name="description" content="Django, API, REST, Serializers, ModelSerializer, HyperlinkedModelSerializer, Advanced serializer usage, Third party packages">
|
||
<meta name="author" content="Tom Christie">
|
||
|
||
<!-- Le styles -->
|
||
<link href="http://www.django-rest-framework.org/css/prettify.css" rel="stylesheet">
|
||
<link href="http://www.django-rest-framework.org/css/bootstrap.css" rel="stylesheet">
|
||
<link href="http://www.django-rest-framework.org/css/bootstrap-responsive.css" rel="stylesheet">
|
||
<link href="http://www.django-rest-framework.org/css/default.css" rel="stylesheet">
|
||
|
||
<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
|
||
<!--[if lt IE 9]>
|
||
<script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
|
||
<![endif]-->
|
||
|
||
<script type="text/javascript">
|
||
|
||
var _gaq = _gaq || [];
|
||
_gaq.push(['_setAccount', 'UA-18852272-2']);
|
||
_gaq.push(['_trackPageview']);
|
||
|
||
(function() {
|
||
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
|
||
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
|
||
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
|
||
})();
|
||
|
||
</script>
|
||
<style>
|
||
span.fusion-wrap a {
|
||
display: block;
|
||
margin-top: 10px;
|
||
color: black;
|
||
}
|
||
|
||
a.fusion-poweredby {
|
||
display: block;
|
||
margin-top: 10px;
|
||
}
|
||
@media (max-width: 767px) {
|
||
div.promo {display: none;}
|
||
}
|
||
</style>
|
||
</head>
|
||
<body onload="prettyPrint()" class="serializers-page">
|
||
|
||
<div class="wrapper">
|
||
|
||
<div class="navbar navbar-inverse navbar-fixed-top">
|
||
<div class="navbar-inner">
|
||
<div class="container-fluid">
|
||
<a class="repo-link btn btn-primary btn-small" href="https://github.com/tomchristie/django-rest-framework/tree/master">GitHub</a>
|
||
<a class="repo-link btn btn-inverse btn-small " href="../api-guide/fields">Next <i class="icon-arrow-right icon-white"></i></a>
|
||
<a class="repo-link btn btn-inverse btn-small " href="../api-guide/renderers"><i class="icon-arrow-left icon-white"></i> Previous</a>
|
||
<a class="repo-link btn btn-inverse btn-small" href="#searchModal" data-toggle="modal"><i class="icon-search icon-white"></i> Search</a>
|
||
<a class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
|
||
<span class="icon-bar"></span>
|
||
<span class="icon-bar"></span>
|
||
<span class="icon-bar"></span>
|
||
</a>
|
||
<a class="brand" href="http://www.django-rest-framework.org">Django REST framework</a>
|
||
<div class="nav-collapse collapse">
|
||
<ul class="nav">
|
||
<li><a href="http://www.django-rest-framework.org">Home</a></li>
|
||
<li class="dropdown">
|
||
<a href="#" class="dropdown-toggle" data-toggle="dropdown">Tutorial <b class="caret"></b></a>
|
||
<ul class="dropdown-menu">
|
||
<li><a href="http://www.django-rest-framework.org/tutorial/quickstart">Quickstart</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/tutorial/1-serialization">1 - Serialization</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/tutorial/2-requests-and-responses">2 - Requests and responses</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/tutorial/3-class-based-views">3 - Class based views</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/tutorial/4-authentication-and-permissions">4 - Authentication and permissions</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/tutorial/5-relationships-and-hyperlinked-apis">5 - Relationships and hyperlinked APIs</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/tutorial/6-viewsets-and-routers">6 - Viewsets and routers</a></li>
|
||
</ul>
|
||
</li>
|
||
<li class="dropdown">
|
||
<a href="#" class="dropdown-toggle" data-toggle="dropdown">API Guide <b class="caret"></b></a>
|
||
<ul class="dropdown-menu">
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/requests">Requests</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/responses">Responses</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/views">Views</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/generic-views">Generic views</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/viewsets">Viewsets</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/routers">Routers</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/parsers">Parsers</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/renderers">Renderers</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/serializers">Serializers</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/fields">Serializer fields</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/relations">Serializer relations</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/authentication">Authentication</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/permissions">Permissions</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/throttling">Throttling</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/filtering">Filtering</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/pagination">Pagination</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/content-negotiation">Content negotiation</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/format-suffixes">Format suffixes</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/reverse">Returning URLs</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/exceptions">Exceptions</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/status-codes">Status codes</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/testing">Testing</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/api-guide/settings">Settings</a></li>
|
||
</ul>
|
||
</li>
|
||
<li class="dropdown">
|
||
<a href="#" class="dropdown-toggle" data-toggle="dropdown">Topics <b class="caret"></b></a>
|
||
<ul class="dropdown-menu">
|
||
<li><a href="http://www.django-rest-framework.org/topics/documenting-your-api">Documenting your API</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/ajax-csrf-cors">AJAX, CSRF & CORS</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/browser-enhancements">Browser enhancements</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/browsable-api">The Browsable API</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/rest-hypermedia-hateoas">REST, Hypermedia & HATEOAS</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/contributing">Contributing to REST framework</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/rest-framework-2-announcement">2.0 Announcement</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/2.2-announcement">2.2 Announcement</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/2.3-announcement">2.3 Announcement</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/kickstarter-announcement">Kickstarter Announcement</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/release-notes">Release Notes</a></li>
|
||
<li><a href="http://www.django-rest-framework.org/topics/credits">Credits</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
<ul class="nav pull-right">
|
||
<!-- TODO
|
||
<li class="dropdown">
|
||
<a href="#" class="dropdown-toggle" data-toggle="dropdown">Version: 2.0.0 <b class="caret"></b></a>
|
||
<ul class="dropdown-menu">
|
||
<li><a href="#">Trunk</a></li>
|
||
<li><a href="#">2.0.0</a></li>
|
||
</ul>
|
||
</li>
|
||
-->
|
||
</ul>
|
||
</div><!--/.nav-collapse -->
|
||
</div>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="body-content">
|
||
<div class="container-fluid">
|
||
|
||
<!-- Search Modal -->
|
||
<div id="searchModal" class="modal hide fade" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
|
||
<div class="modal-header">
|
||
<button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
|
||
<h3 id="myModalLabel">Documentation search</h3>
|
||
</div>
|
||
<div class="modal-body">
|
||
<!-- Custom google search -->
|
||
<script>
|
||
(function() {
|
||
var cx = '015016005043623903336:rxraeohqk6w';
|
||
var gcse = document.createElement('script');
|
||
gcse.type = 'text/javascript';
|
||
gcse.async = true;
|
||
gcse.src = (document.location.protocol == 'https:' ? 'https:' : 'http:') +
|
||
'//www.google.com/cse/cse.js?cx=' + cx;
|
||
var s = document.getElementsByTagName('script')[0];
|
||
s.parentNode.insertBefore(gcse, s);
|
||
})();
|
||
</script>
|
||
<gcse:search></gcse:search>
|
||
</div>
|
||
<div class="modal-footer">
|
||
<button class="btn" data-dismiss="modal" aria-hidden="true">Close</button>
|
||
</div>
|
||
</div>
|
||
|
||
<div class="row-fluid">
|
||
|
||
<div class="span3">
|
||
<!-- TODO
|
||
<p style="margin-top: -12px">
|
||
<a class="btn btn-mini btn-primary" style="width: 60px">« previous</a>
|
||
<a class="btn btn-mini btn-primary" style="float: right; margin-right: 8px; width: 60px;">next »</a>
|
||
</p>
|
||
-->
|
||
<div id="table-of-contents">
|
||
<ul class="nav nav-list side-nav well sidebar-nav-fixed">
|
||
<li class="main"><a href="#serializers">Serializers</a></li>
|
||
<li><a href="#declaring-serializers">Declaring Serializers</a></li>
|
||
<li><a href="#serializing-objects">Serializing objects</a></li>
|
||
<li><a href="#deserializing-objects">Deserializing objects</a></li>
|
||
<li><a href="#validation">Validation</a></li>
|
||
<li><a href="#saving-object-state">Saving object state</a></li>
|
||
<li><a href="#dealing-with-nested-objects">Dealing with nested objects</a></li>
|
||
<li><a href="#dealing-with-multiple-objects">Dealing with multiple objects</a></li>
|
||
<li><a href="#including-extra-context">Including extra context</a></li>
|
||
<li class="main"><a href="#modelserializer">ModelSerializer</a></li>
|
||
<li><a href="#specifying-which-fields-should-be-included">Specifying which fields should be included</a></li>
|
||
<li><a href="#specifying-nested-serialization">Specifying nested serialization</a></li>
|
||
<li><a href="#specifying-which-fields-should-be-read-only">Specifying which fields should be read-only</a></li>
|
||
<li><a href="#specifying-which-fields-should-be-write-only">Specifying which fields should be write-only</a></li>
|
||
<li><a href="#specifying-fields-explicitly">Specifying fields explicitly</a></li>
|
||
<li><a href="#relational-fields">Relational fields</a></li>
|
||
<li class="main"><a href="#hyperlinkedmodelserializer">HyperlinkedModelSerializer</a></li>
|
||
<li><a href="#how-hyperlinked-views-are-determined">How hyperlinked views are determined</a></li>
|
||
<li><a href="#overriding-the-url-field-behavior">Overriding the URL field behavior</a></li>
|
||
<li class="main"><a href="#advanced-serializer-usage">Advanced serializer usage</a></li>
|
||
<li><a href="#dynamically-modifying-fields">Dynamically modifying fields</a></li>
|
||
<li><a href="#customising-the-default-fields">Customising the default fields</a></li>
|
||
<li class="main"><a href="#third-party-packages">Third party packages</a></li>
|
||
<li><a href="#mongoenginemodelserializer">MongoengineModelSerializer</a></li>
|
||
<li><a href="#geofeaturemodelserializer">GeoFeatureModelSerializer</a></li>
|
||
<li><a href="#hstoreserializer">HStoreSerializer</a></li>
|
||
|
||
<div class="promo">
|
||
|
||
</div>
|
||
</ul>
|
||
|
||
</div>
|
||
</div>
|
||
|
||
<div id="main-content" class="span9">
|
||
<p><a class="github" href="https://github.com/tomchristie/django-rest-framework/tree/master/rest_framework/serializers.py"><span class="label label-info">serializers.py</span></a></p>
|
||
<h1 id="serializers">Serializers</h1>
|
||
<blockquote>
|
||
<p>Expanding the usefulness of the serializers is something that we would
|
||
like to address. However, it's not a trivial problem, and it
|
||
will take some serious design work.</p>
|
||
<p>— Russell Keith-Magee, <a href="https://groups.google.com/d/topic/django-users/sVFaOfQi4wY/discussion">Django users group</a></p>
|
||
</blockquote>
|
||
<p>Serializers allow complex data such as querysets and model instances to be converted to native Python datatypes that can then be easily rendered into <code>JSON</code>, <code>XML</code> or other content types. Serializers also provide deserialization, allowing parsed data to be converted back into complex types, after first validating the incoming data.</p>
|
||
<p>REST framework's serializers work very similarly to Django's <code>Form</code> and <code>ModelForm</code> classes. It provides a <code>Serializer</code> class which gives you a powerful, generic way to control the output of your responses, as well as a <code>ModelSerializer</code> class which provides a useful shortcut for creating serializers that deal with model instances and querysets.</p>
|
||
<h2 id="declaring-serializers">Declaring Serializers</h2>
|
||
<p>Let's start by creating a simple object we can use for example purposes:</p>
|
||
<pre class="prettyprint lang-py"><code>class Comment(object):
|
||
def __init__(self, email, content, created=None):
|
||
self.email = email
|
||
self.content = content
|
||
self.created = created or datetime.datetime.now()
|
||
|
||
comment = Comment(email='leila@example.com', content='foo bar')
|
||
</code></pre>
|
||
<p>We'll declare a serializer that we can use to serialize and deserialize <code>Comment</code> objects.</p>
|
||
<p>Declaring a serializer looks very similar to declaring a form:</p>
|
||
<pre class="prettyprint lang-py"><code>from rest_framework import serializers
|
||
|
||
class CommentSerializer(serializers.Serializer):
|
||
email = serializers.EmailField()
|
||
content = serializers.CharField(max_length=200)
|
||
created = serializers.DateTimeField()
|
||
|
||
def restore_object(self, attrs, instance=None):
|
||
"""
|
||
Given a dictionary of deserialized field values, either update
|
||
an existing model instance, or create a new model instance.
|
||
"""
|
||
if instance is not None:
|
||
instance.email = attrs.get('email', instance.email)
|
||
instance.content = attrs.get('content', instance.content)
|
||
instance.created = attrs.get('created', instance.created)
|
||
return instance
|
||
return Comment(**attrs)
|
||
</code></pre>
|
||
<p>The first part of serializer class defines the fields that get serialized/deserialized. The <code>restore_object</code> method defines how fully fledged instances get created when deserializing data.</p>
|
||
<p>The <code>restore_object</code> method is optional, and is only required if we want our serializer to support deserialization into fully fledged object instances. If we don't define this method, then deserializing data will simply return a dictionary of items.</p>
|
||
<h2 id="serializing-objects">Serializing objects</h2>
|
||
<p>We can now use <code>CommentSerializer</code> to serialize a comment, or list of comments. Again, using the <code>Serializer</code> class looks a lot like using a <code>Form</code> class.</p>
|
||
<pre class="prettyprint lang-py"><code>serializer = CommentSerializer(comment)
|
||
serializer.data
|
||
# {'email': u'leila@example.com', 'content': u'foo bar', 'created': datetime.datetime(2012, 8, 22, 16, 20, 9, 822774)}
|
||
</code></pre>
|
||
<p>At this point we've translated the model instance into Python native datatypes. To finalise the serialization process we render the data into <code>json</code>.</p>
|
||
<pre class="prettyprint lang-py"><code>from rest_framework.renderers import JSONRenderer
|
||
|
||
json = JSONRenderer().render(serializer.data)
|
||
json
|
||
# '{"email": "leila@example.com", "content": "foo bar", "created": "2012-08-22T16:20:09.822"}'
|
||
</code></pre>
|
||
<h3 id="customizing-field-representation">Customizing field representation</h3>
|
||
<p>Sometimes when serializing objects, you may not want to represent everything exactly the way it is in your model.</p>
|
||
<p>If you need to customize the serialized value of a particular field, you can do this by creating a <code>transform_<fieldname></code> method. For example if you needed to render some markdown from a text field:</p>
|
||
<pre class="prettyprint lang-py"><code>description = serializers.CharField()
|
||
description_html = serializers.CharField(source='description', read_only=True)
|
||
|
||
def transform_description_html(self, obj, value):
|
||
from django.contrib.markup.templatetags.markup import markdown
|
||
return markdown(value)
|
||
</code></pre>
|
||
<p>These methods are essentially the reverse of <code>validate_<fieldname></code> (see <em>Validation</em> below.)</p>
|
||
<h2 id="deserializing-objects">Deserializing objects</h2>
|
||
<p>Deserialization is similar. First we parse a stream into Python native datatypes... </p>
|
||
<pre class="prettyprint lang-py"><code>from StringIO import StringIO
|
||
from rest_framework.parsers import JSONParser
|
||
|
||
stream = StringIO(json)
|
||
data = JSONParser().parse(stream)
|
||
</code></pre>
|
||
<p>...then we restore those native datatypes into a fully populated object instance.</p>
|
||
<pre class="prettyprint lang-py"><code>serializer = CommentSerializer(data=data)
|
||
serializer.is_valid()
|
||
# True
|
||
serializer.object
|
||
# <Comment object at 0x10633b2d0>
|
||
</code></pre>
|
||
<p>When deserializing data, we can either create a new instance, or update an existing instance.</p>
|
||
<pre class="prettyprint lang-py"><code>serializer = CommentSerializer(data=data) # Create new instance
|
||
serializer = CommentSerializer(comment, data=data) # Update `comment`
|
||
</code></pre>
|
||
<p>By default, serializers must be passed values for all required fields or they will throw validation errors. You can use the <code>partial</code> argument in order to allow partial updates.</p>
|
||
<pre class="prettyprint lang-py"><code>serializer = CommentSerializer(comment, data={'content': u'foo bar'}, partial=True) # Update `comment` with partial data
|
||
</code></pre>
|
||
<h2 id="validation">Validation</h2>
|
||
<p>When deserializing data, you always need to call <code>is_valid()</code> before attempting to access the deserialized object. If any validation errors occur, the <code>.errors</code> property will contain a dictionary representing the resulting error messages. For example:</p>
|
||
<pre class="prettyprint lang-py"><code>serializer = CommentSerializer(data={'email': 'foobar', 'content': 'baz'})
|
||
serializer.is_valid()
|
||
# False
|
||
serializer.errors
|
||
# {'email': [u'Enter a valid e-mail address.'], 'created': [u'This field is required.']}
|
||
</code></pre>
|
||
<p>Each key in the dictionary will be the field name, and the values will be lists of strings of any error messages corresponding to that field. The <code>non_field_errors</code> key may also be present, and will list any general validation errors.</p>
|
||
<p>When deserializing a list of items, errors will be returned as a list of dictionaries representing each of the deserialized items.</p>
|
||
<h4 id="field-level-validation">Field-level validation</h4>
|
||
<p>You can specify custom field-level validation by adding <code>.validate_<fieldname></code> methods to your <code>Serializer</code> subclass. These are analogous to <code>.clean_<fieldname></code> methods on Django forms, but accept slightly different arguments.</p>
|
||
<p>They take a dictionary of deserialized attributes as a first argument, and the field name in that dictionary as a second argument (which will be either the name of the field or the value of the <code>source</code> argument to the field, if one was provided).</p>
|
||
<p>Your <code>validate_<fieldname></code> methods should either just return the <code>attrs</code> dictionary or raise a <code>ValidationError</code>. For example:</p>
|
||
<pre class="prettyprint lang-py"><code>from rest_framework import serializers
|
||
|
||
class BlogPostSerializer(serializers.Serializer):
|
||
title = serializers.CharField(max_length=100)
|
||
content = serializers.CharField()
|
||
|
||
def validate_title(self, attrs, source):
|
||
"""
|
||
Check that the blog post is about Django.
|
||
"""
|
||
value = attrs[source]
|
||
if "django" not in value.lower():
|
||
raise serializers.ValidationError("Blog post is not about Django")
|
||
return attrs
|
||
</code></pre>
|
||
<h4 id="object-level-validation">Object-level validation</h4>
|
||
<p>To do any other validation that requires access to multiple fields, add a method called <code>.validate()</code> to your <code>Serializer</code> subclass. This method takes a single argument, which is the <code>attrs</code> dictionary. It should raise a <code>ValidationError</code> if necessary, or just return <code>attrs</code>. For example:</p>
|
||
<pre class="prettyprint lang-py"><code>from rest_framework import serializers
|
||
|
||
class EventSerializer(serializers.Serializer):
|
||
description = serializers.CharField(max_length=100)
|
||
start = serializers.DateTimeField()
|
||
finish = serializers.DateTimeField()
|
||
|
||
def validate(self, attrs):
|
||
"""
|
||
Check that the start is before the stop.
|
||
"""
|
||
if attrs['start'] > attrs['finish']:
|
||
raise serializers.ValidationError("finish must occur after start")
|
||
return attrs
|
||
</code></pre>
|
||
<h2 id="saving-object-state">Saving object state</h2>
|
||
<p>To save the deserialized objects created by a serializer, call the <code>.save()</code> method:</p>
|
||
<pre class="prettyprint lang-py"><code>if serializer.is_valid():
|
||
serializer.save()
|
||
</code></pre>
|
||
<p>The default behavior of the method is to simply call <code>.save()</code> on the deserialized object instance. You can override the default save behaviour by overriding the <code>.save_object(obj)</code> method on the serializer class.</p>
|
||
<p>The generic views provided by REST framework call the <code>.save()</code> method when updating or creating entities. </p>
|
||
<h2 id="dealing-with-nested-objects">Dealing with nested objects</h2>
|
||
<p>The previous examples are fine for dealing with objects that only have simple datatypes, but sometimes we also need to be able to represent more complex objects, where some of the attributes of an object might not be simple datatypes such as strings, dates or integers.</p>
|
||
<p>The <code>Serializer</code> class is itself a type of <code>Field</code>, and can be used to represent relationships where one object type is nested inside another.</p>
|
||
<pre class="prettyprint lang-py"><code>class UserSerializer(serializers.Serializer):
|
||
email = serializers.EmailField()
|
||
username = serializers.CharField(max_length=100)
|
||
|
||
class CommentSerializer(serializers.Serializer):
|
||
user = UserSerializer()
|
||
content = serializers.CharField(max_length=200)
|
||
created = serializers.DateTimeField()
|
||
</code></pre>
|
||
<p>If a nested representation may optionally accept the <code>None</code> value you should pass the <code>required=False</code> flag to the nested serializer.</p>
|
||
<pre class="prettyprint lang-py"><code>class CommentSerializer(serializers.Serializer):
|
||
user = UserSerializer(required=False) # May be an anonymous user.
|
||
content = serializers.CharField(max_length=200)
|
||
created = serializers.DateTimeField()
|
||
</code></pre>
|
||
<p>Similarly if a nested representation should be a list of items, you should pass the <code>many=True</code> flag to the nested serialized.</p>
|
||
<pre class="prettyprint lang-py"><code>class CommentSerializer(serializers.Serializer):
|
||
user = UserSerializer(required=False)
|
||
edits = EditItemSerializer(many=True) # A nested list of 'edit' items.
|
||
content = serializers.CharField(max_length=200)
|
||
created = serializers.DateTimeField()
|
||
</code></pre>
|
||
<p>Validation of nested objects will work the same as before. Errors with nested objects will be nested under the field name of the nested object.</p>
|
||
<pre class="prettyprint lang-py"><code>serializer = CommentSerializer(data={'user': {'email': 'foobar', 'username': 'doe'}, 'content': 'baz'})
|
||
serializer.is_valid()
|
||
# False
|
||
serializer.errors
|
||
# {'user': {'email': [u'Enter a valid e-mail address.']}, 'created': [u'This field is required.']}
|
||
</code></pre>
|
||
<h2 id="dealing-with-multiple-objects">Dealing with multiple objects</h2>
|
||
<p>The <code>Serializer</code> class can also handle serializing or deserializing lists of objects.</p>
|
||
<h4 id="serializing-multiple-objects">Serializing multiple objects</h4>
|
||
<p>To serialize a queryset or list of objects instead of a single object instance, you should pass the <code>many=True</code> flag when instantiating the serializer. You can then pass a queryset or list of objects to be serialized.</p>
|
||
<pre class="prettyprint lang-py"><code>queryset = Book.objects.all()
|
||
serializer = BookSerializer(queryset, many=True)
|
||
serializer.data
|
||
# [
|
||
# {'id': 0, 'title': 'The electric kool-aid acid test', 'author': 'Tom Wolfe'},
|
||
# {'id': 1, 'title': 'If this is a man', 'author': 'Primo Levi'},
|
||
# {'id': 2, 'title': 'The wind-up bird chronicle', 'author': 'Haruki Murakami'}
|
||
# ]
|
||
</code></pre>
|
||
<h4 id="deserializing-multiple-objects-for-creation">Deserializing multiple objects for creation</h4>
|
||
<p>To deserialize a list of object data, and create multiple object instances in a single pass, you should also set the <code>many=True</code> flag, and pass a list of data to be deserialized.</p>
|
||
<p>This allows you to write views that create multiple items when a <code>POST</code> request is made.</p>
|
||
<p>For example:</p>
|
||
<pre class="prettyprint lang-py"><code>data = [
|
||
{'title': 'The bell jar', 'author': 'Sylvia Plath'},
|
||
{'title': 'For whom the bell tolls', 'author': 'Ernest Hemingway'}
|
||
]
|
||
serializer = BookSerializer(data=data, many=True)
|
||
serializer.is_valid()
|
||
# True
|
||
serializer.save() # `.save()` will be called on each deserialized instance
|
||
</code></pre>
|
||
<h4 id="deserializing-multiple-objects-for-update">Deserializing multiple objects for update</h4>
|
||
<p>You can also deserialize a list of objects as part of a bulk update of multiple existing items.
|
||
In this case you need to supply both an existing list or queryset of items, as well as a list of data to update those items with.</p>
|
||
<p>This allows you to write views that update or create multiple items when a <code>PUT</code> request is made.</p>
|
||
<pre class="prettyprint lang-py"><code># Capitalizing the titles of the books
|
||
queryset = Book.objects.all()
|
||
data = [
|
||
{'id': 3, 'title': 'The Bell Jar', 'author': 'Sylvia Plath'},
|
||
{'id': 4, 'title': 'For Whom the Bell Tolls', 'author': 'Ernest Hemingway'}
|
||
]
|
||
serializer = BookSerializer(queryset, data=data, many=True)
|
||
serializer.is_valid()
|
||
# True
|
||
serializer.save() # `.save()` will be called on each updated or newly created instance.
|
||
</code></pre>
|
||
<p>By default bulk updates will be limited to updating instances that already exist in the provided queryset.</p>
|
||
<p>When performing a bulk update you may want to allow new items to be created, and missing items to be deleted. To do so, pass <code>allow_add_remove=True</code> to the serializer.</p>
|
||
<pre class="prettyprint lang-py"><code>serializer = BookSerializer(queryset, data=data, many=True, allow_add_remove=True)
|
||
serializer.is_valid()
|
||
# True
|
||
serializer.save() # `.save()` will be called on updated or newly created instances.
|
||
# `.delete()` will be called on any other items in the `queryset`.
|
||
</code></pre>
|
||
<p>Passing <code>allow_add_remove=True</code> ensures that any update operations will completely overwrite the existing queryset, rather than simply updating existing objects.</p>
|
||
<h4 id="how-identity-is-determined-when-performing-bulk-updates">How identity is determined when performing bulk updates</h4>
|
||
<p>Performing a bulk update is slightly more complicated than performing a bulk creation, because the serializer needs a way to determine how the items in the incoming data should be matched against the existing object instances.</p>
|
||
<p>By default the serializer class will use the <code>id</code> key on the incoming data to determine the canonical identity of an object. If you need to change this behavior you should override the <code>get_identity</code> method on the <code>Serializer</code> class. For example:</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.Serializer):
|
||
slug = serializers.CharField(max_length=100)
|
||
created = serializers.DateTimeField()
|
||
... # Various other fields
|
||
|
||
def get_identity(self, data):
|
||
"""
|
||
This hook is required for bulk update.
|
||
We need to override the default, to use the slug as the identity.
|
||
|
||
Note that the data has not yet been validated at this point,
|
||
so we need to deal gracefully with incorrect datatypes.
|
||
"""
|
||
try:
|
||
return data.get('slug', None)
|
||
except AttributeError:
|
||
return None
|
||
</code></pre>
|
||
<p>To map the incoming data items to their corresponding object instances, the <code>.get_identity()</code> method will be called both against the incoming data, and against the serialized representation of the existing objects.</p>
|
||
<h2 id="including-extra-context">Including extra context</h2>
|
||
<p>There are some cases where you need to provide extra context to the serializer in addition to the object being serialized. One common case is if you're using a serializer that includes hyperlinked relations, which requires the serializer to have access to the current request so that it can properly generate fully qualified URLs.</p>
|
||
<p>You can provide arbitrary additional context by passing a <code>context</code> argument when instantiating the serializer. For example:</p>
|
||
<pre class="prettyprint lang-py"><code>serializer = AccountSerializer(account, context={'request': request})
|
||
serializer.data
|
||
# {'id': 6, 'owner': u'denvercoder9', 'created': datetime.datetime(2013, 2, 12, 09, 44, 56, 678870), 'details': 'http://example.com/accounts/6/details'}
|
||
</code></pre>
|
||
<p>The context dictionary can be used within any serializer field logic, such as a custom <code>.to_native()</code> method, by accessing the <code>self.context</code> attribute.</p>
|
||
<p>-</p>
|
||
<h1 id="modelserializer">ModelSerializer</h1>
|
||
<p>Often you'll want serializer classes that map closely to model definitions.
|
||
The <code>ModelSerializer</code> class lets you automatically create a Serializer class with fields that correspond to the Model fields.</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.ModelSerializer):
|
||
class Meta:
|
||
model = Account
|
||
</code></pre>
|
||
<p>By default, all the model fields on the class will be mapped to corresponding serializer fields.</p>
|
||
<p>Any relationships such as foreign keys on the model will be mapped to <code>PrimaryKeyRelatedField</code>. Other models fields will be mapped to a corresponding serializer field.</p>
|
||
<hr />
|
||
<p><strong>Note</strong>: When validation is applied to a <code>ModelSerializer</code>, both the serializer fields, and their corresponding model fields must correctly validate. If you have optional fields on your model, make sure to correctly set <code>blank=True</code> on the model field, as well as setting <code>required=False</code> on the serializer field.</p>
|
||
<hr />
|
||
<h2 id="specifying-which-fields-should-be-included">Specifying which fields should be included</h2>
|
||
<p>If you only want a subset of the default fields to be used in a model serializer, you can do so using <code>fields</code> or <code>exclude</code> options, just as you would with a <code>ModelForm</code>.</p>
|
||
<p>For example:</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.ModelSerializer):
|
||
class Meta:
|
||
model = Account
|
||
fields = ('id', 'account_name', 'users', 'created')
|
||
</code></pre>
|
||
<h2 id="specifying-nested-serialization">Specifying nested serialization</h2>
|
||
<p>The default <code>ModelSerializer</code> uses primary keys for relationships, but you can also easily generate nested representations using the <code>depth</code> option:</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.ModelSerializer):
|
||
class Meta:
|
||
model = Account
|
||
fields = ('id', 'account_name', 'users', 'created')
|
||
depth = 1
|
||
</code></pre>
|
||
<p>The <code>depth</code> option should be set to an integer value that indicates the depth of relationships that should be traversed before reverting to a flat representation.</p>
|
||
<p>If you want to customize the way the serialization is done (e.g. using <code>allow_add_remove</code>) you'll need to define the field yourself.</p>
|
||
<h2 id="specifying-which-fields-should-be-read-only">Specifying which fields should be read-only</h2>
|
||
<p>You may wish to specify multiple fields as read-only. Instead of adding each field explicitly with the <code>read_only=True</code> attribute, you may use the <code>read_only_fields</code> Meta option, like so:</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.ModelSerializer):
|
||
class Meta:
|
||
model = Account
|
||
fields = ('id', 'account_name', 'users', 'created')
|
||
read_only_fields = ('account_name',)
|
||
</code></pre>
|
||
<p>Model fields which have <code>editable=False</code> set, and <code>AutoField</code> fields will be set to read-only by default, and do not need to be added to the <code>read_only_fields</code> option. </p>
|
||
<h2 id="specifying-which-fields-should-be-write-only">Specifying which fields should be write-only</h2>
|
||
<p>You may wish to specify multiple fields as write-only. Instead of adding each field explicitly with the <code>write_only=True</code> attribute, you may use the <code>write_only_fields</code> Meta option, like so:</p>
|
||
<pre class="prettyprint lang-py"><code>class CreateUserSerializer(serializers.ModelSerializer):
|
||
class Meta:
|
||
model = User
|
||
fields = ('email', 'username', 'password')
|
||
write_only_fields = ('password',) # Note: Password field is write-only
|
||
|
||
def restore_object(self, attrs, instance=None):
|
||
"""
|
||
Instantiate a new User instance.
|
||
"""
|
||
assert instance is None, 'Cannot update users with CreateUserSerializer'
|
||
user = User(email=attrs['email'], username=attrs['username'])
|
||
user.set_password(attrs['password'])
|
||
return user
|
||
</code></pre>
|
||
<h2 id="specifying-fields-explicitly">Specifying fields explicitly</h2>
|
||
<p>You can add extra fields to a <code>ModelSerializer</code> or override the default fields by declaring fields on the class, just as you would for a <code>Serializer</code> class.</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.ModelSerializer):
|
||
url = serializers.CharField(source='get_absolute_url', read_only=True)
|
||
groups = serializers.PrimaryKeyRelatedField(many=True)
|
||
|
||
class Meta:
|
||
model = Account
|
||
</code></pre>
|
||
<p>Extra fields can correspond to any property or callable on the model.</p>
|
||
<h2 id="relational-fields">Relational fields</h2>
|
||
<p>When serializing model instances, there are a number of different ways you might choose to represent relationships. The default representation for <code>ModelSerializer</code> is to use the primary keys of the related instances.</p>
|
||
<p>Alternative representations include serializing using hyperlinks, serializing complete nested representations, or serializing with a custom representation.</p>
|
||
<p>For full details see the <a href="relations">serializer relations</a> documentation.</p>
|
||
<hr />
|
||
<h1 id="hyperlinkedmodelserializer">HyperlinkedModelSerializer</h1>
|
||
<p>The <code>HyperlinkedModelSerializer</code> class is similar to the <code>ModelSerializer</code> class except that it uses hyperlinks to represent relationships, rather than primary keys.</p>
|
||
<p>By default the serializer will include a <code>url</code> field instead of a primary key field.</p>
|
||
<p>The url field will be represented using a <code>HyperlinkedIdentityField</code> serializer field, and any relationships on the model will be represented using a <code>HyperlinkedRelatedField</code> serializer field.</p>
|
||
<p>You can explicitly include the primary key by adding it to the <code>fields</code> option, for example:</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.HyperlinkedModelSerializer):
|
||
class Meta:
|
||
model = Account
|
||
fields = ('url', 'id', 'account_name', 'users', 'created')
|
||
</code></pre>
|
||
<h2 id="how-hyperlinked-views-are-determined">How hyperlinked views are determined</h2>
|
||
<p>There needs to be a way of determining which views should be used for hyperlinking to model instances.</p>
|
||
<p>By default hyperlinks are expected to correspond to a view name that matches the style <code>'{model_name}-detail'</code>, and looks up the instance by a <code>pk</code> keyword argument.</p>
|
||
<p>You can change the field that is used for object lookups by setting the <code>lookup_field</code> option. The value of this option should correspond both with a kwarg in the URL conf, and with a field on the model. For example:</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.HyperlinkedModelSerializer):
|
||
class Meta:
|
||
model = Account
|
||
fields = ('url', 'account_name', 'users', 'created')
|
||
lookup_field = 'slug'
|
||
</code></pre>
|
||
<p>Note that the <code>lookup_field</code> will be used as the default on <em>all</em> hyperlinked fields, including both the URL identity, and any hyperlinked relationships.</p>
|
||
<p>For more specific requirements such as specifying a different lookup for each field, you'll want to set the fields on the serializer explicitly. For example:</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.HyperlinkedModelSerializer):
|
||
url = serializers.HyperlinkedIdentityField(
|
||
view_name='account_detail',
|
||
lookup_field='account_name'
|
||
)
|
||
users = serializers.HyperlinkedRelatedField(
|
||
view_name='user-detail',
|
||
lookup_field='username',
|
||
many=True,
|
||
read_only=True
|
||
)
|
||
|
||
class Meta:
|
||
model = Account
|
||
fields = ('url', 'account_name', 'users', 'created')
|
||
</code></pre>
|
||
<h2 id="overriding-the-url-field-behavior">Overriding the URL field behavior</h2>
|
||
<p>The name of the URL field defaults to 'url'. You can override this globally, by using the <code>URL_FIELD_NAME</code> setting.</p>
|
||
<p>You can also override this on a per-serializer basis by using the <code>url_field_name</code> option on the serializer, like so:</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.HyperlinkedModelSerializer):
|
||
class Meta:
|
||
model = Account
|
||
fields = ('account_url', 'account_name', 'users', 'created')
|
||
url_field_name = 'account_url'
|
||
</code></pre>
|
||
<p><strong>Note</strong>: The generic view implementations normally generate a <code>Location</code> header in response to successful <code>POST</code> requests. Serializers using <code>url_field_name</code> option will not have this header automatically included by the view. If you need to do so you will ned to also override the view's <code>get_success_headers()</code> method.</p>
|
||
<p>You can also override the URL field's view name and lookup field without overriding the field explicitly, by using the <code>view_name</code> and <code>lookup_field</code> options, like so:</p>
|
||
<pre class="prettyprint lang-py"><code>class AccountSerializer(serializers.HyperlinkedModelSerializer):
|
||
class Meta:
|
||
model = Account
|
||
fields = ('account_url', 'account_name', 'users', 'created')
|
||
view_name = 'account_detail'
|
||
lookup_field='account_name'
|
||
</code></pre>
|
||
<hr />
|
||
<h1 id="advanced-serializer-usage">Advanced serializer usage</h1>
|
||
<p>You can create customized subclasses of <code>ModelSerializer</code> or <code>HyperlinkedModelSerializer</code> that use a different set of default fields.</p>
|
||
<p>Doing so should be considered advanced usage, and will only be needed if you have some particular serializer requirements that you often need to repeat.</p>
|
||
<h2 id="dynamically-modifying-fields">Dynamically modifying fields</h2>
|
||
<p>Once a serializer has been initialized, the dictionary of fields that are set on the serializer may be accessed using the <code>.fields</code> attribute. Accessing and modifying this attribute allows you to dynamically modify the serializer.</p>
|
||
<p>Modifying the <code>fields</code> argument directly allows you to do interesting things such as changing the arguments on serializer fields at runtime, rather than at the point of declaring the serializer.</p>
|
||
<h3 id="example">Example</h3>
|
||
<p>For example, if you wanted to be able to set which fields should be used by a serializer at the point of initializing it, you could create a serializer class like so:</p>
|
||
<pre class="prettyprint lang-py"><code>class DynamicFieldsModelSerializer(serializers.ModelSerializer):
|
||
"""
|
||
A ModelSerializer that takes an additional `fields` argument that
|
||
controls which fields should be displayed.
|
||
"""
|
||
|
||
def __init__(self, *args, **kwargs):
|
||
# Don't pass the 'fields' arg up to the superclass
|
||
fields = kwargs.pop('fields', None)
|
||
|
||
# Instantiate the superclass normally
|
||
super(DynamicFieldsModelSerializer, self).__init__(*args, **kwargs)
|
||
|
||
if fields:
|
||
# Drop any fields that are not specified in the `fields` argument.
|
||
allowed = set(fields)
|
||
existing = set(self.fields.keys())
|
||
for field_name in existing - allowed:
|
||
self.fields.pop(field_name)
|
||
</code></pre>
|
||
<p>This would then allow you to do the following:</p>
|
||
<pre class="prettyprint lang-py"><code>>>> class UserSerializer(DynamicFieldsModelSerializer):
|
||
>>> class Meta:
|
||
>>> model = User
|
||
>>> fields = ('id', 'username', 'email')
|
||
>>>
|
||
>>> print UserSerializer(user)
|
||
{'id': 2, 'username': 'jonwatts', 'email': 'jon@example.com'}
|
||
>>>
|
||
>>> print UserSerializer(user, fields=('id', 'email'))
|
||
{'id': 2, 'email': 'jon@example.com'}
|
||
</code></pre>
|
||
<h2 id="customising-the-default-fields">Customising the default fields</h2>
|
||
<p>The <code>field_mapping</code> attribute is a dictionary that maps model classes to serializer classes. Overriding the attribute will let you set a different set of default serializer classes. </p>
|
||
<p>For more advanced customization than simply changing the default serializer class you can override various <code>get_<field_type>_field</code> methods. Doing so will allow you to customize the arguments that each serializer field is initialized with. Each of these methods may either return a field or serializer instance, or <code>None</code>.</p>
|
||
<h3 id="get_pk_field">get_pk_field</h3>
|
||
<p><strong>Signature</strong>: <code>.get_pk_field(self, model_field)</code></p>
|
||
<p>Returns the field instance that should be used to represent the pk field.</p>
|
||
<h3 id="get_nested_field">get_nested_field</h3>
|
||
<p><strong>Signature</strong>: <code>.get_nested_field(self, model_field, related_model, to_many)</code></p>
|
||
<p>Returns the field instance that should be used to represent a related field when <code>depth</code> is specified as being non-zero.</p>
|
||
<p>Note that the <code>model_field</code> argument will be <code>None</code> for reverse relationships. The <code>related_model</code> argument will be the model class for the target of the field. The <code>to_many</code> argument will be a boolean indicating if this is a to-one or to-many relationship.</p>
|
||
<h3 id="get_related_field">get_related_field</h3>
|
||
<p><strong>Signature</strong>: <code>.get_related_field(self, model_field, related_model, to_many)</code></p>
|
||
<p>Returns the field instance that should be used to represent a related field when <code>depth</code> is not specified, or when nested representations are being used and the depth reaches zero.</p>
|
||
<p>Note that the <code>model_field</code> argument will be <code>None</code> for reverse relationships. The <code>related_model</code> argument will be the model class for the target of the field. The <code>to_many</code> argument will be a boolean indicating if this is a to-one or to-many relationship.</p>
|
||
<h3 id="get_field">get_field</h3>
|
||
<p><strong>Signature</strong>: <code>.get_field(self, model_field)</code></p>
|
||
<p>Returns the field instance that should be used for non-relational, non-pk fields.</p>
|
||
<h3 id="example_1">Example</h3>
|
||
<p>The following custom model serializer could be used as a base class for model serializers that should always exclude the pk by default.</p>
|
||
<pre class="prettyprint lang-py"><code>class NoPKModelSerializer(serializers.ModelSerializer):
|
||
def get_pk_field(self, model_field):
|
||
return None
|
||
</code></pre>
|
||
<hr />
|
||
<h1 id="third-party-packages">Third party packages</h1>
|
||
<p>The following third party packages are also available.</p>
|
||
<h2 id="mongoenginemodelserializer">MongoengineModelSerializer</h2>
|
||
<p>The <a href="https://github.com/umutbozkurt/django-rest-framework-mongoengine">django-rest-framework-mongoengine</a> package provides a <code>MongoEngineModelSerializer</code> serializer class that supports using MongoDB as the storage layer for Django REST framework.</p>
|
||
<h2 id="geofeaturemodelserializer">GeoFeatureModelSerializer</h2>
|
||
<p>The <a href="https://github.com/djangonauts/django-rest-framework-gis">django-rest-framework-gis</a> package provides a <code>GeoFeatureModelSerializer</code> serializer class that supports GeoJSON both for read and write operations.</p>
|
||
<h2 id="hstoreserializer">HStoreSerializer</h2>
|
||
<p>The <a href="https://github.com/djangonauts/django-rest-framework-hstore">django-rest-framework-hstore</a> package provides an <code>HStoreSerializer</code> to support <a href="https://github.com/djangonauts/django-hstore">django-hstore</a> <code>DictionaryField</code> model field and its <code>schema-mode</code> feature.</p>
|
||
</div><!--/span-->
|
||
</div><!--/row-->
|
||
</div><!--/.fluid-container-->
|
||
</div><!--/.body content-->
|
||
|
||
<div id="push"></div>
|
||
</div><!--/.wrapper -->
|
||
|
||
<footer class="span12">
|
||
<p>Sponsored by <a href="http://dabapps.com/">DabApps</a>.</a></p>
|
||
</footer>
|
||
|
||
<!-- Le javascript
|
||
================================================== -->
|
||
<!-- Placed at the end of the document so the pages load faster -->
|
||
<script src="http://www.django-rest-framework.org/js/jquery-1.8.1-min.js"></script>
|
||
<script src="http://www.django-rest-framework.org/js/prettify-1.0.js"></script>
|
||
<script src="http://www.django-rest-framework.org/js/bootstrap-2.1.1-min.js"></script>
|
||
|
||
<script>
|
||
//$('.side-nav').scrollspy()
|
||
var shiftWindow = function() { scrollBy(0, -50) };
|
||
if (location.hash) shiftWindow();
|
||
window.addEventListener("hashchange", shiftWindow);
|
||
|
||
$('.dropdown-menu').on('click touchstart', function(event) {
|
||
event.stopPropagation();
|
||
});
|
||
|
||
// Dynamically force sidenav to no higher than browser window
|
||
$('.side-nav').css('max-height', window.innerHeight - 130);
|
||
|
||
$(function(){
|
||
$(window).resize(function(){
|
||
$('.side-nav').css('max-height', window.innerHeight - 130);
|
||
});
|
||
});
|
||
</script>
|
||
</body></html>
|