Merge datetime formats

docs/api-guide/fields.md

@@ -185,12 +185,22 @@ Corresponds to `django.forms.fields.RegexField`
 
 A date representation.
 
+Optionally takes `format` as parameter to replace the matching pattern.
+
 Corresponds to `django.db.models.fields.DateField`
 
+**Signature:** `DateField(input_formats=None, output_format=False)`
+
+ - `input_formats` designates which input formats are supported. This will override the `DATE_INPUT_FORMATS`
+
+ - `output_format` designates which output format will be used. This will override the `DATE_OUTPUT_FORMAT`
+
 ## DateTimeField
 
 A date and time representation.
 
+Optionally takes `format` as parameter to replace the matching pattern.
+
 Corresponds to `django.db.models.fields.DateTimeField`
 
 When using `ModelSerializer` or `HyperlinkedModelSerializer`, note that any model fields with `auto_now=True` or `auto_now_add=True` will use serializer fields that are `read_only=True` by default.
@@ -203,12 +213,26 @@ If you want to override this behavior, you'll need to declare the `DateTimeField
         class Meta:
             model = Comment
 
+**Signature:** `DateTimeField(input_formats=None, output_format=False)`
+
+ - `input_formats` designates which input formats are supported. This will override the `DATETIME_INPUT_FORMATS`
+
+ - `output_format` designates which output format will be used. This will override the `DATETIME_OUTPUT_FORMAT`
+
 ## TimeField
 
 A time representation.
 
+Optionally takes `format` as parameter to replace the matching pattern.
+
 Corresponds to `django.db.models.fields.TimeField`
 
+**Signature:** `TimeField(input_formats=None, output_format=False)`
+
+ - `input_formats` designates which input formats are supported. This will override the `TIME_INPUT_FORMATS`
+
+ - `output_format` designates which output format will be used. This will override the `TIME_OUTPUT_FORMAT`
+
 ## IntegerField
 
 An integer representation.

docs/api-guide/settings.md

@@ -174,4 +174,28 @@ The name of a parameter in the URL conf that may be used to provide a format suf
 
 Default: `'format'`
 
+## DATE_INPUT_FORMATS
+
+Default: `ISO8601`
+
+## DATE_OUTPUT_FORMAT
+
+Default: `ISO8601`
+
+## DATETIME_INPUT_FORMATS
+
+Default: `ISO8601`
+
+## DATETIME_OUTPUT_FORMAT
+
+Default: `ISO8601`
+
+## TIME_INPUT_FORMATS
+
+Default: `ISO8601`
+
+## TIME_OUTPUT_FORMAT
+
+Default: `ISO8601`
+
 [cite]: http://www.python.org/dev/peps/pep-0020/

docs/topics/release-notes.md

@@ -42,7 +42,8 @@ You can determine your currently installed version using `pip freeze`:
 
 ### Master
 
-* Request authentication is no longer lazily evaluated, instead authentication is always run, which results in more consistent, obvious behavior.  Eg. Supplying bad auth credentials will now always return an error response, even if no permissions are set on the view.
+* Support for custom input and output formats for `DateField`, `DateTimeField` and `TimeField`
+* Cleanup: Request authentication is no longer lazily evaluated, instead authentication is always run, which results in more consistent, obvious behavior.  Eg. Supplying bad auth credentials will now always return an error response, even if no permissions are set on the view.
 * Bugfix for serializer data being uncacheable with pickle protocol 0.
 * Bugfixes for model field validation edge-cases.
 * Bugfix for authtoken migration while using a custom user model and south.

rest_framework/__init__.py

@@ -4,3 +4,6 @@ VERSION = __version__  # synonym
 
 # Header encoding (see RFC5987)
 HTTP_HEADER_ENCODING = 'iso-8859-1'
+
+# Default input and output format
+ISO8601 = 'iso-8601'
\ No newline at end of file

rest_framework/fields.py

@@ -13,12 +13,14 @@ from django import forms
 from django.forms import widgets
 from django.utils.encoding import is_protected_type
 from django.utils.translation import ugettext_lazy as _
-from rest_framework.compat import parse_date, parse_datetime
-from rest_framework.compat import timezone
+
+from rest_framework import ISO8601
+from rest_framework.compat import timezone, parse_date, parse_datetime, parse_time
 from rest_framework.compat import BytesIO
 from rest_framework.compat import six
 from rest_framework.compat import smart_text
-from rest_framework.compat import parse_time
+from rest_framework.settings import api_settings
+from rest_framework.utils.dates import get_readable_date_format
 
 
 def is_simple_callable(obj):
@@ -447,12 +449,16 @@ class DateField(WritableField):
     form_field_class = forms.DateField
 
     default_error_messages = {
-        'invalid': _("'%s' value has an invalid date format. It must be "
-                     "in YYYY-MM-DD format."),
-        'invalid_date': _("'%s' value has the correct format (YYYY-MM-DD) "
-                          "but it is an invalid date."),
+        'invalid': _("Date has wrong format. Use one of these formats instead: %s"),
     }
     empty = None
