From b2dc66448503c2120d943a2f282eab235afc67ba Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 19 Mar 2013 14:26:48 +0000
Subject: Basic bulk create and bulk update

---
 docs/api-guide/serializers.md                  |  17 ++-
 rest_framework/serializers.py                  |  38 ++++++
 rest_framework/tests/serializer.py             |   2 +-
 rest_framework/tests/serializer_bulk_update.py | 174 +++++++++++++++++++++++++
 4 files changed, 223 insertions(+), 8 deletions(-)
 create mode 100644 rest_framework/tests/serializer_bulk_update.py

diff --git a/docs/api-guide/serializers.md b/docs/api-guide/serializers.md
index 42edf9af..ee7208a3 100644
--- a/docs/api-guide/serializers.md
+++ b/docs/api-guide/serializers.md
@@ -37,9 +37,6 @@ Declaring a serializer looks very similar to declaring a form:
             """
             Given a dictionary of deserialized field values, either update
             an existing model instance, or create a new model instance.
-            
-            Note that if we don't define this method, then deserializing
-            data will simply return a dictionary of items.
             """
             if instance is not None:
                 instance.title = attrs.get('title', instance.title)
@@ -48,7 +45,9 @@ Declaring a serializer looks very similar to declaring a form:
                 return instance
             return Comment(**attrs) 
 
-The first part of serializer class defines the fields that get serialized/deserialized.  The `restore_object` method defines how fully fledged instances get created when deserializing data.  The `restore_object` method is optional, and is only required if we want our serializer to support deserialization.
+The first part of serializer class defines the fields that get serialized/deserialized.  The `restore_object` method defines how fully fledged instances get created when deserializing data.
+
+The `restore_object` 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.
 
 ## Serializing objects
 
@@ -88,18 +87,22 @@ By default, serializers must be passed values for all required fields or they wi
 
     serializer = CommentSerializer(comment, data={'content': u'foo bar'}, partial=True)  # Update `instance` with partial data
 
-## Serializing querysets
+## Serializing multiple objects
 
-To serialize a queryset instead of an object instance, you should pass the `many=True` flag when instantiating the serializer.
+To serialize a queryset or list of objects instead of a single object instance, you should pass the `many=True` flag when instantiating the serializer.
 
     queryset = Comment.objects.all()
     serializer = CommentSerializer(queryset, many=True)
     serializer.data
-    # [{'email': u'leila@example.com', 'content': u'foo bar', 'created': datetime.datetime(2012, 8, 22, 16, 20, 9, 822774)}, {'email': u'jamie@example.com', 'content': u'baz', 'created': datetime.datetime(2013, 1, 12, 16, 12, 45, 104445)}]
+    # [
+    #     {'email': u'leila@example.com', 'content': u'foo bar', 'created': datetime.datetime(2012, 8, 22, 16, 20, 9, 822774)},
+    #     {'email': u'jamie@example.com', 'content': u'baz', 'created': datetime.datetime(2013, 1, 12, 16, 12, 45, 104445)}
+    # ]
 
 ## Validation
 
 When deserializing data, you always need to call `is_valid()` before attempting to access the deserialized object.  If any validation errors occur, the `.errors` property will contain a dictionary representing the resulting error messages.
+
 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 `non_field_errors` key may also be present, and will list any general validation errors.
 
 When deserializing a list of items, errors will be returned as a list of dictionaries representing each of the deserialized items.
diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 4fe857a6..34120dc6 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -128,6 +128,7 @@ class BaseSerializer(Field):
         self._data = None
         self._files = None
         self._errors = None
+        self._deleted = None
 
     #####
     # Methods to determine which fields to use when (de)serializing objects.
@@ -331,6 +332,13 @@ class BaseSerializer(Field):
             return [self.to_native(item) for item in obj]
         return self.to_native(obj)
 
+    def get_identity(self, data):
+        """
+        This hook is required for bulk update.
+        It is used to determine the canonical identity of a given object.
+        """
+        return data.get('id')
+
     @property
     def errors(self):
         """
@@ -352,9 +360,32 @@ class BaseSerializer(Field):
             if many:
                 ret = []
                 errors = []
+                update = self.object is not None
+
+                if update:
+                    # If this is a bulk update we need to map all the objects
+                    # to a canonical identity so we can determine which
+                    # individual object is being updated for each item in the
+                    # incoming data
+                    objects = self.object
+                    identities = [self.get_identity(self.to_native(obj)) for obj in objects]
+                    identity_to_objects = dict(zip(identities, objects))
+
                 for item in data:
+                    if update:
+                        # Determine which object we're updating
+                        try:
+                            identity = self.get_identity(item)
+                        except:
+                            self.object = None
+                        else:
+                            self.object = identity_to_objects.pop(identity, None)
+
                     ret.append(self.from_native(item, None))
                     errors.append(self._errors)
+
+                if update:
+                    self._deleted = identity_to_objects.values()
                 self._errors = any(errors) and errors or []
             else:
                 ret = self.from_native(data, files)
@@ -394,6 +425,9 @@ class BaseSerializer(Field):
     def save_object(self, obj, **kwargs):
         obj.save(**kwargs)
 
+    def delete_object(self, obj):
+        obj.delete()
+
     def save(self, **kwargs):
         """
         Save the deserialized object and return it.
@@ -402,6 +436,10 @@ class BaseSerializer(Field):
             [self.save_object(item, **kwargs) for item in self.object]
         else:
             self.save_object(self.object, **kwargs)
+
+        if self._deleted:
+            [self.delete_object(item) for item in self._deleted]
+
         return self.object
 
 
diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index beb372c2..9c0fdd78 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -266,7 +266,7 @@ class ValidationTests(TestCase):
         Data of the wrong type is not valid.
         """
         data = ['i am', 'a', 'list']
-        serializer = CommentSerializer(self.comment, data=data, many=True)
+        serializer = CommentSerializer([self.comment], data=data, many=True)
         self.assertEqual(serializer.is_valid(), False)
         self.assertTrue(isinstance(serializer.errors, list))
 
diff --git a/rest_framework/tests/serializer_bulk_update.py b/rest_framework/tests/serializer_bulk_update.py
new file mode 100644
index 00000000..66fca883
--- /dev/null
+++ b/rest_framework/tests/serializer_bulk_update.py
@@ -0,0 +1,174 @@
+"""
+Tests to cover bulk create and update using serializers.
+"""
+from __future__ import unicode_literals
+from django.test import TestCase
+from rest_framework import serializers
+
+
+class BulkCreateSerializerTests(TestCase):
+
+    def setUp(self):
+        class BookSerializer(serializers.Serializer):
+            id = serializers.IntegerField()
+            title = serializers.CharField(max_length=100)
+            author = serializers.CharField(max_length=100)
+
+        self.BookSerializer = BookSerializer
+
+    def test_bulk_create_success(self):
+        """
+        Correct bulk update serialization should return the input data.
+        """
+
+        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'
+            }
+        ]
+
+        serializer = self.BookSerializer(data=data, many=True)
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.object, data)
+
+    def test_bulk_create_errors(self):
+        """
+        Correct bulk update serialization should return the input data.
+        """
+
+        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': 'foo',
+                'title': 'The wind-up bird chronicle',
+                'author': 'Haruki Murakami'
+            }
+        ]
+        expected_errors = [
+            {},
+            {},
+            {'id': ['Enter a whole number.']}
+        ]
+
+        serializer = self.BookSerializer(data=data, many=True)
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, expected_errors)
+
+
+class BulkUpdateSerializerTests(TestCase):
+
+    def setUp(self):
+        class Book(object):
+            object_map = {}
+
+            def __init__(self, id, title, author):
+                self.id = id
+                self.title = title
+                self.author = author
+
+            def save(self):
+                Book.object_map[self.id] = self
+
+            def delete(self):
+                del Book.object_map[self.id]
+
+        class BookSerializer(serializers.Serializer):
+            id = serializers.IntegerField()
+            title = serializers.CharField(max_length=100)
+            author = serializers.CharField(max_length=100)
+
+            def restore_object(self, attrs, instance=None):
+                if instance:
+                    instance.id = attrs['id']
+                    instance.title = attrs['title']
+                    instance.author = attrs['author']
+                    return instance
+                return Book(**attrs)
+
+        self.Book = Book
+        self.BookSerializer = BookSerializer
+
+        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'
+            }
+        ]
+
+        for item in data:
+            book = Book(item['id'], item['title'], item['author'])
+            book.save()
+
+    def books(self):
+        return self.Book.object_map.values()
+
+    def test_bulk_update_success(self):
+        """
+        Correct bulk update serialization should return the input data.
+        """
+        data = [
+            {
+                'id': 0,
+                'title': 'The electric kool-aid acid test',
+                'author': 'Tom Wolfe'
+            }, {
+                'id': 2,
+                'title': 'Kafka on the shore',
+                'author': 'Haruki Murakami'
+            }
+        ]
+        serializer = self.BookSerializer(self.books(), data=data, many=True)
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.data, data)
+        serializer.save()
+        new_data = self.BookSerializer(self.books(), many=True).data
+        self.assertEqual(data, new_data)
+
+    def test_bulk_update_error(self):
+        """
+        Correct bulk update serialization should return the input data.
+        """
+        data = [
+            {
+                'id': 0,
+                'title': 'The electric kool-aid acid test',
+                'author': 'Tom Wolfe'
+            }, {
+                'id': 'foo',
+                'title': 'Kafka on the shore',
+                'author': 'Haruki Murakami'
+            }
+        ]
+        expected_errors = [
+            {},
+            {'id': ['Enter a whole number.']}
+        ]
+        serializer = self.BookSerializer(self.books(), data=data, many=True)
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, expected_errors)
-- 
cgit v1.2.3


From 20fd738c856dfa21a0d2d251b92459d6641c782c Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 20 Mar 2013 13:05:59 +0000
Subject: iso formated datetime aware fields with +0000 offset should use 'Z'
 suffix instead

---
 rest_framework/fields.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/rest_framework/fields.py b/rest_framework/fields.py
index 4b6931ad..a0f52f50 100644
--- a/rest_framework/fields.py
+++ b/rest_framework/fields.py
@@ -609,7 +609,10 @@ class DateTimeField(WritableField):
             return None
 
         if self.format.lower() == ISO_8601:
-            return value.isoformat()
+            ret = value.isoformat()
+            if ret.endswith('+00:00'):
+                ret = ret[:-6] + 'Z'
+            return ret
         return value.strftime(self.format)
 
 
-- 
cgit v1.2.3


From 8adde506e865005a96cdeff996ec4b5b9bb73a8f Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 21 Mar 2013 08:41:54 +0000
Subject: Default date/time fields now return python date/time objects again by
 default

---
 docs/api-guide/fields.md           |  6 +++---
 docs/api-guide/settings.md         | 27 +++++++++++++++++-------
 rest_framework/fields.py           | 18 ++++++++--------
 rest_framework/tests/fields.py     | 43 ++++++++++++++++++++++++++++++++++++--
 rest_framework/tests/filterset.py  |  9 ++++----
 rest_framework/tests/pagination.py |  2 +-
 rest_framework/tests/serializer.py |  2 +-
 7 files changed, 79 insertions(+), 28 deletions(-)

diff --git a/docs/api-guide/fields.md b/docs/api-guide/fields.md
index 9a745cf1..63bd5b1a 100644
--- a/docs/api-guide/fields.md
+++ b/docs/api-guide/fields.md
@@ -199,7 +199,7 @@ If you want to override this behavior, you'll need to declare the `DateTimeField
 
 **Signature:** `DateTimeField(format=None, input_formats=None)`
 
-* `format` - A string representing the output format.  If not specified, the `DATETIME_FORMAT` setting will be used, which defaults to `'iso-8601'`.
+* `format` - A string representing the output format.  If not specified, this defaults to `None`, which indicates that python `datetime` objects should be returned by `to_native`.  In this case the datetime encoding will be determined by the renderer. 
 * `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `DATETIME_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`.
 
 DateTime format strings may either be [python strftime formats][strftime] which explicitly specifiy the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style datetimes should be used. (eg `'2013-01-29T12:34:56.000000'`)
@@ -212,7 +212,7 @@ Corresponds to `django.db.models.fields.DateField`
 
 **Signature:** `DateField(format=None, input_formats=None)`
 
-* `format` - A string representing the output format.  If not specified, the `DATE_FORMAT` setting will be used, which defaults to `'iso-8601'`.
+* `format` - A string representing the output format.  If not specified, this defaults to `None`, which indicates that python `date` objects should be returned by `to_native`.  In this case the date encoding will be determined by the renderer.
 * `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `DATE_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`. 
 
 Date format strings may either be [python strftime formats][strftime] which explicitly specifiy the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style dates should be used. (eg `'2013-01-29'`)
@@ -227,7 +227,7 @@ Corresponds to `django.db.models.fields.TimeField`
 
 **Signature:** `TimeField(format=None, input_formats=None)`
 
-* `format` - A string representing the output format.  If not specified, the `TIME_FORMAT` setting will be used, which defaults to `'iso-8601'`.
+* `format` - A string representing the output format.  If not specified, this defaults to `None`, which indicates that python `time` objects should be returned by `to_native`.  In this case the time encoding will be determined by the renderer.
 * `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `TIME_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`.
 
 Time format strings may either be [python strftime formats][strftime] which explicitly specifiy the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style times should be used. (eg `'12:34:56.000000'`)
diff --git a/docs/api-guide/settings.md b/docs/api-guide/settings.md
index 11638696..c0d8d9ee 100644
--- a/docs/api-guide/settings.md
+++ b/docs/api-guide/settings.md
@@ -192,44 +192,56 @@ Default: `'format'`
 
 ---
 
-## Date/Time formatting
+## Date and time formatting
 
 *The following settings are used to control how date and time representations may be parsed and rendered.*
 
 #### DATETIME_FORMAT
 
-A format string that should be used by default for rendering the output of `DateTimeField` serializer fields.
+A format string that should be used by default for rendering the output of `DateTimeField` serializer fields.  If `None`, then `DateTimeField` serializer fields will return python `datetime` objects, and the datetime encoding will be determined by the renderer.
 
-Default: `'iso-8601'`
+May be any of `None`, `'iso-8601'` or a python [strftime format][strftime] string.
+
+Default: `None'`
 
 #### DATETIME_INPUT_FORMATS
 
 A list of format strings that should be used by default for parsing inputs to `DateTimeField` serializer fields.
 
+May be a list including the string `'iso-8601'` or python [strftime format][strftime] strings.
+
 Default: `['iso-8601']`
 
 #### DATE_FORMAT
 
-A format string that should be used by default for rendering the output of `DateField` serializer fields.
+A format string that should be used by default for rendering the output of `DateField` serializer fields.  If `None`, then `DateField` serializer fields will return python `date` objects, and the date encoding will be determined by the renderer.
 
-Default: `'iso-8601'`
+May be any of `None`, `'iso-8601'` or a python [strftime format][strftime] string.
+
+Default: `None`
 
 #### DATE_INPUT_FORMATS
 
 A list of format strings that should be used by default for parsing inputs to `DateField` serializer fields.
 
+May be a list including the string `'iso-8601'` or python [strftime format][strftime] strings.
+
 Default: `['iso-8601']`
 
 #### TIME_FORMAT
 
-A format string that should be used by default for rendering the output of `TimeField` serializer fields.
+A format string that should be used by default for rendering the output of `TimeField` serializer fields.  If `None`, then `TimeField` serializer fields will return python `time` objects, and the time encoding will be determined by the renderer.
+
+May be any of `None`, `'iso-8601'` or a python [strftime format][strftime] string.
 
-Default: `'iso-8601'`
+Default: `None`
 
 #### TIME_INPUT_FORMATS
 
 A list of format strings that should be used by default for parsing inputs to `TimeField` serializer fields.
 
+May be a list including the string `'iso-8601'` or python [strftime format][strftime] strings.
+
 Default: `['iso-8601']`
 
 ---
@@ -243,3 +255,4 @@ The name of a parameter in the URL conf that may be used to provide a format suf
 Default: `'format'`
 
 [cite]: http://www.python.org/dev/peps/pep-0020/
+[strftime]: http://docs.python.org/2/library/time.html#time.strftime
\ No newline at end of file
diff --git a/rest_framework/fields.py b/rest_framework/fields.py
index a0f52f50..f3496b53 100644
--- a/rest_framework/fields.py
+++ b/rest_framework/fields.py
@@ -494,7 +494,7 @@ class DateField(WritableField):
     }
     empty = None
     input_formats = api_settings.DATE_INPUT_FORMATS
-    format = api_settings.DATE_FORMAT
+    format = None
 
     def __init__(self, input_formats=None, format=None, *args, **kwargs):
         self.input_formats = input_formats if input_formats is not None else self.input_formats
@@ -536,8 +536,8 @@ class DateField(WritableField):
         raise ValidationError(msg)
 
     def to_native(self, value):
-        if value is None:
-            return None
+        if value is None or self.format is None:
+            return value
 
         if isinstance(value, datetime.datetime):
             value = value.date()
@@ -557,7 +557,7 @@ class DateTimeField(WritableField):
     }
     empty = None
     input_formats = api_settings.DATETIME_INPUT_FORMATS
-    format = api_settings.DATETIME_FORMAT
+    format = None
 
     def __init__(self, input_formats=None, format=None, *args, **kwargs):
         self.input_formats = input_formats if input_formats is not None else self.input_formats
@@ -605,8 +605,8 @@ class DateTimeField(WritableField):
         raise ValidationError(msg)
 
     def to_native(self, value):
-        if value is None:
-            return None
+        if value is None or self.format is None:
+            return value
 
         if self.format.lower() == ISO_8601:
             ret = value.isoformat()
@@ -626,7 +626,7 @@ class TimeField(WritableField):
     }
     empty = None
     input_formats = api_settings.TIME_INPUT_FORMATS
-    format = api_settings.TIME_FORMAT
+    format = None
 
     def __init__(self, input_formats=None, format=None, *args, **kwargs):
         self.input_formats = input_formats if input_formats is not None else self.input_formats
@@ -661,8 +661,8 @@ class TimeField(WritableField):
         raise ValidationError(msg)
 
     def to_native(self, value):
-        if value is None:
-            return None
+        if value is None or self.format is None:
+            return value
 
         if isinstance(value, datetime.datetime):
             value = value.time()
diff --git a/rest_framework/tests/fields.py b/rest_framework/tests/fields.py
index fd6de779..19c663d8 100644
--- a/rest_framework/tests/fields.py
+++ b/rest_framework/tests/fields.py
@@ -153,12 +153,22 @@ class DateFieldTest(TestCase):
 
     def test_to_native(self):
         """
