gh-120713: normalize year with century for datetime.strftime

Lib/_pydatetime.py

@@ -204,6 +204,17 @@ def _format_offset(off, sep=':'):
                 s += '.%06d' % ss.microseconds
     return s
 
+_normalize_century = None
+def _need_normalize_century():
+    global _normalize_century
+    if _normalize_century is None:
+        try:
+            _normalize_century = (
+                _time.strftime("%Y", (99, 1, 1, 0, 0, 0, 0, 1, 0)) != "0099")
+        except ValueError:
+            _normalize_century = True
+    return _normalize_century
+
 # Correctly substitute for %z and %Z escapes in strftime formats.
 def _wrap_strftime(object, format, timetuple):
     # Don't call utcoffset() or tzname() unless actually needed.
@@ -261,6 +272,12 @@ def _wrap_strftime(object, format, timetuple):
                                 # strftime is going to have at this: escape %
                                 Zreplace = s.replace('%', '%%')
                     newformat.append(Zreplace)
+                elif ch in 'YG' and _need_normalize_century():
+                    if ch == 'G':
+                        year = int(_time.strftime("%G", timetuple))
+                    else:
+                        year = object.year
+                    push('{:04}'.format(year))
                 else:
                     push('%')
                     push(ch)

Lib/test/datetimetester.py

@@ -1697,18 +1697,17 @@ def test_bool(self):
         self.assertTrue(self.theclass.max)
 
     def test_strftime_y2k(self):
-        for y in (1, 49, 70, 99, 100, 999, 1000, 1970):
-            d = self.theclass(y, 1, 1)
-            # Issue 13305:  For years < 1000, the value is not always
-            # padded to 4 digits across platforms.  The C standard
-            # assumes year >= 1900, so it does not specify the number
-            # of digits.
-            if d.strftime("%Y") != '%04d' % y:
-                # Year 42 returns '42', not padded
-                self.assertEqual(d.strftime("%Y"), '%d' % y)
-                # '0042' is obtained anyway
-                if support.has_strftime_extensions:
-                    self.assertEqual(d.strftime("%4Y"), '%04d' % y)
+        # Test that years less than 1000 are 0-padded; note that the beginning
+        # of an ISO 8601 year may fall in an ISO week of the year before, and
+        # therefore needs an offset of -1 when formatting with '%G'.
+        for y, o in ((1, 0), (49, -1), (70, 0), (99, 0), (100, -1), (999, 0),
+                     (1000, 0), (1970, 0)):
+            for s in 'YG':
+                with self.subTest(year=y, specifier=s):
+                    d = self.theclass(y, 1, 1)
+                    if s == 'G':
+                        y += o
+                    self.assertEqual(d.strftime("%" + s), '%04d' % y)
 
     def test_replace(self):
         cls = self.theclass

Misc/NEWS.d/next/Library/2024-06-21-06-37-46.gh-issue-120713.WBbQx4.rst

@@ -0,0 +1,2 @@
+:func:`datetime.datetime.strftime` now 0-pads a year <= 999 for the format specifier ``%Y`` on Linux.
+Patch by Ben Hsing

Modules/_datetimemodule.c

@@ -19,6 +19,7 @@
 #include "datetime.h"
 
 
+#include <stdlib.h>
 #include <time.h>
 
 #ifdef MS_WINDOWS
@@ -1837,6 +1838,10 @@ wrap_strftime(PyObject *object, PyObject *format, PyObject *timetuple,
     PyObject *colonzreplacement = NULL; /* py string, replacement for %:z */
     PyObject *Zreplacement = NULL;      /* py string, replacement for %Z */
     PyObject *freplacement = NULL;      /* py string, replacement for %f */
+#ifdef NORMALIZE_CENTURY
+    long year;                          /* year of timetuple as long */
+    char year_formatted[12];            /* formatted year with century for %Y */
+#endif
 
     const char *pin;            /* pointer to next char in input format */
     Py_ssize_t flen;            /* length of input format */
@@ -1873,6 +1878,11 @@ wrap_strftime(PyObject *object, PyObject *format, PyObject *timetuple,
     pnew = PyBytes_AsString(newfmt);
     usednew = 0;
 
+    PyObject *strftime = _PyImport_GetModuleAttrString("time", "strftime");
+
+    if (strftime == NULL)
+        goto Done;
+
     while ((ch = *pin++) != '\0') {
         if (ch != '%') {
             ptoappend = pin - 1;
@@ -1939,6 +1949,22 @@ wrap_strftime(PyObject *object, PyObject *format, PyObject *timetuple,
             ptoappend = PyBytes_AS_STRING(freplacement);
             ntoappend = PyBytes_GET_SIZE(freplacement);
         }
+#ifdef NORMALIZE_CENTURY
+        else if (ch == 'Y' || ch == 'G') {
+            /* 0-pad year with century as necessary */
+            if (ch == 'G') {
+                format = PyUnicode_FromString("%G");
+                result = PyObject_CallFunctionObjArgs(strftime, format,
+                                                      timetuple, NULL);
+                year = atoi(PyUnicode_AsUTF8(result));
+                Py_DECREF(format);
+                Py_DECREF(result);
+            } else
+                year = PyLong_AsLong(PyTuple_GET_ITEM(timetuple, 0));
+            ntoappend = sprintf(year_formatted, "%04ld", year);
+            ptoappend = year_formatted;
+        }
+#endif
         else {
             /* percent followed by something else */
             ptoappend = pin - 2;
@@ -1972,10 +1998,7 @@ wrap_strftime(PyObject *object, PyObject *format, PyObject *timetuple,
         goto Done;
     {
         PyObject *format;
-        PyObject *strftime = _PyImport_GetModuleAttrString("time", "strftime");
 
-        if (strftime == NULL)
-            goto Done;
         format = PyUnicode_FromString(PyBytes_AS_STRING(newfmt));
         if (format != NULL) {
             result = PyObject_CallFunctionObjArgs(strftime,

configure.ac

@@ -6572,6 +6572,33 @@ then
   [Define if you have struct stat.st_mtimensec])
 fi
 
+# Check if year with century should be normalized for strftime
+AC_CACHE_CHECK([whether year with century should be normalized for strftime], [ac_cv_normalize_century], [
+AC_RUN_IFELSE([AC_LANG_SOURCE([[
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+
+int main(void)
+{
+  char year[5];
+  struct tm date = {
+    .tm_year = -1801,
+    .tm_mon = 0,
+    .tm_mday = 1
+  };
+  exit(strftime(year, sizeof year, "%Y", &date) && !strcmp(year, "0099"));
+}
+]])],
+[ac_cv_normalize_century=yes],
+[ac_cv_normalize_century=no],
+[ac_cv_normalize_century=yes])])
+if test "$ac_cv_normalize_century" = yes
+then
+  AC_DEFINE([NORMALIZE_CENTURY], [1],
+  [Define if year with century should be normalized for strftime.])
+fi
+
 dnl check for ncurses/ncursesw and panel/panelw
 dnl NOTE: old curses is not detected.
 dnl have_curses=[no, ncursesw, ncurses]

pyconfig.h.in

@@ -1591,6 +1591,9 @@
 /* Define if mvwdelch in curses.h is an expression. */
 #undef MVWDELCH_IS_EXPRESSION
 
+/* Define if year with century should be normalized for strftime. */
+#undef NORMALIZE_CENTURY
+
 /* Define to the address where bug reports for this package should be sent. */
 #undef PACKAGE_BUGREPORT