+    input_formats = api_settings.DATE_INPUT_FORMATS
+    output_format = api_settings.DATE_OUTPUT_FORMAT
+
+    def __init__(self, input_formats=None, output_format=None, *args, **kwargs):
+        self.input_formats = input_formats if input_formats is not None else self.input_formats
+        self.output_format = output_format if output_format is not None else self.output_format
+        super(DateField, self).__init__(*args, **kwargs)
 
     def from_native(self, value):
         if value in validators.EMPTY_VALUES:
@@ -468,17 +474,34 @@ class DateField(WritableField):
         if isinstance(value, datetime.date):
             return value
 
+        for format in self.input_formats:
+            if format.lower() == ISO8601:
                 try:
                     parsed = parse_date(value)
+                except (ValueError, TypeError):
+                    pass
+                else:
                     if parsed is not None:
                         return parsed
+            else:
+                try:
+                    parsed = datetime.datetime.strptime(value, format)
                 except (ValueError, TypeError):
-            msg = self.error_messages['invalid_date'] % value
-            raise ValidationError(msg)
+                    pass
+                else:
+                    return parsed.date()
 
-        msg = self.error_messages['invalid'] % value
+        date_input_formats = '; '.join(self.input_formats).replace(ISO8601, 'YYYY-MM-DD')
+        msg = self.error_messages['invalid'] % get_readable_date_format(date_input_formats)
         raise ValidationError(msg)
 
+    def to_native(self, value):
+        if isinstance(value, datetime.datetime):
+            value = value.date()
+        if self.output_format.lower() == ISO8601:
+            return value.isoformat()
+        return value.strftime(self.output_format)
+
 
 class DateTimeField(WritableField):
     type_name = 'DateTimeField'
@@ -486,15 +509,16 @@ class DateTimeField(WritableField):
     form_field_class = forms.DateTimeField
 
     default_error_messages = {
-        'invalid': _("'%s' value has an invalid format. It must be in "
-                     "YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] format."),
-        'invalid_date': _("'%s' value has the correct format "
-                          "(YYYY-MM-DD) but it is an invalid date."),
-        'invalid_datetime': _("'%s' value has the correct format "
-                              "(YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]) "
-                              "but it is an invalid date/time."),
+        'invalid': _("Datetime has wrong format. Use one of these formats instead: %s"),
     }
     empty = None
+    input_formats = api_settings.DATETIME_INPUT_FORMATS
+    output_format = api_settings.DATETIME_OUTPUT_FORMAT
+
+    def __init__(self, input_formats=None, output_format=None, *args, **kwargs):
+        self.input_formats = input_formats if input_formats is not None else self.input_formats
+        self.output_format = output_format if output_format is not None else self.output_format
+        super(DateTimeField, self).__init__(*args, **kwargs)
 
     def from_native(self, value):
         if value in validators.EMPTY_VALUES:
@@ -516,25 +540,32 @@ class DateTimeField(WritableField):
                 value = timezone.make_aware(value, default_timezone)
             return value
 
+        for format in self.input_formats:
+            if format.lower() == ISO8601:
                 try:
                     parsed = parse_datetime(value)
+                except (ValueError, TypeError):
+                    pass
+                else:
                     if parsed is not None:
                         return parsed
-        except (ValueError, TypeError):
-            msg = self.error_messages['invalid_datetime'] % value
-            raise ValidationError(msg)
-
+            else:
                 try:
-            parsed = parse_date(value)
-            if parsed is not None:
-                return datetime.datetime(parsed.year, parsed.month, parsed.day)
+                    parsed = datetime.datetime.strptime(value, format)
                 except (ValueError, TypeError):
-            msg = self.error_messages['invalid_date'] % value
-            raise ValidationError(msg)
+                    pass
+                else:
+                    return parsed
 
-        msg = self.error_messages['invalid'] % value
+        datetime_input_formats = '; '.join(self.input_formats).replace(ISO8601, 'YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]')
+        msg = self.error_messages['invalid'] % get_readable_date_format(datetime_input_formats)
         raise ValidationError(msg)
 
+    def to_native(self, value):
+        if self.output_format.lower() == ISO8601:
+            return value.isoformat()
+        return value.strftime(self.output_format)
+
 
 class TimeField(WritableField):
     type_name = 'TimeField'
@@ -542,10 +573,16 @@ class TimeField(WritableField):
     form_field_class = forms.TimeField
 
     default_error_messages = {
-        'invalid': _("'%s' value has an invalid format. It must be a valid "
-                     "time in the HH:MM[:ss[.uuuuuu]] format."),
+        'invalid': _("Time has wrong format. Use one of these formats instead: %s"),
     }
     empty = None