-        Make sure to_native() returns isoformat as default.
+        Make sure to_native() returns datetime as default.
         """
         f = serializers.DateField()
 
         result_1 = f.to_native(datetime.date(1984, 7, 31))
 
+        self.assertEqual(datetime.date(1984, 7, 31), result_1)
+
+    def test_to_native_iso(self):
+        """
+        Make sure to_native() with 'iso-8601' returns iso formated date.
+        """
+        f = serializers.DateField(format='iso-8601')
+
+        result_1 = f.to_native(datetime.date(1984, 7, 31))
+
         self.assertEqual('1984-07-31', result_1)
 
     def test_to_native_custom_format(self):
@@ -289,6 +299,22 @@ class DateTimeFieldTest(TestCase):
         result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59))
         result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200))
 
+        self.assertEqual(datetime.datetime(1984, 7, 31), result_1)
+        self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31), result_2)
+        self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59), result_3)
+        self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59, 200), result_4)
+
+    def test_to_native_iso(self):
+        """
+        Make sure to_native() with format=iso-8601 returns iso formatted datetime.
+        """
+        f = serializers.DateTimeField(format='iso-8601')
+
+        result_1 = f.to_native(datetime.datetime(1984, 7, 31))
+        result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31))
+        result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59))
+        result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200))
+
         self.assertEqual('1984-07-31T00:00:00', result_1)
         self.assertEqual('1984-07-31T04:31:00', result_2)
         self.assertEqual('1984-07-31T04:31:59', result_3)
@@ -419,13 +445,26 @@ class TimeFieldTest(TestCase):
 
     def test_to_native(self):
         """
