Add datetime.time.strptime and datetime.date.strptime

Modules/_datetimemodule.c

 /*  C implementation for the date/time type documented at
  *  http://www.zope.org/Members/fdrake/DateTimeWiki/FrontPage
  */
 
 #include "Python.h"
 #include "structmember.h"
 
 #include <time.h>
 
 /* Differentiate between building the core module and building extension
@@ skipping 2528 matching lines @@
 /* Return new date from time.strptime(). */
 static PyObject *
 date_strptime(PyObject *cls, PyObject *args)
 {
     PyObject *date = NULL;
     PyObject *datetime;
 
     datetime = datetime_strptime((PyObject *)&PyDateTime_DateTimeType, args);
 
     if (datetime == NULL)
-        return NULL;
+    return NULL;
 
     if (DATE_GET_HOUR(datetime) ||
-        DATE_GET_MINUTE(datetime) ||
-        DATE_GET_SECOND(datetime) ||
-        DATE_GET_MICROSECOND(datetime))
-        PyErr_SetString(PyExc_ValueError,
-                        "date.strptime value cannot have a time part");
+    DATE_GET_MINUTE(datetime) ||
+    DATE_GET_SECOND(datetime) ||
+    DATE_GET_MICROSECOND(datetime))
+    PyErr_SetString(PyExc_ValueError,
+            "date.strptime value cannot have a time part");
     else
-        date = datetime_getdate((PyDateTime_DateTime *)datetime);
+    date = datetime_getdate((PyDateTime_DateTime *)datetime);
 
     Py_DECREF(datetime);
     return date;
 }
 
 /*
  * Date arithmetic.
  */
 
 /* date + timedelta -> date.  If arg negate is true, subtract the timedelta
@@ skipping 283 matching lines @@
     {"fromordinal", (PyCFunction)date_fromordinal,      METH_VARARGS |
                                                     METH_CLASS,
      PyDoc_STR("int -> date corresponding to a proleptic Gregorian "
                "ordinal.")},
 
     {"today",         (PyCFunction)date_today,   METH_NOARGS | METH_CLASS,
      PyDoc_STR("Current date or datetime:  same as "
                "self.__class__.fromtimestamp(time.time()).")},
 
     {"strptime", (PyCFunction)date_strptime,     METH_VARARGS | METH_CLASS,
-     PyDoc_STR("string, format -> new date parsed from a string "
-                   "(like time.strptime()).")},
+     PyDoc_STR("string, format -> new date instance parsed from a string "
+               "(like time.strptime()).\n\n"
+               ">>> datetime.date.strptime('2012/07/20', '%Y/%m/%d')\n"
+               "datetime.date(2012, 7, 20)")},
 
     /* Instance methods: */
 
     {"ctime",       (PyCFunction)date_ctime,        METH_NOARGS,
      PyDoc_STR("Return ctime() style string.")},
 
     {"strftime",        (PyCFunction)date_strftime,     METH_VARARGS | METH_KEYWORDS,
      PyDoc_STR("format -> strftime() style string.")},
 
     {"__format__",      (PyCFunction)date_format,       METH_VARARGS,
@@ skipping 675 matching lines @@
         self = new_time_ex(hour, minute, second, usecond, tzinfo,
                            type);
     }
     return self;
 }
 
 /* Return new time from time.strptime(). */
 static PyObject *
 time_strptime(PyObject *cls, PyObject *args)
 {
-        PyObject *time = NULL;
-        PyObject *datetime;
-
-        static PyObject *emptyDatetime = NULL;
-
-        /* To ensure that the given string does not contain a date,
-         * compare with the result of an empty date string.
-         */
-        if (emptyDatetime == NULL) {
-                PyObject *emptyStringPair = Py_BuildValue("ss", "", "");
-                if (emptyStringPair == NULL)
-                        return NULL;
-                emptyDatetime = datetime_strptime(
-                        (PyObject *)&PyDateTime_DateTimeType,
-                        emptyStringPair);
-                Py_DECREF(emptyStringPair);
-                if (emptyDatetime == NULL)
-                        return NULL;
-        }
-
-        datetime = datetime_strptime(
-                (PyObject *)&PyDateTime_DateTimeType,
-                args);
-
-        if (datetime == NULL)
-                return NULL;
-
-        if (GET_YEAR(datetime) != GET_YEAR(emptyDatetime)
-            || GET_MONTH(datetime) != GET_MONTH(emptyDatetime)
-            || GET_DAY(datetime) != GET_DAY(emptyDatetime))
-                PyErr_SetString(PyExc_ValueError,
-                                "time.strptime value cannot have a date part");
-        else
-                time = datetime_gettime((PyDateTime_DateTime *)datetime);
-
-        Py_DECREF(datetime);
-
-        return time;
+    PyObject *time = NULL;
+    PyObject *datetime;
+
+    static PyObject *emptyDatetime = NULL;
+
+    /* To ensure that the given string does not contain a date,
+     * compare with the result of an empty date string.
+     */
+    if (emptyDatetime == NULL) {
+        PyObject *emptyStringPair = Py_BuildValue("ss", "", "");
+        if (emptyStringPair == NULL)
+            return NULL;
+        emptyDatetime = datetime_strptime(
+            (PyObject *)&PyDateTime_DateTimeType,
+            emptyStringPair);
+        Py_DECREF(emptyStringPair);
+        if (emptyDatetime == NULL)
+            return NULL;
+    }
+
+    datetime = datetime_strptime(
+        (PyObject *)&PyDateTime_DateTimeType,
+        args);
+
+    if (datetime == NULL)
+        return NULL;
+
+    if (GET_YEAR(datetime) != GET_YEAR(emptyDatetime)
+        || GET_MONTH(datetime) != GET_MONTH(emptyDatetime)
+        || GET_DAY(datetime) != GET_DAY(emptyDatetime))
+        PyErr_SetString(PyExc_ValueError,
+                        "time.strptime value cannot have a date part");
+    else
+        time = datetime_gettime((PyDateTime_DateTime *)datetime);
+
+    Py_DECREF(datetime);
+
+    return time;
 }
 
 
 /*
  * Destructor.
  */
 
 static void
 time_dealloc(PyDateTime_Time *self)
 {
@@ skipping 316 matching lines @@
 {
     return Py_BuildValue("(ON)", Py_TYPE(self), time_getstate(self));
 }
 
 static PyMethodDef time_methods[] = {
 
     /* Class methods: */
 
     {"strptime", (PyCFunction)time_strptime, METH_VARARGS | METH_CLASS,
      PyDoc_STR("string, format -> new time parsed from a string "
-               "(like time.strptime()).")},
+               "(like time.strptime()).\n\n"
+               ">>> datetime.time.strptime('10:40am', '%H:%M%p')\n"
+               "datetime.time(10, 40)")},
 
     /* Instance methods: */
 
     {"isoformat",   (PyCFunction)time_isoformat,        METH_NOARGS,
      PyDoc_STR("Return string in ISO 8601 format, HH:MM:SS[.mmmmmm]"
                "[+HH:MM].")},
 
     {"strftime",        (PyCFunction)time_strftime,     METH_VARARGS | METH_KEYWORDS,
      PyDoc_STR("format -> strftime() style string.")},
 
