gh-158252: Parse month and weekday names in C

Read ASCII names from the current locale without caching them across
setlocale calls. Preserve explicitly supplied weekdays in time.strptime,
including numeric weekdays and weekdays that disagree with the date.

Non-ASCII names and mixed spellings of a field retain the Python parser.

Author: pganssle

Include/internal/pycore_time.h

@@ -349,6 +349,7 @@ typedef struct {
     int hour, minute, second, fraction;
     int gmtoff;  // INT_MIN means no offset was supplied.
     int yday;    // January 1 is day 1.
+    int weekday;  // Monday is 0; a supplied weekday need not agree with the date.
 } _PyTime_StrptimeFields;
 
 // Export for the '_datetime' shared extension.

Lib/test/test_strptime.py

@@ -1,6 +1,7 @@
 """PyUnit testing against strptime"""
 
 import unittest
+import datetime
 import time
 import locale
 import re
@@ -13,6 +14,69 @@
 
 import _strptime
 
+
+class PublicStrptimeTests(unittest.TestCase):
+    @run_with_locales('LC_TIME', 'C', 'en_US', 'fr_FR', 'de_DE', 'ja_JP', '')
+    def test_locale_names(self):
+        for month in range(1, 13):
+            value = datetime.datetime(2024, month, 19, 13, 24, 35)
+            for fmt in ('%b %d %Y', '%B %d %Y', '%a %Y-%m-%d', '%A %Y-%m-%d'):
+                self.assert_matches_python(value.strftime(fmt), fmt)
+
+    def assert_matches_python(self, text, fmt):
+        methods = (
+            (time.strptime, _strptime._strptime_time),
+            (datetime.date.strptime,
+             lambda s, f: _strptime._strptime_datetime_date(datetime.date, s, f)),
+            (datetime.time.strptime,
+             lambda s, f: _strptime._strptime_datetime_time(datetime.time, s, f)),
+            (datetime.datetime.strptime,
+             lambda s, f: _strptime._strptime_datetime_datetime(
+                 datetime.datetime, s, f)),
+        )
+        for parse, reference in methods:
+            with self.subTest(method=parse, text=text, format=fmt):
+                try:
+                    expected = reference(text, fmt)
+                except (ValueError, re.PatternError) as error:
+                    with self.assertRaises(type(error)) as caught:
+                        parse(text, fmt)
+                    self.assertEqual(str(caught.exception), str(error))
+                else:
+                    actual = parse(text, fmt)
+                    self.assertEqual(actual, expected)
+                    if isinstance(actual, time.struct_time):
+                        self.assertEqual(actual.tm_zone, expected.tm_zone)
+                        self.assertEqual(actual.tm_gmtoff, expected.tm_gmtoff)
+                    elif isinstance(actual, (datetime.time, datetime.datetime)):
+                        self.assertEqual(actual.tzname(), expected.tzname())
+
+    @support.run_with_locale('LC_TIME', 'C')
+    def test_names_and_weekdays(self):
+        for month in range(1, 13):
+            value = datetime.datetime(2024, month, 19, 13, 24, 35)
+            for fmt in ('%b %d, %Y', '%d %B %Y',
+                        '%a, %d %b %Y %H:%M:%S GMT', '%A %Y-%m-%d'):
+                text = value.strftime(fmt)
+                for spelling in (text, text.lower(), text.upper()):
+                    self.assert_matches_python(spelling, fmt)
+        for directive in ('a', 'A', 'w', 'u'):
+            for day in range(1, 8):
+                # A supplied weekday is preserved even when it disagrees.
+                text = datetime.date(2024, 1, day).strftime('%' + directive)
+                self.assert_matches_python(text + ' 2024-02-29',
+                                           '%' + directive + ' %Y-%m-%d')
+        for text, fmt in (
+            ('2024 January 02 03', '%Y %B %m %d'),
+            ('2024 Jan January 03', '%Y %b %B %d'),
+            ('2024 Monday Tue', '%Y %A %a'),
+            ('2024 Jax 03', '%Y %b %d'),
+            ('2024 Feb 30', '%Y %b %d'),
+            ('Monday Monday', '%A %A'),
+            ('8', '%u'), ('7', '%w'),
+        ):
+            self.assert_matches_python(text, fmt)
+
 libc_ver = platform.libc_ver()
 if libc_ver[0] == 'glibc':
     glibc_ver = tuple(map(int, libc_ver[1].split('.')))

Modules/timemodule.c