-        Make sure to_native() returns isoformat as default.
+        Make sure to_native() returns time object as default.
         """
         f = serializers.TimeField()
         result_1 = f.to_native(datetime.time(4, 31))
         result_2 = f.to_native(datetime.time(4, 31, 59))
         result_3 = f.to_native(datetime.time(4, 31, 59, 200))
 
+        self.assertEqual(datetime.time(4, 31), result_1)
+        self.assertEqual(datetime.time(4, 31, 59), result_2)
+        self.assertEqual(datetime.time(4, 31, 59, 200), result_3)
+
+    def test_to_native_iso(self):
+        """
+        Make sure to_native() with format='iso-8601' returns iso formatted time.
+        """
+        f = serializers.TimeField(format='iso-8601')
+        result_1 = f.to_native(datetime.time(4, 31))
+        result_2 = f.to_native(datetime.time(4, 31, 59))
+        result_3 = f.to_native(datetime.time(4, 31, 59, 200))
+
         self.assertEqual('04:31:00', result_1)
         self.assertEqual('04:31:59', result_2)
         self.assertEqual('04:31:59.000200', result_3)
diff --git a/rest_framework/tests/filterset.py b/rest_framework/tests/filterset.py
index fe92e0bc..238da56e 100644
--- a/rest_framework/tests/filterset.py
+++ b/rest_framework/tests/filterset.py
@@ -65,7 +65,7 @@ class IntegrationTestFiltering(TestCase):
 
         self.objects = FilterableItem.objects
         self.data = [
-            {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date.isoformat()}
+            {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date}
             for obj in self.objects.all()
         ]
 
@@ -95,7 +95,7 @@ class IntegrationTestFiltering(TestCase):
         request = factory.get('/?date=%s' % search_date)  # search_date str: '2012-09-22'
         response = view(request).render()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if datetime.datetime.strptime(f['date'], '%Y-%m-%d').date() == search_date]
+        expected_data = [f for f in self.data if f['date'] == search_date]
         self.assertEqual(response.data, expected_data)
 
     @unittest.skipUnless(django_filters, 'django-filters not installed')
@@ -125,7 +125,7 @@ class IntegrationTestFiltering(TestCase):
         request = factory.get('/?date=%s' % search_date)  # search_date str: '2012-10-02'
         response = view(request).render()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if datetime.datetime.strptime(f['date'], '%Y-%m-%d').date() > search_date]
+        expected_data = [f for f in self.data if f['date'] > search_date]
         self.assertEqual(response.data, expected_data)
 
         # Tests that the text filter set with 'icontains' in the filter class works.
@@ -142,8 +142,7 @@ class IntegrationTestFiltering(TestCase):
         request = factory.get('/?decimal=%s&date=%s' % (search_decimal, search_date))
         response = view(request).render()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if
-                         datetime.datetime.strptime(f['date'], '%Y-%m-%d').date() > search_date and
+        expected_data = [f for f in self.data if f['date'] > search_date and
                          f['decimal'] < search_decimal]
         self.assertEqual(response.data, expected_data)
 
diff --git a/rest_framework/tests/pagination.py b/rest_framework/tests/pagination.py
index 1a2d68a6..d2c9b051 100644
--- a/rest_framework/tests/pagination.py
+++ b/rest_framework/tests/pagination.py
@@ -102,7 +102,7 @@ class IntegrationTestPaginationAndFiltering(TestCase):
 
         self.objects = FilterableItem.objects
         self.data = [
-            {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date.isoformat()}
+            {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date}
             for obj in self.objects.all()
         ]
 
diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index beb372c2..d0799b85 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -112,7 +112,7 @@ class BasicTests(TestCase):
         self.expected = {
             'email': 'tom@example.com',
             'content': 'Happy new year!',
-            'created': '2012-01-01T00:00:00',
+            'created': datetime.datetime(2012, 1, 1),
             'sub_comment': 'And Merry Christmas!'
         }
         self.person_data = {'name': 'dwight', 'age': 35}
-- 
cgit v1.2.3


From c32d9969acaebc83ad1e2dd888d4a2829c35571e Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 22 Mar 2013 12:33:09 +0000
Subject: Add extra tests for errors from incorrect data with multiple
 create/update

---
 rest_framework/serializers.py                  | 36 ++++++++++------
 rest_framework/tests/serializer_bulk_update.py | 60 +++++++++++++++++++++++++-
 2 files changed, 81 insertions(+), 15 deletions(-)

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 34120dc6..3029cf1c 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -371,22 +371,30 @@ class BaseSerializer(Field):
                     identities = [self.get_identity(self.to_native(obj)) for obj in objects]
                     identity_to_objects = dict(zip(identities, objects))
 
-                for item in data:
-                    if update:
-                        # Determine which object we're updating
-                        try:
-                            identity = self.get_identity(item)
-                        except:
-                            self.object = None
-                        else:
-                            self.object = identity_to_objects.pop(identity, None)
+                try:
+                    iter(data)
+                    if isinstance(data, dict):
+                        raise TypeError
+                except TypeError:
+                    self._errors = {'non_field_errors': ['Expected a list of items']}
+                else:
+                    for item in data:
+                        if update:
+                            # Determine which object we're updating
+                            try:
+                                identity = self.get_identity(item)
+                            except:
+                                self.object = None
+                            else:
+                                self.object = identity_to_objects.pop(identity, None)
+
+                        ret.append(self.from_native(item, None))
+                        errors.append(self._errors)
 
-                    ret.append(self.from_native(item, None))
-                    errors.append(self._errors)
+                    if update:
+                        self._deleted = identity_to_objects.values()
 
-                if update:
-                    self._deleted = identity_to_objects.values()
-                self._errors = any(errors) and errors or []
+                    self._errors = any(errors) and errors or []
             else:
                 ret = self.from_native(data, files)
 
diff --git a/rest_framework/tests/serializer_bulk_update.py b/rest_framework/tests/serializer_bulk_update.py
index 66fca883..2f416488 100644
--- a/rest_framework/tests/serializer_bulk_update.py
+++ b/rest_framework/tests/serializer_bulk_update.py
@@ -7,6 +7,9 @@ from rest_framework import serializers
 
 
 class BulkCreateSerializerTests(TestCase):
+    """
+    Creating multiple instances using serializers.
+    """
 
     def setUp(self):
         class BookSerializer(serializers.Serializer):
@@ -71,11 +74,63 @@ class BulkCreateSerializerTests(TestCase):
         self.assertEqual(serializer.is_valid(), False)
         self.assertEqual(serializer.errors, expected_errors)
 
+    def test_invalid_list_datatype(self):
+        """
+        Data containing list of incorrect data type should return errors.
+        """
+        data = ['foo', 'bar', 'baz']
+        serializer = self.BookSerializer(data=data, many=True)
+        self.assertEqual(serializer.is_valid(), False)
+
+        expected_errors = [
+                {'non_field_errors': ['Invalid data']},
+                {'non_field_errors': ['Invalid data']},
+                {'non_field_errors': ['Invalid data']}
+        ]
+
+        self.assertEqual(serializer.errors, expected_errors)
+
+    def test_invalid_single_datatype(self):
+        """
+        Data containing a single incorrect data type should return errors.
+        """
+        data = 123
+        serializer = self.BookSerializer(data=data, many=True)
+        self.assertEqual(serializer.is_valid(), False)
+
+        expected_errors = {'non_field_errors': ['Expected a list of items']}
+
+        self.assertEqual(serializer.errors, expected_errors)
+
+    def test_invalid_single_object(self):
+        """
+        Data containing only a single object, instead of a list of objects
+        should return errors.
+        """
+        data = {
+            'id': 0,
+            'title': 'The electric kool-aid acid test',
+            'author': 'Tom Wolfe'
+        }
+        serializer = self.BookSerializer(data=data, many=True)
+        self.assertEqual(serializer.is_valid(), False)
+
+        expected_errors = {'non_field_errors': ['Expected a list of items']}
+
+        self.assertEqual(serializer.errors, expected_errors)
+
 
 class BulkUpdateSerializerTests(TestCase):
+    """
+    Updating multiple instances using serializers.
+    """
 
     def setUp(self):
         class Book(object):
+            """
+            A data type that can be persisted to a mock storage backend
+            with `.save()` and `.delete()`.
+            """
             object_map = {}
 
             def __init__(self, id, title, author):
@@ -126,6 +181,9 @@ class BulkUpdateSerializerTests(TestCase):
             book.save()
 
     def books(self):
+        """
+        Return all the objects in the mock storage backend.
+        """
         return self.Book.object_map.values()
 
     def test_bulk_update_success(self):
@@ -152,7 +210,7 @@ class BulkUpdateSerializerTests(TestCase):
 
     def test_bulk_update_error(self):
         """
