gh-158252: Use the C parser for all strptime entry points

Construct date, time, and struct_time results from the shared numeric fields. Preserve subclass constructors and Python fallback behavior, including leap seconds, discarded fields, and timezone metadata.

Author: pganssle

Lib/test/datetimetester.py

@@ -1104,6 +1104,99 @@ def __divmod__(self, other):
 #############################################################################
 # date tests
 
+class TestStrptime(unittest.TestCase):
+    def test_numeric_fields(self):
+        cases = (
+            ('2024-02-29 12:34:56.123', '%Y-%m-%d %H:%M:%S.%f',
+             datetime(2024, 2, 29, 12, 34, 56, 123000)),
+            ('2024-02-29T12:34:56.123+0530', '%Y-%m-%dT%H:%M:%S.%f%z',
+             datetime(2024, 2, 29, 12, 34, 56, 123000,
+                      timezone(timedelta(hours=5, minutes=30)))),
+            ('12:34:56Z', '%H:%M:%S%z', datetime(1900, 1, 1, 12, 34, 56, tzinfo=UTC)),
+            ('12:34:56-03:30', '%H:%M:%S%z',
+             datetime(1900, 1, 1, 12, 34, 56,
+                      tzinfo=timezone(-timedelta(hours=3, minutes=30)))),
+            ('12:34:56', '%H:%M:%S%z', datetime(1900, 1, 1, 12, 34, 56)),
+            ('', '', datetime(1900, 1, 1)),
+            ('2024111', '%Y%m%d', datetime(2024, 11, 1)),
+            ('2024131', '%Y%m%d', datetime(2024, 1, 31)),
+            ('2024\0-02-29', '%Y\0-%m-%d', datetime(2024, 2, 29)),
+            ('٢٠٢٤-02-29', '%Y-%m-%d', datetime(2024, 2, 29)),
+            ('2024\u200302\u200329', '%Y %m %d', datetime(2024, 2, 29)),
+            ('2024t02t29', '%YT%mt%d', datetime(2024, 2, 29)),
+            ('24 2025-02-01', '%y %Y-%m-%d', datetime(2025, 2, 1)),
+        )
+        for text, fmt, expected in cases:
+            for cls, result in ((datetime, expected), (date, expected.date()),
+                                (time, expected.timetz())):
+                with self.subTest(text=text, fmt=fmt, cls=cls):
+                    actual = cls.strptime(text, fmt)
+                    self.assertEqual(actual, result)
+                    self.assertIs(type(actual), cls)
+            with self.subTest(text=text, fmt=fmt, cls=_time.struct_time):
+                actual = _time.strptime(text, fmt)
+                self.assertEqual(actual, expected.timetuple())
+                self.assertIsNone(actual.tm_zone)
+                offset = expected.utcoffset()
+                self.assertEqual(actual.tm_gmtoff,
+                                 None if offset is None else offset.total_seconds())
+
+    def test_invalid_fields(self):
+        cases = (
+            ('2024-02-30', '%Y-%m-%d'),
+            ('1900-02-29', '%Y-%m-%d'),
+            ('0000-01-01', '%Y-%m-%d'),
+            ('2024-01- 12', '%Y-%m-%d'),
+            ('2024\0ignored', '%Y'),
+            ('24:00:00', '%H:%M:%S'),
+            ('23:60:00', '%H:%M:%S'),
+            ('23:59:62', '%H:%M:%S'),
+        )
+        for text, fmt in cases:
+            for parse in (datetime.strptime, date.strptime, time.strptime,
+                          _time.strptime):
+                with self.subTest(text=text, fmt=fmt, parse=parse):
+                    with self.assertRaises(ValueError):
+                        parse(text, fmt)
+
+    def test_leap_seconds(self):
+        for second in (60, 61):
+            text = f'2024-02-29 23:59:{second}'
+            fmt = '%Y-%m-%d %H:%M:%S'
+            with self.subTest(second=second):
+                self.assertEqual(date.strptime(text, fmt), date(2024, 2, 29))
+                self.assertEqual(_time.strptime(text, fmt),
+                                 (2024, 2, 29, 23, 59, second, 3, 60, -1))
+                for cls in (datetime, time):
+                    with self.assertRaises(ValueError):
+                        cls.strptime(text, fmt)
+
+    def test_offset_outside_datetime_range(self):
+        # date discards the offset; struct_time doesn't construct a timezone.
+        self.assertEqual(date.strptime('+2400', '%z'), date(1900, 1, 1))
+        self.assertEqual(_time.strptime('+2400', '%z').tm_gmtoff, 86400)
+        for cls in (datetime, time):
+            with self.subTest(cls=cls):
+                with self.assertRaises(ValueError):
+                    cls.strptime('+2400', '%z')
+
+    def test_subclass_constructor(self):
+        for cls, args in ((date, (2024, 2, 29)),
+                          (time, (12, 34, 56, 123000)),
+                          (datetime, (2024, 2, 29, 12, 34, 56, 123000))):
+            class Capture(cls):
+                def __new__(cls, *args, **kwargs):
+                    return args, kwargs
+
+            text = '2024-02-29 12:34:56.123'
+            fmt = '%Y-%m-%d %H:%M:%S.%f'
+            with self.subTest(cls=cls):
+                self.assertEqual(Capture.strptime(text, fmt), (args, {}))
+                aware_args = args if cls is date else args + (UTC,)
+                self.assertEqual(Capture.strptime(text + 'Z', fmt + '%z'),
+                                 (aware_args, {}))
+
+
 class TestDateOnly(unittest.TestCase):
     # Tests here won't pass if also run on datetime objects, so don't
     # subclass this to test datetimes too.

