gh-158252: Parse ordinal and week dates in C

Calculate dates for %j, %U/%W and %G/%V using the shared Gregorian
calendar helpers. Preserve explicit weekdays and time.strptime yday
values when a week or ordinal date crosses a year boundary.

Author: pganssle

Include/internal/pycore_time.h

@@ -340,7 +340,7 @@ _PyTime_Weekday(int year, int yday)
 }
 
 
-// Locale-independent numeric strptime parsing.
+// Shared strptime parsing, with fallback for unsupported inputs.
 // A complete match returns 1; otherwise use Lib/_strptime.py. This function
 // neither allocates nor sets exceptions. The calendar date is validated, but
 // seconds may be 60 or 61: callers must apply their own time validation.

Lib/test/test_strptime.py

@@ -16,6 +16,29 @@
 
 
 class PublicStrptimeTests(unittest.TestCase):
+    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):
+                self.assert_matches_python(f'{year:04d} {day:03d}', '%Y %j')
+            for week in (0, 1, 52, 53, 54):
+                for weekday in range(1, 8):
+                    for fmt in ('%Y %U %u', '%Y %W %u', '%G %V %u'):
+                        self.assert_matches_python(
+                            f'{year:04d} {week:02d} {weekday}', fmt)
+        for text, fmt in (
+            ('2023-02-31 060', '%Y-%m-%d %j'),
+            ('2024-12-31 001', '%Y-%m-%d %j'),
+            ('2023 366 1', '%Y %j %u'),
+            ('2024 53', '%Y %U'), ('366', '%j'),
+            ('2024 001 01 1', '%Y %j %W %u'),
+            ('2024 2020 01 1', '%Y %G %V %u'),
+            ('2024 001 01 1', '%G %j %V %u'),
+            ('2024 01 1', '%Y %V %u'), ('2024 01', '%G %V'),
+            ('2024', '%G'), ('0000 001', '%Y %j'),
+            ('2024 01 02 1', '%Y %U %W %u'),
+        ):
+            self.assert_matches_python(text, fmt)
+
     def test_numeric_aliases(self):
         for text, fmt in (
             ('2024-02-29', '%F'), ('02/29/24', '%D'),

Misc/NEWS.d/next/Library/2026-10-20-16-00-00.gh-issue-158252.weeks.rst

@@ -0,0 +1,4 @@
+Speed up parsing month and weekday names, 12-hour clocks, UTC offsets,
+numeric format aliases, and ordinal and week dates with :func:`time.strptime`,
+:meth:`datetime.date.strptime`, :meth:`datetime.time.strptime`, and
+:meth:`datetime.datetime.strptime`.

Python/_strptime.c

@@ -13,10 +13,10 @@
  * - %I with ASCII %p indicators, and the %k, %l, %P aliases;
  * - %z and %:z offsets with hours below 24, and terminal UTC/GMT %Z names;
  * - numeric aliases %F, %D, %T, %R, %e and whitespace %n/%t;
+ * - ordinal dates (%j), calendar weeks (%U/%W), and ISO weeks (%G/%V);
  * - 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 non-ASCII locale names and
- * week/day-of-year calculations).
+ * fallback. So do non-ASCII locale names and directives not listed above.
  */
 
 static int
@@ -103,6 +103,48 @@ strptime_name(const unsigned char *data, Py_ssize_t length, Py_ssize_t pos,
 #endif
 }
 
+static int
+strptime_date_from_ordinal(int ordinal, _PyTime_StrptimeFields *fields)
+{
+    if (ordinal < 1 || ordinal > _PyTime_DaysBeforeYear(10000)) {
+        return 0;
+    }
+    int lower = 1, upper = 10000;
+    while (lower + 1 < upper) {
+        int middle = (lower + upper) / 2;
+        if (_PyTime_DaysBeforeYear(middle) < ordinal) {
+            lower = middle;
+        }
+        else {
+            upper = middle;
+        }
+    }
+    fields->year = lower;
+    fields->yday = ordinal - _PyTime_DaysBeforeYear(lower);
+    fields->day = fields->yday;
+    int leap = lower % 4 == 0 && (lower % 100 != 0 || lower % 400 == 0);
+    static const int month_days[] = {31, 28, 31, 30, 31, 30,
+                                     31, 31, 30, 31, 30, 31};
+    for (fields->month = 1; fields->month < 12; fields->month++) {
+        int days = month_days[fields->month - 1] + (fields->month == 2 && leap);
+        if (fields->day <= days) {
+            break;
+        }
+        fields->day -= days;
+    }
+    if (fields->weekday < 0) {
+        fields->weekday = (ordinal - 1) % 7;
+    }
+    return 1;
+}
+
+static int
+strptime_iso_start(int year)
+{
+    /* ISO week 1 contains January 4. */
+    return _PyTime_DaysBeforeYear(year) + 4 - _PyTime_Weekday(year, 4);
+}
+
 static int
 strptime_offset(const unsigned char *data, Py_ssize_t length, Py_ssize_t pos,
                 int require_colon, _PyTime_StrptimeFields *fields)
@@ -159,7 +201,7 @@ strptime_offset(const unsigned char *data, Py_ssize_t length, Py_ssize_t pos,
     return (int)(pos - start);
 }
 