@@ -1019,7 +1019,7 @@ time_strptime(PyObject *self, PyObject *args)
         const int values[] = {
             fields.year, fields.month, fields.day,
             fields.hour, fields.minute, fields.second,
-            _PyTime_Weekday(fields.year, fields.yday), fields.yday, -1
+            fields.weekday, fields.yday, -1
         };
         for (size_t i = 0; i < Py_ARRAY_LENGTH(values); i++) {
             PyObject *value = PyLong_FromLong(values[i]);

Python/_strptime.c

@@ -1,16 +1,19 @@
 #include "Python.h"
 #include "pycore_time.h"
 
+#include <time.h>
+
 
 /* Implement common parts of strptime in C to improve performance. Callers
  * fall back to Lib/_strptime.py for a full parse when this doesn't match.
  *
  * Supported inputs are exact str objects containing only ASCII, with:
  * - numeric %Y, %y, %m, %d, %H, %M, %S, and %f fields;
+ * - ASCII locale month/weekday names and numeric %w/%u weekdays;
  * - a terminal %z: empty, Z, or +/-HHMM or +/-HH:MM with hours below 24;
  * - literal characters, %%, and ASCII whitespace.
  * Duplicate directives, mixed %Y/%y, and day-of-month without a year use the
- * fallback. So do other directives (including locale-dependent names and
+ * fallback. So do other directives (including non-ASCII locale names and
  * week/day-of-year calculations), and offsets with seconds or fractions.
  */
 
@@ -31,6 +34,53 @@ strptime_digits(const unsigned char *data, Py_ssize_t length, Py_ssize_t pos,
     return count >= minimum ? count : 0;
 }
 
+static int
+strptime_name(const unsigned char *data, Py_ssize_t length, Py_ssize_t pos,
+              unsigned char directive, int *value)
+{
+#ifdef HAVE_STRFTIME
+    /* Read the current locale without keeping a cache across setlocale().
+     * Non-ASCII names retain Python's decoding and Unicode case handling.
+     * As in TimeRE, prefer the longest match, then the first equal name.
+     */
+    int month = directive == 'b' || directive == 'B';
+    int count = month ? 12 : 7;
+    char format[] = {'%', directive, '\0'};
+    int matched = 0;
+    for (int i = 0; i < count; i++) {
+        struct tm tm = {.tm_year = 101, .tm_mday = 1,
+                        .tm_mon = month ? i : 0,
+                        .tm_wday = month ? 0 : (i + 1) % 7};
+        char name[256];
+        size_t size = strftime(name, sizeof(name), format, &tm);
+        if (size == 0) {
+            return 0;
+        }
+        for (size_t j = 0; j < size; j++) {
+            if ((unsigned char)name[j] >= 128) {
+                return 0;
+            }
+        }
+        if (size <= (size_t)matched || size > (size_t)(length - pos)) {
+            continue;
+        }
+        size_t j;
+        for (j = 0; j < size; j++) {
+            if (Py_TOLOWER(data[pos + j]) != Py_TOLOWER(name[j])) {
+                break;
+            }
+        }
+        if (j == size) {
+            matched = (int)size;
+            *value = month ? i + 1 : i;
+        }
+    }
+    return matched;
+#else
+    return 0;
+#endif
+}
+
 static int
 strptime_offset(const unsigned char *data, Py_ssize_t length, Py_ssize_t pos,
                 _PyTime_StrptimeFields *fields)
@@ -83,6 +133,7 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         SECOND = 1U << 6,
         FRACTION = 1U << 7,
         OFFSET = 1U << 8,
+        WEEKDAY = 1U << 9,
         ANY_YEAR = YEAR | SHORT_YEAR,
     };
     static const unsigned short directive_bits[128] = {
@@ -95,6 +146,7 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         ['S'] = SECOND,
         ['f'] = FRACTION,
         ['z'] = OFFSET,
+        ['w'] = WEEKDAY,
     };
     /* String subclasses and non-ASCII input retain Python's behavior. */
     if (!PyUnicode_CheckExact(string) || !PyUnicode_CheckExact(format) ||
@@ -105,7 +157,8 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
     const unsigned char *fmt = PyUnicode_1BYTE_DATA(format);
     Py_ssize_t length = PyUnicode_GET_LENGTH(string);
     Py_ssize_t fmt_length = PyUnicode_GET_LENGTH(format);
-    *fields = (_PyTime_StrptimeFields){.year = 1900, .month = 1, .day = 1, .gmtoff = INT_MIN};
+    *fields = (_PyTime_StrptimeFields){.year = 1900, .month = 1, .day = 1,
+                                     .gmtoff = INT_MIN, .weekday = -1};
     unsigned int seen = 0;
     Py_ssize_t pos = 0;
 
@@ -140,8 +193,15 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
             continue;
         }
 
-        /* Reject duplicate groups, aliases, and locale-dependent directives. */
-        unsigned int bit = directive_bits[c];
+        /* Mixed spellings of the same field retain Python's precedence. */
+        unsigned char field = c;
+        if (c == 'b' || c == 'B') {
+            field = 'm';
+        }
+        else if (c == 'a' || c == 'A' || c == 'u') {
+            field = 'w';
+        }
+        unsigned int bit = directive_bits[field];
         if (bit == 0) {
             return 0;
         }
@@ -150,6 +210,22 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         }
         seen |= bit;
 
+        if (c == 'b' || c == 'B' || c == 'a' || c == 'A') {
+            int value;
+            int count = strptime_name(data, length, pos, c, &value);
+            if (count == 0) {
+                return 0;
+            }
+            pos += count;
+            if (field == 'm') {
+                fields->month = value;
+            }
+            else {
+                fields->weekday = value;
+            }
+            continue;
+        }
+
         if (c == 'z') {
             if (i != fmt_length - 1 ||
                 !strptime_offset(data, length, pos, fields)) {
@@ -170,6 +246,9 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         else if (c == 'f') {
             maximum = 6;
         }
+        else if (field == 'w') {
+            maximum = 1;
+        }
         else if ((c == 'd' || c == 'H') && pos < length && data[pos] == ' ') {
             pos++;
             maximum = 1;
@@ -181,6 +260,18 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         }
         pos += count;
         switch (c) {
+            case 'w':
+                if (value > 6) {
+                    return 0;
+                }
+                fields->weekday = (value + 6) % 7;
+                break;
+            case 'u':
+                if (value < 1 || value > 7) {
+                    return 0;
+                }
+                fields->weekday = value - 1;
+                break;
             case 'Y':
                 fields->year = value;
                 break;
@@ -244,5 +335,8 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
     }
     fields->yday = days_before_month[fields->month] + fields->day +
                    (fields->month > 2 && leap);
+    if (fields->weekday < 0) {
+        fields->weekday = _PyTime_Weekday(fields->year, fields->yday);
+    }
     return 1;
 }