-        Correct bulk update serialization should return the input data.
+        Incorrect bulk update serialization should return error data.
         """
         data = [
             {
-- 
cgit v1.2.3


From b4210f9a56fb7f8913f674aecb304da01e2e9f64 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 22 Mar 2013 12:46:03 +0000
Subject: Test moved out of serializer.py into serializer_bulk_update

---
 rest_framework/tests/serializer.py | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 9c0fdd78..1ee671dc 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -261,34 +261,6 @@ class ValidationTests(TestCase):
         self.assertEqual(serializer.is_valid(), True)
         self.assertEqual(serializer.errors, {})
 
-    def test_bad_type_data_is_false(self):
-        """
-        Data of the wrong type is not valid.
-        """
-        data = ['i am', 'a', 'list']
-        serializer = CommentSerializer([self.comment], data=data, many=True)
-        self.assertEqual(serializer.is_valid(), False)
-        self.assertTrue(isinstance(serializer.errors, list))
-
-        self.assertEqual(
-            serializer.errors,
-            [
-                {'non_field_errors': ['Invalid data']},
-                {'non_field_errors': ['Invalid data']},
-                {'non_field_errors': ['Invalid data']}
-            ]
-        )
-
-        data = 'and i am a string'
-        serializer = CommentSerializer(self.comment, data=data)
-        self.assertEqual(serializer.is_valid(), False)
-        self.assertEqual(serializer.errors, {'non_field_errors': ['Invalid data']})
-
-        data = 42
-        serializer = CommentSerializer(self.comment, data=data)
-        self.assertEqual(serializer.is_valid(), False)
-        self.assertEqual(serializer.errors, {'non_field_errors': ['Invalid data']})
-
     def test_cross_field_validation(self):
 
         class CommentSerializerWithCrossFieldValidator(CommentSerializer):
-- 
cgit v1.2.3


From 13794baf7016f7d44daffb55d29e3dbc56f7612d Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 22 Mar 2013 17:01:06 +0000
Subject: Bit of extra tidying and plenty of docs

---
 docs/api-guide/fields.md                       |  43 ++++++
 docs/api-guide/serializers.md                  | 189 ++++++++++++++++---------
 rest_framework/serializers.py                  |  49 ++++---
 rest_framework/tests/serializer_bulk_update.py |  26 +++-
 4 files changed, 225 insertions(+), 82 deletions(-)

diff --git a/docs/api-guide/fields.md b/docs/api-guide/fields.md
index 9a745cf1..4d73eec7 100644
--- a/docs/api-guide/fields.md
+++ b/docs/api-guide/fields.md
@@ -273,6 +273,49 @@ Django's regular [FILE_UPLOAD_HANDLERS] are used for handling uploaded files.
 
 ---
 
+# Custom fields
+
+If you want to create a custom field, you'll probably want to override either one or both of the `.to_native()` and `.from_native()` methods.  These two methods are used to convert between the intial datatype, and a primative, serializable datatype.  Primative datatypes may be any of a number, string, date/time/datetime or None.  They may also be any list or dictionary like object that only contains other primative objects.
+
+The `.to_native()` method is called to convert the initial datatype into a primative, serializable datatype.  The `from_native()` method is called to restore a primative datatype into it's initial representation.
+
+## Examples
+
+Let's look at an example of serializing a class that represents an RGB color value:
+
+    class Color(object):
+        """
+        A color represented in the RGB colorspace.
+        """
+        def __init__(self, red, green, blue):
+            assert(red >= 0 and green >= 0 and blue >= 0)
+            assert(red < 256 and green < 256 and blue < 256)
+            self.red, self.green, self.blue = red, green, blue
+
+    class ColourField(serializers.WritableField):
+        """
+        Color objects are serialized into "rgb(#, #, #)" notation.
+        """
+        def to_native(self, obj):
+            return "rgb(%d, %d, %d)" % (obj.red, obj.green, obj.blue)
+      
+        def from_native(self, data):
+            data = data.strip('rgb(').rstrip(')')
+            red, green, blue = [int(col) for col in data.split(',')]
+            return Color(red, green, blue)
+            
+
+By default field values are treated as mapping to an attribute on the object.  If you need to customize how the field value is accessed and set you need to override `.field_to_native()` and/or `.field_from_native()`.
+
+As an example, let's create a field that can be used represent the class name of the object being serialized:
+
+    class ClassNameField(serializers.Field):
+        def field_to_native(self, obj, field_name):
+            """
+            Serialize the object's class name.
+            """
+            return obj.__class__
+
 [cite]: https://docs.djangoproject.com/en/dev/ref/forms/api/#django.forms.Form.cleaned_data
 [FILE_UPLOAD_HANDLERS]: https://docs.djangoproject.com/en/dev/ref/settings/#std:setting-FILE_UPLOAD_HANDLERS
 [strftime]: http://docs.python.org/2/library/datetime.html#strftime-and-strptime-behavior
diff --git a/docs/api-guide/serializers.md b/docs/api-guide/serializers.md
index ee7208a3..42e81cad 100644
--- a/docs/api-guide/serializers.md
+++ b/docs/api-guide/serializers.md
@@ -87,27 +87,21 @@ By default, serializers must be passed values for all required fields or they wi
 
     serializer = CommentSerializer(comment, data={'content': u'foo bar'}, partial=True)  # Update `instance` with partial data
 
-## Serializing multiple objects
-
-To serialize a queryset or list of objects instead of a single object instance, you should pass the `many=True` flag when instantiating the serializer.
-
-    queryset = Comment.objects.all()
-    serializer = CommentSerializer(queryset, many=True)
-    serializer.data
-    # [
-    #     {'email': u'leila@example.com', 'content': u'foo bar', 'created': datetime.datetime(2012, 8, 22, 16, 20, 9, 822774)},
-    #     {'email': u'jamie@example.com', 'content': u'baz', 'created': datetime.datetime(2013, 1, 12, 16, 12, 45, 104445)}
-    # ]
-
 ## Validation
 
-When deserializing data, you always need to call `is_valid()` before attempting to access the deserialized object.  If any validation errors occur, the `.errors` property will contain a dictionary representing the resulting error messages.
+When deserializing data, you always need to call `is_valid()` before attempting to access the deserialized object.  If any validation errors occur, the `.errors` property will contain a dictionary representing the resulting error messages.  For example:
+
+    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.']}
 
 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 `non_field_errors` key may also be present, and will list any general validation errors.
 
 When deserializing a list of items, errors will be returned as a list of dictionaries representing each of the deserialized items.
 
-### Field-level validation
+#### Field-level validation
 
 You can specify custom field-level validation by adding `.validate_<fieldname>` methods to your `Serializer` subclass. These are analagous to `.clean_<fieldname>` methods on Django forms, but accept slightly different arguments.
 
@@ -130,7 +124,7 @@ Your `validate_<fieldname>` methods should either just return the `attrs` dictio
                 raise serializers.ValidationError("Blog post is not about Django")
             return attrs
 
-### Object-level validation
+#### Object-level validation
 
 To do any other validation that requires access to multiple fields, add a method called `.validate()` to your `Serializer` subclass. This method takes a single argument, which is the `attrs` dictionary. It should raise a `ValidationError` if necessary, or just return `attrs`.  For example:
 
@@ -151,26 +145,44 @@ To do any other validation that requires access to multiple fields, add a method
 
 ## Saving object state
 
-Serializers also include a `.save()` method that you can override if you want to provide a method of persisting the state of a deserialized object.  The default behavior of the method is to simply call `.save()` on the deserialized object instance.
+To save the deserialized objects created by a serializer, call the `.save()` method:
+
+    if serializer.is_valid():
+        serializer.save()
+
+The default behavior of the method is to simply call `.save()` on the deserialized object instance.  You can override the default save behaviour by overriding the `.save_object(obj)` method on the serializer class.
 
 The generic views provided by REST framework call the `.save()` method when updating or creating entities.  
 
 ## Dealing with nested objects
 
-The previous example is 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.
+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.
 
 The `Serializer` class is itself a type of `Field`, and can be used to represent relationships where one object type is nested inside another.
 
     class UserSerializer(serializers.Serializer):
-        email = serializers.Field()
-        username = serializers.Field()
+        email = serializers.EmailField()
+        username = serializers.CharField(max_length=100)
 
     class CommentSerializer(serializers.Serializer):
         user = UserSerializer()
-        title = serializers.Field()
-        content = serializers.Field()
-        created = serializers.Field()
+        content = serializers.CharField(max_length=200)
+        created = serializers.DateTimeField()
+
+If a nested representation may optionally accept the `None` value you should pass the `required=False` flag to the nested serializer.
+
+    class CommentSerializer(serializers.Serializer):
+        user = UserSerializer(required=False)  # May be an anonymous user.
+        content = serializers.CharField(max_length=200)
+        created = serializers.DateTimeField()
+
+Similarly if a nested representation should be a list of items, you should the `many=True` flag to the nested serialized.
+
+    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()
 
 ---
 
@@ -178,58 +190,107 @@ The `Serializer` class is itself a type of `Field`, and can be used to represent
 
 ---
 
-## Including extra context
+## Dealing with multiple objects
 
-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.
+The `Serializer` class can also handle serializing or deserializing lists of objects.
 
-You can provide arbitrary additional context by passing a `context` argument when instantiating the serializer. For example:
+#### Serializing multiple objects
 
-    serializer = AccountSerializer(account, context={'request': request})
+To serialize a queryset or list of objects instead of a single object instance, you should pass the `many=True` flag when instantiating the serializer.  You can then pass a queryset or list of objects to be serialized.
+
+    queryset = Book.objects.all()
+    serializer = BookSerializer(queryset, many=True)
     serializer.data
-    # {'id': 6, 'owner': u'denvercoder9', 'created': datetime.datetime(2013, 2, 12, 09, 44, 56, 678870), 'details': 'http://example.com/accounts/6/details'}
+    # [
+    #     {'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'}
+    # ]
 
-The context dictionary can be used within any serializer field logic, such as a custom `.to_native()` method, by accessing the `self.context` attribute.
+#### Deserializing multiple objects for creation
 
-## Creating custom fields
-
-If you want to create a custom field, you'll probably want to override either one or both of the `.to_native()` and `.from_native()` methods.  These two methods are used to convert between the intial datatype, and a primative, serializable datatype.  Primative datatypes may be any of a number, string, date/time/datetime or None.  They may also be any list or dictionary like object that only contains other primative objects.
-
-The `.to_native()` method is called to convert the initial datatype into a primative, serializable datatype.  The `from_native()` method is called to restore a primative datatype into it's initial representation.
-
-Let's look at an example of serializing a class that represents an RGB color value:
-
-    class Color(object):
-        """
-        A color represented in the RGB colorspace.
-        """
-        def __init__(self, red, green, blue):
-            assert(red >= 0 and green >= 0 and blue >= 0)
-            assert(red < 256 and green < 256 and blue < 256)
-            self.red, self.green, self.blue = red, green, blue
-
-    class ColourField(serializers.WritableField):
-        """
-        Color objects are serialized into "rgb(#, #, #)" notation.
-        """
-        def to_native(self, obj):
-            return "rgb(%d, %d, %d)" % (obj.red, obj.green, obj.blue)
-      
-        def from_native(self, data):
-            data = data.strip('rgb(').rstrip(')')
-            red, green, blue = [int(col) for col in data.split(',')]
-            return Color(red, green, blue)
-            
+To deserialize a list of object data, and create multiple object instances in a single pass, you should also set the `many=True` flag, and pass a list of data to be deserialized.
+
+This allows you to write views that create multiple items when a `POST` request is made.
 
-By default field values are treated as mapping to an attribute on the object.  If you need to customize how the field value is accessed and set you need to override `.field_to_native()` and/or `.field_from_native()`.
+For example:
+
+    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
+
+#### Deserializing multiple objects for update
+
+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.
+
+This allows you to write views that update or create multiple items when a `PUT` request is made.
+
+    # 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
+    serialize.save()  # `.save()` will be called on each updated or newly created instance.
+
+Bulk updates will update any instances that already exist, and create new instances for data items that do not have a corresponding instance.
+
+When performing a bulk update you may want any items that are not present in the incoming data to be deleted.  To do so, pass `allow_delete=True` to the serializer.
+
+    serializer = BookSerializer(queryset, data=data, many=True, allow_delete=True)
+    serializer.is_valid()
+    # True
+    serializer.save()  # `.save()` will be called on each updated or newly created instance.
+                       # `.delete()` will be called on any other items in the `queryset`.
+
+Passing `allow_delete=True` ensures that any update operations will completely overwrite the existing queryset, rather than simply updating any objects found in the incoming data. 
+
+#### How identity is determined when performing bulk updates
 
-As an example, let's create a field that can be used represent the class name of the object being serialized:
+Performing a bulk update is slightly more complicated than performing a bulk creation, because the serializer needs a way of determining how the items in the incoming data should be matched against the existing object instances.
 
-    class ClassNameField(serializers.Field):
-        def field_to_native(self, obj, field_name):
+By default the serializer class will use the `id` key on the incoming data to determine the canonical identity of an object.  If you need to change this behavior you should override the `get_identity` method on the `Serializer` class.  For example:
+
+    class AccountSerializer(serializers.Serializer):
+        slug = serializers.CharField(max_length=100)
+        created = serializers.DateTimeField()
+        ...  # Various other fields
+        
+        def get_identity(self, data):
             """