Lib/test/test_time.py

@@ -371,6 +371,45 @@ def test_strptime(self):
                 self.fail("conversion specifier %r failed with '%s' input." %
                           (format, strf_output))
 
+    def test_strptime_numeric_calendar(self):
+        cases = (
+            ('0001-01-01', 1, 1, 1, 0, 1),
+            ('1900-03-01', 1900, 3, 1, 3, 60),
+            ('2000-02-29', 2000, 2, 29, 1, 60),
+            ('2000-03-01', 2000, 3, 1, 2, 61),
+            ('2024-12-31', 2024, 12, 31, 1, 366),
+            ('2100-03-01', 2100, 3, 1, 0, 60),
+            ('9999-12-31', 9999, 12, 31, 4, 365),
+        )
+        for text, year, month, day, weekday, yday in cases:
+            with self.subTest(text=text):
+                result = time.strptime(text, '%Y-%m-%d')
+                self.assertIs(type(result), time.struct_time)
+                self.assertEqual(result,
+                                 (year, month, day, 0, 0, 0, weekday, yday, -1))
+                self.assertIsNone(result.tm_zone)
+                self.assertIsNone(result.tm_gmtoff)
+
+    def test_strptime_numeric_offset(self):
+        for text, offset in (('', None), ('Z', 0), ('+0000', 0),
+                             ('-00:00', 0), ('+0530', 19800),
+                             ('-03:30', -12600), ('+2359', 86340),
+                             ('+01:02:03.456', 3723)):
+            with self.subTest(text=text):
+                result = time.strptime('12:34:56.123' + text, '%H:%M:%S.%f%z')
+                self.assertEqual(result, (1900, 1, 1, 12, 34, 56, 0, 1, -1))
+                self.assertIsNone(result.tm_zone)
+                self.assertEqual(result.tm_gmtoff, offset)
+
+    @support.run_with_locale('LC_TIME', 'C')
+    def test_strptime_default_format(self):
+        self.assertEqual(time.strptime('Thu Feb 29 12:34:56 2024'),
+                         (2024, 2, 29, 12, 34, 56, 3, 60, -1))
+        for args in ((), ('2024', '%Y', 'extra'), (None, '%Y')):
+            with self.subTest(args=args):
+                with self.assertRaises(TypeError):
+                    time.strptime(*args)
+
     def test_strptime_bytes(self):
         # Make sure only strings are accepted as arguments to strptime.
         self.assertRaises(TypeError, time.strptime, b'2009', "%Y")

Misc/NEWS.d/next/Library/2026-09-17-10-30-00.gh-issue-158252.strptime.rst

