Differentiate between datetimeformat and dateformat

marshmallow/fields.py

@@ -915,14 +915,14 @@ class DateTime(Field):
 
     """
 
-    DATEFORMAT_SERIALIZATION_FUNCS = {
+    SERIALIZATION_FUNCS = {
         'iso': utils.isoformat,
         'iso8601': utils.isoformat,
         'rfc': utils.rfcformat,
         'rfc822': utils.rfcformat,
     }
 
-    DATEFORMAT_DESERIALIZATION_FUNCS = {
+    DESERIALIZATION_FUNCS = {
         'iso': utils.from_iso_datetime,
         'iso8601': utils.from_iso_datetime,
         'rfc': utils.from_rfc,
@@ -931,62 +931,74 @@ class DateTime(Field):
 
     DEFAULT_FORMAT = 'iso'
 
+    OBJ_TYPE = 'datetime'
+
+    SCHEMA_OPTS_VAR_NAME = 'datetimeformat'
+
     localtime = False
     default_error_messages = {
-        'invalid': 'Not a valid datetime.',
-        'format': '"{input}" cannot be formatted as a datetime.',
+        'invalid': 'Not a valid {obj_type}.',
+        'format': '"{input}" cannot be formatted as a {obj_type}.',
     }
 
     def __init__(self, format=None, **kwargs):
         super(DateTime, self).__init__(**kwargs)
         # Allow this to be None. It may be set later in the ``_serialize``
         # or ``_desrialize`` methods This allows a Schema to dynamically set the
-        # dateformat, e.g. from a Meta option
-        self.dateformat = format
+        # format, e.g. from a Meta option
+        self.format = format
 
     def _add_to_schema(self, field_name, schema):
         super(DateTime, self)._add_to_schema(field_name, schema)
-        self.dateformat = self.dateformat or schema.opts.dateformat
+        self.format = self.format or \
+            getattr(schema.opts, self.SCHEMA_OPTS_VAR_NAME) or \
+            self.DEFAULT_FORMAT
 
     def _serialize(self, value, attr, obj):
+        self.format = self.format or self.DEFAULT_FORMAT
         if value is None:
             return None
-        dateformat = self.dateformat or self.DEFAULT_FORMAT
-        format_func = self.DATEFORMAT_SERIALIZATION_FUNCS.get(dateformat, None)
+        format_func = self.SERIALIZATION_FUNCS.get(self.format, None)
         if format_func:
             try:
                 return format_func(value, localtime=self.localtime)
-            except (AttributeError, ValueError):
-                self.fail('format', input=value)
+            except (TypeError, AttributeError, ValueError):
+                self.fail('format', input=value, obj_type=self.OBJ_TYPE)
         else:
-            return value.strftime(dateformat)
+            return value.strftime(self.format)
 
     def _deserialize(self, value, attr, data):
+        self.format = self.format or self.DEFAULT_FORMAT
         if not value:  # Falsy values, e.g. '', None, [] are not valid
-            raise self.fail('invalid')
-        dateformat = self.dateformat or self.DEFAULT_FORMAT
-        func = self.DATEFORMAT_DESERIALIZATION_FUNCS.get(dateformat)
+            raise self.fail('invalid', obj_type=self.OBJ_TYPE)
+        func = self.DESERIALIZATION_FUNCS.get(
+            self.format,
+        )
         if func:
             try:
                 return func(value)
             except (TypeError, AttributeError, ValueError):
-                raise self.fail('invalid')
-        elif dateformat:
+                raise self.fail('invalid', obj_type=self.OBJ_TYPE)
+        elif self.format:
             try:
-                return dt.datetime.strptime(value, dateformat)
+                return dt.datetime.strptime(value, self.format)
             except (TypeError, AttributeError, ValueError):
-                raise self.fail('invalid')
+                raise self.fail('invalid', obj_type=self.OBJ_TYPE)
         elif utils.dateutil_available:
             try:
-                return utils.from_datestring(value)
-            except TypeError:
-                raise self.fail('invalid')
+                parsed = utils.from_datestring(value)
+                return dt.datetime(
+                    parsed.year, parsed.month, parsed.day, parsed.hour,
+                    parsed.minute, parsed.second,
+                )
+            except (TypeError, ValueError):
+                raise self.fail('invalid', obj_type=self.OBJ_TYPE)
         else:
             warnings.warn(
                 'It is recommended that you install python-dateutil '
                 'for improved datetime deserialization.',
             )
-            raise self.fail('invalid')
+            raise self.fail('invalid', obj_type=self.OBJ_TYPE)
 
 
 class LocalDateTime(DateTime):
@@ -1030,35 +1042,33 @@ def _deserialize(self, value, attr, data):
             self.fail('invalid')
 
 
-class Date(Field):
+class Date(DateTime):
     """ISO8601-formatted date string.
 