@@ skipping 1138 matching lines @@
      PyDoc_STR("timestamp[, tz] -> tz's local time from POSIX timestamp.")},
 
     {"utcfromtimestamp", (PyCFunction)datetime_utcfromtimestamp,
      METH_VARARGS | METH_CLASS,
      PyDoc_STR("timestamp -> UTC datetime from a POSIX timestamp "
                "(like time.time()).")},
 
     {"strptime", (PyCFunction)datetime_strptime,
      METH_VARARGS | METH_CLASS,
      PyDoc_STR("string, format -> new datetime parsed from a string "
-               "(like time.strptime()).")},
-
-    {"strptime", (PyCFunction)time_strptime, METH_VARARGS | METH_CLASS,
-     PyDoc_STR("string, format -> new time parsed from a string "
-               "(like time.strptime()).")},
+               "(like time.strptime()).\n\n"
+               ">>> datetime.datetime.strptime('2012/07/20 10:40am', "
+               "'%Y/%m/%d %H:%M%p')\n"
+               "datetime.datetime(2012, 7, 20, 10, 40)")},
 
     {"combine", (PyCFunction)datetime_combine,
      METH_VARARGS | METH_KEYWORDS | METH_CLASS,
      PyDoc_STR("date, time -> datetime with same date and time fields")},
 
     /* Instance methods: */
 
     {"date",   (PyCFunction)datetime_getdate, METH_NOARGS,
      PyDoc_STR("Return date object with same year, month and day.")},
 
@@ skipping 531 matching lines @@
    enough to say.
 
 In any case, it's clear that the default fromutc() is strong enough to handle
 "almost all" time zones:  so long as the standard offset is invariant, it
 doesn't matter if daylight time transition points change from year to year, or
 if daylight time is skipped in some years; it doesn't matter how large or
 small dst() may get within its bounds; and it doesn't even matter if some
 perverse time zone returns a negative dst()).  So a breaking case must be
 pretty bizarre, and a tzinfo subclass can override fromutc() if it is.
 --------------------------------------------------------------------------- */