@@ -1,3 +1,4 @@
-Speed up :meth:`datetime.datetime.strptime` for common numeric formats by
-parsing fields and constructing the result in C. Other inputs continue to use
-the Python parser.
+Speed up :func:`time.strptime`, :meth:`datetime.date.strptime`,
+:meth:`datetime.time.strptime`, and :meth:`datetime.datetime.strptime` for
+common numeric formats by parsing fields and constructing the result in C.
+Other inputs continue to use the Python parser.

Modules/_datetimemodule.c

@@ -3514,6 +3514,11 @@ datetime_date_strptime_impl(PyTypeObject *type, PyObject *string,
                             PyObject *format)
 /*[clinic end generated code: output=454d473bee2d5161 input=2db8f0b2b5242deb]*/
 {
+    _PyTime_StrptimeFields fields;
+    if (type == DATE_TYPE(NO_STATE) &&
+        _PyTime_Strptime(string, format, &fields)) {
+        return new_date_ex(fields.year, fields.month, fields.day, type);
+    }
     PyObject *result;
 
     PyObject *module = PyImport_Import(&_Py_ID(_strptime));
@@ -4786,6 +4791,20 @@ datetime_time_strptime_impl(PyTypeObject *type, PyObject *string,
                             PyObject *format)
 /*[clinic end generated code: output=ae05a9bc0241d3bf input=f01d0b9eb5383da5]*/
 {
+    _PyTime_StrptimeFields fields;
+    if (type == TIME_TYPE(NO_STATE) &&
+        _PyTime_Strptime(string, format, &fields)) {
+        PyObject *tzinfo = tzinfo_from_isoformat_results(
+            fields.gmtoff != INT_MIN, fields.gmtoff, 0);
+        if (tzinfo == NULL) {
+            return NULL;
+        }
+        PyObject *result = new_time_ex(
+            fields.hour, fields.minute, fields.second, fields.fraction,
+            tzinfo, type);
+        Py_DECREF(tzinfo);
+        return result;
+    }
     PyObject *result;
 
     PyObject *module = PyImport_Import(&_Py_ID(_strptime));

Modules/timemodule.c

@@ -989,6 +989,44 @@ is not present, current time as returned by localtime() is used.\n\
 static PyObject *
 time_strptime(PyObject *self, PyObject *args)
 {
+    _PyTime_StrptimeFields fields;
+    if (PyTuple_GET_SIZE(args) == 2 &&
+        _PyTime_Strptime(PyTuple_GET_ITEM(args, 0),
+                         PyTuple_GET_ITEM(args, 1), &fields)) {
+        time_module_state *state = get_time_state(self);
+        PyObject *result = PyStructSequence_New(state->struct_time_type);
+        if (result == NULL) {
+            return NULL;
+        }
+        /* January 1 of year 1 was a Monday. */
+        int year = fields.year - 1;
+        int weekday = (365 * year + year / 4 - year / 100 + year / 400 +
+                       fields.yday - 1) % 7;
+        const int values[] = {
+            fields.year, fields.month, fields.day,
+            fields.hour, fields.minute, fields.second,
+            weekday, fields.yday, -1
+        };
+        for (size_t i = 0; i < Py_ARRAY_LENGTH(values); i++) {
+            PyObject *value = PyLong_FromLong(values[i]);
+            if (value == NULL) {
+                Py_DECREF(result);
+                return NULL;
+            }
+            PyStructSequence_SET_ITEM(result, i, value);
+        }
+        /* Numeric offsets don't supply a timezone name or DST information. */
+        PyStructSequence_SET_ITEM(result, 9, Py_NewRef(Py_None));
+        PyObject *offset = fields.gmtoff == INT_MIN
+                          ? Py_NewRef(Py_None)
+                          : PyLong_FromLong(fields.gmtoff);
+        if (offset == NULL) {
+            Py_DECREF(result);
+            return NULL;
+        }
+        PyStructSequence_SET_ITEM(result, 10, offset);
+        return result;
+    }
     PyObject *func, *result;
 
     func = PyImport_ImportModuleAttrString("_strptime", "_strptime_time");