-            Serialize the object's class name.
+            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.
             """
-            return obj.__class__
+            try:
+                return data.get('slug', None)
+            except AttributeError:
+                return None
+
+To map the incoming data items to their corresponding object instances, the `.get_identity()` method will be called both against the incoming data, and against the serialized representation of the existing objects.
+
+## Including extra context
+
+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.
+
+You can provide arbitrary additional context by passing a `context` argument when instantiating the serializer. For example:
+
+    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'}
+
+The context dictionary can be used within any serializer field logic, such as a custom `.to_native()` method, by accessing the `self.context` attribute.
 
 ---
 
diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 3029cf1c..0b0c2c9c 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -110,13 +110,15 @@ class BaseSerializer(Field):
     _dict_class = SortedDictWithMetadata
 
     def __init__(self, instance=None, data=None, files=None,
-                 context=None, partial=False, many=None, source=None):
+                 context=None, partial=False, many=None, source=None,
+                 allow_delete=False):
         super(BaseSerializer, self).__init__(source=source)
         self.opts = self._options_class(self.Meta)
         self.parent = None
         self.root = None
         self.partial = partial
         self.many = many
+        self.allow_delete = allow_delete
 
         self.context = context or {}
 
@@ -130,6 +132,12 @@ class BaseSerializer(Field):
         self._errors = None
         self._deleted = None
 
+        if many and instance is not None and not hasattr(instance, '__iter__'):
+            raise ValueError('instance should be a queryset or other iterable with many=True')
+
+        if allow_delete and not many:
+            raise ValueError('allow_delete should only be used for bulk updates, but you have not set many=True')
+
     #####
     # Methods to determine which fields to use when (de)serializing objects.
 
@@ -336,8 +344,15 @@ class BaseSerializer(Field):
         """
         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.
         """
-        return data.get('id')
+        try:
+            return data.get('id', None)
+        except AttributeError:
+            return None
 
     @property
     def errors(self):
@@ -371,22 +386,12 @@ class BaseSerializer(Field):
                     identities = [self.get_identity(self.to_native(obj)) for obj in objects]
                     identity_to_objects = dict(zip(identities, objects))
 
-                try:
-                    iter(data)
-                    if isinstance(data, dict):
-                        raise TypeError
-                except TypeError:
-                    self._errors = {'non_field_errors': ['Expected a list of items']}
-                else:
+                if hasattr(data, '__iter__') and not isinstance(data, (dict, six.text_type)):
                     for item in data:
                         if update:
                             # Determine which object we're updating
-                            try:
-                                identity = self.get_identity(item)
-                            except:
-                                self.object = None
-                            else:
-                                self.object = identity_to_objects.pop(identity, None)
+                            identity = self.get_identity(item)
+                            self.object = identity_to_objects.pop(identity, None)
 
                         ret.append(self.from_native(item, None))
                         errors.append(self._errors)
@@ -395,6 +400,8 @@ class BaseSerializer(Field):
                         self._deleted = identity_to_objects.values()
 
                     self._errors = any(errors) and errors or []
+                else:
+                    self._errors = {'non_field_errors': ['Expected a list of items']}
             else:
                 ret = self.from_native(data, files)
 
@@ -445,7 +452,7 @@ class BaseSerializer(Field):
         else:
             self.save_object(self.object, **kwargs)
 
-        if self._deleted:
+        if self.allow_delete and self._deleted:
             [self.delete_object(item) for item in self._deleted]
 
         return self.object
@@ -736,3 +743,13 @@ class HyperlinkedModelSerializer(ModelSerializer):
             'many': to_many
         }
         return HyperlinkedRelatedField(**kwargs)
+
+    def get_identity(self, data):
+        """
+        This hook is required for bulk update.
+        We need to override the default, to use the url as the identity.
+        """
+        try:
+            return data.get('url', None)
+        except AttributeError:
+            return None
diff --git a/rest_framework/tests/serializer_bulk_update.py b/rest_framework/tests/serializer_bulk_update.py
index 2f416488..afc1a1a9 100644
--- a/rest_framework/tests/serializer_bulk_update.py
+++ b/rest_framework/tests/serializer_bulk_update.py
@@ -201,7 +201,29 @@ class BulkUpdateSerializerTests(TestCase):
                 'author': 'Haruki Murakami'
             }
         ]
-        serializer = self.BookSerializer(self.books(), data=data, many=True)
+        serializer = self.BookSerializer(self.books(), data=data, many=True, allow_delete=True)
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.data, data)
+        serializer.save()
+        new_data = self.BookSerializer(self.books(), many=True).data
+        self.assertEqual(data, new_data)
+
+    def test_bulk_update_and_create(self):
+        """
+        Bulk update serialization may also include created items.
+        """
+        data = [
+            {
+                'id': 0,
+                'title': 'The electric kool-aid acid test',
+                'author': 'Tom Wolfe'
+            }, {
+                'id': 3,
+                'title': 'Kafka on the shore',
+                'author': 'Haruki Murakami'
+            }
+        ]
+        serializer = self.BookSerializer(self.books(), data=data, many=True, allow_delete=True)
         self.assertEqual(serializer.is_valid(), True)
         self.assertEqual(serializer.data, data)
         serializer.save()
@@ -227,6 +249,6 @@ class BulkUpdateSerializerTests(TestCase):
             {},
             {'id': ['Enter a whole number.']}
         ]
-        serializer = self.BookSerializer(self.books(), data=data, many=True)
+        serializer = self.BookSerializer(self.books(), data=data, many=True, allow_delete=True)
         self.assertEqual(serializer.is_valid(), False)
         self.assertEqual(serializer.errors, expected_errors)
-- 
cgit v1.2.3


From 4055129662023a13c40ccea108a990b818d244cd Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 22 Mar 2013 21:31:32 +0000
Subject: If oauth is not attempted don't throw an error.  Fixes #748.

---
 rest_framework/authentication.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rest_framework/authentication.py b/rest_framework/authentication.py
index b4b73699..8f4ec536 100644
--- a/rest_framework/authentication.py
+++ b/rest_framework/authentication.py
@@ -204,6 +204,9 @@ class OAuthAuthentication(BaseAuthentication):
         except oauth.Error as err:
             raise exceptions.AuthenticationFailed(err.message)
 
+        if not oauth_request:
+            return None
+
         oauth_params = oauth_provider.consts.OAUTH_PARAMETERS_NAMES
 
         found = any(param for param in oauth_params if param in oauth_request)
-- 
cgit v1.2.3


From 9a2ba4bf54d72452c2800bb3e51ea718a72250bc Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 22 Mar 2013 21:37:51 +0000
Subject: Update release notes

---
 docs/topics/release-notes.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docs/topics/release-notes.md b/docs/topics/release-notes.md
index c45fff88..f506c610 100644
--- a/docs/topics/release-notes.md
+++ b/docs/topics/release-notes.md
@@ -42,6 +42,8 @@ You can determine your currently installed version using `pip freeze`:
 
 ### Master
 
+* Regression fix: Date and time fields return date/time objects by default.  Fixes regressions caused by 2.2.2.  See [#743][743] for more details.
+* Bugfix: Fix 500 error is OAuth not attempted with OAuthAuthentication class installed.
 * `Serializer.save()` now supports arbitrary keyword args which are passed through to the object `.save()` method.  Mixins use `force_insert` and `force_update` where appropriate, resulting in one less database query.
 
 ### 2.2.4
@@ -434,6 +436,7 @@ This change will not affect user code, so long as it's following the recommended
 [django-deprecation-policy]: https://docs.djangoproject.com/en/dev/internals/release-process/#internal-release-deprecation-policy
 [defusedxml-announce]: http://blog.python.org/2013/02/announcing-defusedxml-fixes-for-xml.html
 [2.2-announcement]: 2.2-announcement.md
+[743]: https://github.com/tomchristie/django-rest-framework/pull/743
 [staticfiles14]: https://docs.djangoproject.com/en/1.4/howto/static-files/#with-a-template-tag
 [staticfiles13]: https://docs.djangoproject.com/en/1.3/howto/static-files/#with-a-template-tag
 [2.1.0-notes]: https://groups.google.com/d/topic/django-rest-framework/Vv2M0CMY9bg/discussion
-- 
cgit v1.2.3