gh-158252: Dispatch strptime directives directly

Common numeric directives were passing through alias and locale-name
checks before parsing their digits. Look up equivalent fields directly
in the directive table and dispatch once to select the parsing rules.

Compute missing weekdays in time.strptime, so the datetime methods avoid
work they don't use. Keep weekdays supplied by the input or calculated
from ordinal dates intact.

Add coverage for mixed directive spellings and inferred weekdays.

Author: pganssle

Include/internal/pycore_time.h

@@ -351,7 +351,9 @@ typedef struct {
     int gmtoff_fraction;
     Py_ssize_t zone_start, zone_length;  // Original spelling of a %Z name.
     int yday;    // January 1 is day 1.
-    int weekday;  // Monday is 0; a supplied weekday need not agree with the date.
+    // Monday is 0; a supplied weekday need not agree with the date.
+    // If negative, the caller must compute it from year and yday if needed.
+    int weekday;
 } _PyTime_StrptimeFields;
 
 // Export for the '_datetime' shared extension.

Lib/test/test_strptime.py

@@ -16,6 +16,34 @@
 
 
 class PublicStrptimeTests(unittest.TestCase):
+    def test_inferred_weekday(self):
+        for text, fmt in (
+            ('0001-01-01', '%Y-%m-%d'),
+            ('2024-02-29', '%Y-%m-%d'),
+            ('9999-12-31', '%Y-%m-%d'),
+            ('2023 366', '%Y %j'),
+            ('2024 00 0', '%Y %W %w'),
+        ):
+            self.assert_matches_python(text, fmt)
+
+    @support.run_with_locale('LC_TIME', 'C')
+    def test_mixed_directive_spellings(self):
+        groups = (
+            (('m', '01'), ('b', 'Feb'), ('B', 'March')),
+            (('d', '01'), ('e', ' 2')),
+            (('H', '13'), ('k', '14'), ('I', '03'), ('l', ' 4')),
+            (('w', '0'), ('u', '1'), ('a', 'Tue'), ('A', 'Wednesday')),
+            (('p', 'AM'), ('P', 'PM')),
+            (('z', '+0100'), (':z', '+02:00')),
+            (('U', '01'), ('W', '02')),
+        )
+        for group in groups:
+            for first, first_text in group:
+                for second, second_text in group:
+                    self.assert_matches_python(
+                        f'2024 {first_text} {second_text}',
+                        f'%Y %{first} %{second}')
+
     def test_week_and_ordinal_dates(self):
         for year in (1, 4, 100, 400, 1900, 1999, 2000, 2004, 2020, 9999):
             for day in (1, 28, 59, 60, 61, 365, 366, 367):

Modules/timemodule.c

@@ -1016,10 +1016,14 @@ time_strptime(PyObject *self, PyObject *args)
         if (result == NULL) {
             return NULL;
         }
+        int weekday = fields.weekday;
+        if (weekday < 0) {
+            weekday = _PyTime_Weekday(fields.year, fields.yday);
+        }
         const int values[] = {
             fields.year, fields.month, fields.day,
             fields.hour, fields.minute, fields.second,
-            fields.weekday, fields.yday, fields.zone_length ? 0 : -1
+            weekday, fields.yday, fields.zone_length ? 0 : -1
         };
         for (size_t i = 0; i < Py_ARRAY_LENGTH(values); i++) {
             PyObject *value = PyLong_FromLong(values[i]);

Python/_strptime.c

@@ -249,6 +249,19 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         ['U'] = WEEK,
         ['G'] = ISO_YEAR,
         ['V'] = ISO_WEEK,
+        /* Equivalent directives share the duplicate-field checks. */
+        ['b'] = MONTH,
+        ['B'] = MONTH,
+        ['e'] = DAY,
+        ['k'] = HOUR,
+        ['I'] = HOUR,
+        ['l'] = HOUR,
+        ['a'] = WEEKDAY,
+        ['A'] = WEEKDAY,
+        ['u'] = WEEKDAY,
+        ['P'] = AMPM,
+        [':'] = OFFSET,
+        ['W'] = WEEK,
     };
     /* String subclasses and non-ASCII input retain Python's behavior. */
     if (!PyUnicode_CheckExact(string) || !PyUnicode_CheckExact(format) ||
@@ -308,145 +321,144 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
             return 0;
         }
         c = fmt[i];