+    :param format: Either ``"iso"`` (for ISO8601) or a date format string.
+        If `None`, defaults to "iso".
     :param kwargs: The same keyword arguments that :class:`Field` receives.
     """
     default_error_messages = {
         'invalid': 'Not a valid date.',
         'format': '"{input}" cannot be formatted as a date.',
     }
 
-    def _serialize(self, value, attr, obj):
-        if value is None:
-            return None
-        try:
-            return value.isoformat()
-        except AttributeError:
-            self.fail('format', input=value)
-        return value
+    SERIALIZATION_FUNCS = {
+        'iso': utils.to_iso_date,
+        'iso8601': utils.to_iso_date,
+    }
 
-    def _deserialize(self, value, attr, data):
-        """Deserialize an ISO8601-formatted date string to a
-        :class:`datetime.date` object.
-        """
-        if not value:  # falsy values are invalid
-            self.fail('invalid')
-        try:
-            return utils.from_iso_date(value)
-        except (AttributeError, TypeError, ValueError):
-            self.fail('invalid')
+    DESERIALIZATION_FUNCS = {
+        'iso': utils.from_iso_date,
+        'iso8601': utils.from_iso_date,
+    }
+
+    DEFAULT_FORMAT = 'iso'
+
+    OBJ_TYPE = "date"
+
+    SCHEMA_OPTS_VAR_NAME = 'dateformat'
 
 
 class TimeDelta(Field):

marshmallow/schema.py

@@ -201,6 +201,7 @@ def __init__(self, meta, ordered=False):
         if not isinstance(self.exclude, (list, tuple)):
             raise ValueError('`exclude` must be a list or tuple.')
         self.dateformat = getattr(meta, 'dateformat', None)
+        self.datetimeformat = getattr(meta, 'datetimeformat', None)
         if hasattr(meta, 'json_module'):
             warnings.warn(
                 'The json_module class Meta option is deprecated. Use render_module instead.',

marshmallow/utils.py

@@ -309,6 +309,11 @@ def from_iso_date(datestring, use_dateutil=True):
     else:
         return datetime.datetime.strptime(datestring[:10], '%Y-%m-%d').date()
 
+
+def to_iso_date(date, *args, **kwargs):
+    return datetime.date.isoformat(date)
+
+
 def ensure_text_type(val):
     if isinstance(val, binary_type):
         val = val.decode('utf-8')

tests/base.py

@@ -89,6 +89,7 @@ def __init__(
         self.uid = uuid.uuid1()
         self.time_registered = time_registered or dt.time(1, 23, 45, 6789)
         self.birthdate = birthdate or dt.date(2013, 1, 23)
+        self.activation_date = dt.date(2013, 12, 11)
         self.sex = sex
         self.employer = employer
         self.relatives = []
@@ -170,6 +171,7 @@ class UserSchema(Schema):
     uid = fields.UUID()
     time_registered = fields.Time()
     birthdate = fields.Date()
+    activation_date = fields.Date()
     since_created = fields.TimeDelta()
     sex = fields.Str(validate=validate.OneOf(['male', 'female']))
     various_data = fields.Dict()

tests/test_schema.py

@@ -1468,19 +1468,32 @@ class BadExclude(Schema):
             class Meta:
                 exclude = 'name'
 
-def test_dateformat_option(user):
+def test_datetimeformat_option(user):
     fmt = '%Y-%m'
 
-    class DateFormatSchema(Schema):
+    class DateTimeFormatSchema(Schema):
         updated = fields.DateTime('%m-%d')
 
         class Meta:
             fields = ('created', 'updated')
-            dateformat = fmt
-    serialized = DateFormatSchema().dump(user)
+            datetimeformat = fmt
+    serialized = DateTimeFormatSchema().dump(user)
     assert serialized['created'] == user.created.strftime(fmt)
     assert serialized['updated'] == user.updated.strftime('%m-%d')
 
+def test_dateformat_option(user):
+    fmt = '%Y-%m'
+
+    class DateFormatSchema(Schema):
+        birthdate = fields.Date('%m-%d')
+
+        class Meta:
+            fields = ('birthdate', 'activation_date')
+            dateformat = fmt
+    serialized = DateFormatSchema().dump(user)
+    assert serialized['birthdate'] == user.birthdate.strftime('%m-%d')
+    assert serialized['activation_date'] == user.activation_date.strftime(fmt)
+
 def test_default_dateformat(user):
     class DateFormatSchema(Schema):
         updated = fields.DateTime(format='%m-%d')