+    input_formats = api_settings.TIME_INPUT_FORMATS
+    output_format = api_settings.TIME_OUTPUT_FORMAT
+
+    def __init__(self, input_formats=None, output_format=None, *args, **kwargs):
+        self.input_formats = input_formats if input_formats is not None else self.input_formats
+        self.output_format = output_format if output_format is not None else self.output_format
+        super(TimeField, self).__init__(*args, **kwargs)
 
     def from_native(self, value):
         if value in validators.EMPTY_VALUES:
@@ -554,14 +591,34 @@ class TimeField(WritableField):
         if isinstance(value, datetime.time):
             return value
 
+        for format in self.input_formats:
+            if format.lower() == ISO8601:
                 try:
                     parsed = parse_time(value)
-            assert parsed is not None
+                except (ValueError, TypeError):
+                    pass
+                else:
+                    if parsed is not None:
                         return parsed
+            else:
+                try:
+                    parsed = datetime.datetime.strptime(value, format)
                 except (ValueError, TypeError):
-            msg = self.error_messages['invalid'] % value
+                    pass
+                else:
+                    return parsed.time()
+
+        time_input_formats = '; '.join(self.input_formats).replace(ISO8601, 'HH:MM[:ss[.uuuuuu]]')
+        msg = self.error_messages['invalid'] % get_readable_date_format(time_input_formats)
         raise ValidationError(msg)
 
+    def to_native(self, value):
+        if isinstance(value, datetime.datetime):
+            value = value.time()
+        if self.output_format.lower() == ISO8601:
+            return value.isoformat()
+        return value.strftime(self.output_format)
+
 
 class IntegerField(WritableField):
     type_name = 'IntegerField'

rest_framework/settings.py

@@ -18,8 +18,11 @@ REST framework settings, checking for user settings first, then falling
 back to the defaults.
 """
 from __future__ import unicode_literals
+
 from django.conf import settings
 from django.utils import importlib
+
+from rest_framework import ISO8601
 from rest_framework.compat import six
 
 
@@ -76,6 +79,22 @@ DEFAULTS = {
     'URL_FORMAT_OVERRIDE': 'format',
 
     'FORMAT_SUFFIX_KWARG': 'format',
+
+    # Input and output formats
+    'DATE_INPUT_FORMATS': (
+        ISO8601,
+    ),
+    'DATE_OUTPUT_FORMAT': ISO8601,
+
+    'DATETIME_INPUT_FORMATS': (
+        ISO8601,
+    ),
+    'DATETIME_OUTPUT_FORMAT': ISO8601,
+
+    'TIME_INPUT_FORMATS': (
+        ISO8601,
+    ),
+    'TIME_OUTPUT_FORMAT': ISO8601,
 }
 
 

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}
+            {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date.isoformat()}
             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 f['date'] == search_date]
+        expected_data = [f for f in self.data if datetime.datetime.strptime(f['date'], '%Y-%m-%d').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 f['date'] > search_date]
+        expected_data = [f for f in self.data if datetime.datetime.strptime(f['date'], '%Y-%m-%d').date() > search_date]
         self.assertEqual(response.data, expected_data)
 
         # Tests that the text filter set with 'icontains' in the filter class works.
@@ -142,7 +142,8 @@ 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 f['date'] > search_date and
+        expected_data = [f for f in self.data if
+                         datetime.datetime.strptime(f['date'], '%Y-%m-%d').date() > search_date and
                          f['decimal'] < search_decimal]
         self.assertEqual(response.data, expected_data)
 

rest_framework/tests/pagination.py

@@ -112,7 +112,7 @@ class IntegrationTestPaginationAndFiltering(TestCase):
 
         self.objects = FilterableItem.objects
         self.data = [
-        {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date}
+            {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date.isoformat()}
             for obj in self.objects.all()
         ]
         self.view = FilterFieldsRootView.as_view()

rest_framework/tests/serializer.py

@@ -112,7 +112,7 @@ class BasicTests(TestCase):
         self.expected = {
             'email': 'tom@example.com',
             'content': 'Happy new year!',
-            'created': datetime.datetime(2012, 1, 1),
+            'created': '2012-01-01T00:00:00',
             'sub_comment': 'And Merry Christmas!'
         }
         self.person_data = {'name': 'dwight', 'age': 35}

rest_framework/utils/dates.py

+def get_readable_date_format(date_format):
+    mapping = [("%Y", "YYYY"),
+               ("%y", "YY"),
+               ("%m", "MM"),
+               ("%b", "[Jan through Dec]"),
+               ("%B", "[January through December]"),
+               ("%d", "DD"),
+               ("%H", "HH"),
+               ("%M", "MM"),
+               ("%S", "SS"),
+               ("%f", "uuuuuu")]
+    for k, v in mapping:
+        date_format = date_format.replace(k, v)
+    return date_format
\ No newline at end of file