-        const char *alias = NULL;
-        switch (c) {
-            case 'F': alias = "%Y-%m-%d"; break;
-            case 'D': alias = "%m/%d/%y"; break;
-            case 'T': alias = "%H:%M:%S"; break;
-            case 'R': alias = "%H:%M"; break;
-            case 'e': c = 'd'; break;
-        }
-        if (alias != NULL) {
-            /* These fixed expansions contain no further aliases. Parsing
-             * them in place keeps duplicate-field checks and avoids copying
-             * an arbitrarily long user format into a temporary buffer.
-             */
-            assert(outer_fmt == NULL);
-            outer_fmt = fmt;
-            outer_length = fmt_length;
-            outer_pos = i + 1;
-            fmt = (const unsigned char *)alias;
-            fmt_length = strlen(alias);
-            i = -1;
-            continue;
-        }
-        if (c == 'n' || c == 't') {
-            while (pos < length && Py_UNICODE_ISSPACE(data[pos])) {
-                pos++;
-            }
-            continue;
-        }
-        int require_colon = 0;
-        if (c == ':' && i + 1 < fmt_length && fmt[i + 1] == 'z') {
-            c = fmt[++i];
-            require_colon = 1;
-        }
-        if (c == 'k') {
-            c = 'H';
-        }
-        else if (c == 'l') {
-            c = 'I';
-        }
-        else if (c == 'P') {
-            c = 'p';
-        }
-        if (c == '%') {
-            if (pos == length || data[pos++] != '%') {
-                return 0;
-            }
-            continue;
-        }
-
-        /* 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';
-        }
-        else if (c == 'I') {
-            field = 'H';
-        }
-        else if (c == 'W') {
-            field = 'U';
-        }
-        unsigned int bit = directive_bits[field];
-        if (bit == 0) {
-            return 0;
-        }
+        unsigned int bit = directive_bits[c];
         if (seen & bit) {
             return 0;
         }
         seen |= bit;
 
-        if (c == 'b' || c == 'B' || c == 'a' || c == 'A' || c == 'p') {
-            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 if (c == 'p') {
-                ampm = value;
+        /* Dispatch once: numeric fields don't need to test for names,
+         * aliases or timezone spellings before parsing their digits.
+         */
+        int minimum = 1;
+        int maximum = 2;
+        switch (c) {
+            case 'Y':
+            case 'G':
+                minimum = maximum = 4;
+                break;
+            case 'y':
+                minimum = maximum = 2;
+                break;
+            case 'f':
+                maximum = 6;
+                break;
+            case 'j':
+                maximum = 3;
+                break;
+            case 'w':
+            case 'u':
+                maximum = 1;
+                break;
+            case 'd':
+            case 'e':
+            case 'H':
+            case 'k':
+            case 'I':
+            case 'l':
+                if (pos < length && data[pos] == ' ') {
+                    pos++;
+                    maximum = 1;
+                }
+                break;
+            case 'm':
+            case 'M':
+            case 'S':
+            case 'U':
+            case 'W':
+            case 'V':
+                break;
+            case 'b':
+            case 'B':
+            case 'a':
+            case 'A':
+            case 'p':
+            case 'P': {
+                int value;
+                int count = strptime_name(data, length, pos,
+                                          c == 'P' ? 'p' : c, &value);
+                if (count == 0) {
+                    return 0;
+                }
+                pos += count;
+                if (bit == MONTH) {
+                    fields->month = value;
+                }
+                else if (bit == AMPM) {
+                    ampm = value;
+                }
+                else {
+                    fields->weekday = value;
+                }
+                continue;
             }
-            else {
-                fields->weekday = value;
+            case 'Z':
+                /* Local timezone names and nonterminal names retain Python's
+                 * tzset state, DST rules and regex backtracking.
+                 */
+                if (i != fmt_length - 1 || length - pos != 3 ||
+                    !((Py_TOLOWER(data[pos]) == 'u' &&
+                       Py_TOLOWER(data[pos + 1]) == 't' &&
+                       Py_TOLOWER(data[pos + 2]) == 'c') ||
+                      (Py_TOLOWER(data[pos]) == 'g' &&
+                       Py_TOLOWER(data[pos + 1]) == 'm' &&
+                       Py_TOLOWER(data[pos + 2]) == 't'))) {
+                    return 0;
+                }
+                fields->zone_start = pos;
+                fields->zone_length = 3;
+                pos = length;
+                continue;
+            case ':':
+                if (++i == fmt_length || fmt[i] != 'z') {
+                    return 0;
+                }
+                _Py_FALLTHROUGH;
+            case 'z': {
+                int count = strptime_offset(data, length, pos, c == ':', fields);
+                if (count < 0) {
+                    return 0;
+                }
+                pos += count;
+                continue;
             }
-            continue;
-        }
-
-        if (c == 'Z') {
-            /* Local timezone names and nonterminal names retain Python's
-             * tzset state, DST rules and regex backtracking.
-             */
-            if (i != fmt_length - 1 || length - pos != 3 ||
-                !((Py_TOLOWER(data[pos]) == 'u' &&
-                   Py_TOLOWER(data[pos + 1]) == 't' &&
-                   Py_TOLOWER(data[pos + 2]) == 'c') ||
-                  (Py_TOLOWER(data[pos]) == 'g' &&
-                   Py_TOLOWER(data[pos + 1]) == 'm' &&
-                   Py_TOLOWER(data[pos + 2]) == 't'))) {
-                return 0;
+            case 'F':
+            case 'D':
+            case 'T':
+            case 'R': {
+                const char *alias;
+                switch (c) {
+                    case 'F': alias = "%Y-%m-%d"; break;
+                    case 'D': alias = "%m/%d/%y"; break;
+                    case 'T': alias = "%H:%M:%S"; break;
+                    default: alias = "%H:%M"; break;
+                }
+                /* These fixed expansions contain no further aliases. Parsing
+                 * them in place keeps duplicate-field checks and avoids copying
+                 * an arbitrarily long user format into a temporary buffer.
+                 */
+                assert(outer_fmt == NULL);
+                outer_fmt = fmt;
+                outer_length = fmt_length;
+                outer_pos = i + 1;
+                fmt = (const unsigned char *)alias;
+                fmt_length = strlen(alias);
+                i = -1;
+                continue;
             }
-            fields->zone_start = pos;
-            fields->zone_length = 3;
-            pos = length;
-            continue;
-        }
-        if (c == 'z') {
-            int count = strptime_offset(data, length, pos, require_colon, fields);
-            if (count < 0) {
+            case 'n':
+            case 't':
+                while (pos < length && Py_UNICODE_ISSPACE(data[pos])) {
+                    pos++;
+                }
+                continue;
+            case '%':
+                if (pos == length || data[pos++] != '%') {
+                    return 0;
+                }
+                continue;
+            default:
                 return 0;
-            }
-            pos += count;
-            continue;
-        }
-
-        int minimum = 1;
-        int maximum = 2;
-        if (c == 'Y' || c == 'G') {
-            minimum = maximum = 4;
-        }
-        else if (c == 'y') {
-            minimum = maximum = 2;
-        }
-        else if (c == 'f') {
-            maximum = 6;
-        }
-        else if (c == 'j') {
-            maximum = 3;
-        }
-        else if (field == 'w') {
-            maximum = 1;
-        }
-        else if ((c == 'd' || c == 'H' || c == 'I') &&
-                 pos < length && data[pos] == ' ') {
-            pos++;
-            maximum = 1;
         }
         int value;
         int count = strptime_digits(data, length, pos, minimum, maximum, &value);
@@ -480,6 +492,7 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
                 iso_week = value;
                 break;
             case 'I':
+            case 'l':
                 if (value < 1 || value > 12) {
                     return 0;
                 }
@@ -511,12 +524,14 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
                 fields->month = value;
                 break;
             case 'd':
+            case 'e':
                 if (value < 1 || value > 31) {
                     return 0;
                 }
                 fields->day = value;
                 break;
             case 'H':
+            case 'k':
                 if (value > 23) {
                     return 0;
                 }
@@ -612,8 +627,5 @@ _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;
 }