-/* Return 1 for a complete numeric match, or 0 if fallback is required.
+/* Return 1 for a complete match, or 0 if fallback is required.
  *
  * Parsing doesn't allocate or set exceptions. Some mismatches require regex
  * backtracking, but even inputs known to be invalid use the Python parser:
@@ -184,6 +226,10 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         WEEKDAY = 1U << 9,
         AMPM = 1U << 10,
         ZONE = 1U << 11,
+        JULIAN = 1U << 12,
+        WEEK = 1U << 13,
+        ISO_YEAR = 1U << 14,
+        ISO_WEEK = 1U << 15,
         ANY_YEAR = YEAR | SHORT_YEAR,
     };
     static const unsigned short directive_bits[128] = {
@@ -199,6 +245,10 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         ['w'] = WEEKDAY,
         ['p'] = AMPM,
         ['Z'] = ZONE,
+        ['j'] = JULIAN,
+        ['U'] = WEEK,
+        ['G'] = ISO_YEAR,
+        ['V'] = ISO_WEEK,
     };
     /* String subclasses and non-ASCII input retain Python's behavior. */
     if (!PyUnicode_CheckExact(string) || !PyUnicode_CheckExact(format) ||
@@ -216,6 +266,9 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
     unsigned int seen = 0;
     int hour12 = 0;
     int ampm = -1;
+    int julian = -1, week = -1, monday_first = 0;
+    int have_julian = 0;
+    int iso_year = -1, iso_week = -1;
     Py_ssize_t pos = 0;
 
     for (Py_ssize_t i = 0; ; i++) {
@@ -314,6 +367,9 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         else if (c == 'I') {
             field = 'H';
         }
+        else if (c == 'W') {
+            field = 'U';
+        }
         unsigned int bit = directive_bits[field];
         if (bit == 0) {
             return 0;
@@ -371,7 +427,7 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
 
         int minimum = 1;
         int maximum = 2;
-        if (c == 'Y') {
+        if (c == 'Y' || c == 'G') {
             minimum = maximum = 4;
         }
         else if (c == 'y') {
@@ -380,6 +436,9 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         else if (c == 'f') {
             maximum = 6;
         }
+        else if (c == 'j') {
+            maximum = 3;
+        }
         else if (field == 'w') {
             maximum = 1;
         }
@@ -395,6 +454,30 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         }
         pos += count;
         switch (c) {
+            case 'j':
+                if (value < 1 || value > 366) {
+                    return 0;
+                }
+                julian = value;
+                have_julian = 1;
+                break;
+            case 'U':
+            case 'W':
+                if (value > 53) {
+                    return 0;
+                }
+                week = value;
+                monday_first = c == 'W';
+                break;
+            case 'G':
+                iso_year = value;
+                break;
+            case 'V':
+                if (value < 1 || value > 53) {
+                    return 0;
+                }
+                iso_week = value;
+                break;
             case 'I':
                 if (value < 1 || value > 12) {
                     return 0;
@@ -464,6 +547,53 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
         }
         fields->hour = fields->hour % 12 + (ampm == 1 ? 12 : 0);
     }
+    /* Mixed fields and incomplete ISO dates retain Python's diagnostics. */
+    if (pos != length || (seen & ANY_YEAR) == ANY_YEAR ||
+        ((seen & DAY) && !(seen & ANY_YEAR) && iso_year < 0)) {
+        return 0;
+    }
+    if (iso_year >= 0 || iso_week >= 0) {
+        if (iso_year < 1 || iso_week < 1 || fields->weekday < 0 ||
+            julian >= 0 || week >= 0) {
+            return 0;
+        }
+        int monday = strptime_iso_start(iso_year) + 7 * (iso_week - 1);
+        if (monday >= strptime_iso_start(iso_year + 1) ||
+            !strptime_date_from_ordinal(monday + fields->weekday, fields)) {
+            return 0;
+        }
+    }
+    if (fields->year < 1) {
+        return 0;
+    }
+    if (julian < 0 && week >= 0 && fields->weekday >= 0) {
+        int first = _PyTime_Weekday(fields->year, 1);
+        int weekday = fields->weekday;
+        if (!monday_first) {
+            first = (first + 1) % 7;
+            weekday = (weekday + 1) % 7;
+        }
+        julian = week == 0 ? 1 + weekday - first
+                          : 1 + (7 - first) % 7 + 7 * (week - 1) + weekday;
+        have_julian = 1;
+    }
+    if (have_julian) {
+        /* Week zero can fall in the previous year. A day spilling into the
+         * next year retains its original yday in time.strptime's result.
+         */
+        int year = fields->year;
+        if (julian <= 0) {
+            if (year == 1) {
+                return 0;
+            }
+            year--;
+            julian += _PyTime_DaysBeforeYear(year + 1) - _PyTime_DaysBeforeYear(year);
+        }
+        if (!strptime_date_from_ordinal(_PyTime_DaysBeforeYear(year) + julian, fields)) {
+            return 0;
+        }
+        fields->yday = julian;
+    }
     static const int days_before_month[] = {
         0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
     };
@@ -474,15 +604,13 @@ _PyTime_Strptime(PyObject *string, PyObject *format, _PyTime_StrptimeFields *fie
     if (fields->month == 2) {
         month_days += leap;
     }
-    /* Mixed %Y/%y and day-without-year diagnostics belong to Python. */
-    if (pos != length || (seen & ANY_YEAR) == ANY_YEAR ||
-        ((seen & DAY) && !(seen & ANY_YEAR)) ||
-        fields->year < 1 ||
-        fields->day > month_days) {
+    if (fields->day > month_days) {
         return 0;
     }
-    fields->yday = days_before_month[fields->month] + fields->day +
-                   (fields->month > 2 && leap);
+    if (!have_julian) {
+        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);
     }