REF: de-vendor _stprtime code (#46736)

Author: jbrockmendel

pandas/_libs/tslibs/fields.pyx

@@ -4,6 +4,7 @@ objects and arrays
 """
 from locale import LC_TIME
 
+from _strptime import LocaleTime
 import cython
 from cython import Py_ssize_t
 import numpy as np
@@ -46,8 +47,6 @@ from pandas._libs.tslibs.np_datetime cimport (
     td64_to_tdstruct,
 )
 
-from pandas._libs.tslibs.strptime import LocaleTime
-
 
 @cython.wraparound(False)
 @cython.boundscheck(False)

pandas/_libs/tslibs/strptime.pyx

@@ -57,7 +57,7 @@ cdef dict _parse_code_table = {'y': 0,
                                'u': 22}
 
 
-def array_strptime(ndarray[object] values, object fmt, bint exact=True, errors='raise'):
+def array_strptime(ndarray[object] values, str fmt, bint exact=True, errors='raise'):
     """
     Calculates the datetime structs represented by the passed array of strings
 
@@ -349,7 +349,7 @@ def array_strptime(ndarray[object] values, object fmt, bint exact=True, errors='
 
 
 """
-_getlang, LocaleTime, TimeRE, _calc_julian_from_U_or_W are vendored
+TimeRE, _calc_julian_from_U_or_W are vendored
 from the standard library, see
 https://github.com/python/cpython/blob/master/Lib/_strptime.py
 The original module-level docstring follows.
@@ -364,161 +364,14 @@ FUNCTIONS:
     strptime -- Calculates the time struct represented by the passed-in string
 """
 
-
-def _getlang():
-    """Figure out what language is being used for the locale"""
-    return locale.getlocale(locale.LC_TIME)
-
-
-class LocaleTime:
-    """
-    Stores and handles locale-specific information related to time.
-
-    ATTRIBUTES:
-        f_weekday -- full weekday names (7-item list)
-        a_weekday -- abbreviated weekday names (7-item list)
-        f_month -- full month names (13-item list; dummy value in [0], which
-                    is added by code)
-        a_month -- abbreviated month names (13-item list, dummy value in
-                    [0], which is added by code)
-        am_pm -- AM/PM representation (2-item list)
-        LC_date_time -- format string for date/time representation (string)
-        LC_date -- format string for date representation (string)
-        LC_time -- format string for time representation (string)
-        timezone -- daylight- and non-daylight-savings timezone representation
-                    (2-item list of sets)
-        lang -- Language used by instance (2-item tuple)
-    """
-
-    def __init__(self):
-        """
-        Set all attributes.
-
-        Order of methods called matters for dependency reasons.
-
-        The locale language is set at the offset and then checked again before
-        exiting.  This is to make sure that the attributes were not set with a
-        mix of information from more than one locale.  This would most likely
-        happen when using threads where one thread calls a locale-dependent
-        function while another thread changes the locale while the function in
-        the other thread is still running.  Proper coding would call for
-        locks to prevent changing the locale while locale-dependent code is
-        running.  The check here is done in case someone does not think about
-        doing this.
-
-        Only other possible issue is if someone changed the timezone and did
-        not call tz.tzset .  That is an issue for the programmer, though,
-        since changing the timezone is worthless without that call.
-        """
-        self.lang = _getlang()
-        self.__calc_weekday()
-        self.__calc_month()
-        self.__calc_am_pm()
-        self.__calc_timezone()
-        self.__calc_date_time()
-        if _getlang() != self.lang:
-            raise ValueError("locale changed during initialization")
-
-    def __pad(self, seq, front):
-        # Add '' to seq to either the front (is True), else the back.
-        seq = list(seq)
-        if front:
-            seq.insert(0, '')
-        else:
-            seq.append('')
-        return seq
-
-    def __calc_weekday(self):
-        # Set self.a_weekday and self.f_weekday using the calendar
-        # module.
-        a_weekday = [calendar.day_abbr[i].lower() for i in range(7)]
-        f_weekday = [calendar.day_name[i].lower() for i in range(7)]
-        self.a_weekday = a_weekday
-        self.f_weekday = f_weekday
-
-    def __calc_month(self):
-        # Set self.f_month and self.a_month using the calendar module.
-        a_month = [calendar.month_abbr[i].lower() for i in range(13)]
-        f_month = [calendar.month_name[i].lower() for i in range(13)]
-        self.a_month = a_month
-        self.f_month = f_month
-
-    def __calc_am_pm(self):
-        # Set self.am_pm by using time.strftime().
-
-        # The magic date (1999,3,17,hour,44,55,2,76,0) is not really that
-        # magical; just happened to have used it everywhere else where a
-        # static date was needed.
-        am_pm = []
-        for hour in (01, 22):
-            time_tuple = time.struct_time(
-                (1999, 3, 17, hour, 44, 55, 2, 76, 0))
-            am_pm.append(time.strftime("%p", time_tuple).lower())
-        self.am_pm = am_pm
-
-    def __calc_date_time(self):
-        # Set self.date_time, self.date, & self.time by using
-        # time.strftime().
-
-        # Use (1999,3,17,22,44,55,2,76,0) for magic date because the amount of
-        # overloaded numbers is minimized.  The order in which searches for
-        # values within the format string is very important; it eliminates
-        # possible ambiguity for what something represents.
-        time_tuple = time.struct_time((1999, 3, 17, 22, 44, 55, 2, 76, 0))
-        date_time = [None, None, None]
-        date_time[0] = time.strftime("%c", time_tuple).lower()
-        date_time[1] = time.strftime("%x", time_tuple).lower()
-        date_time[2] = time.strftime("%X", time_tuple).lower()
-        replacement_pairs = [('%', '%%'), (self.f_weekday[2], '%A'),
-                             (self.f_month[3], '%B'),
-                             (self.a_weekday[2], '%a'),
-                             (self.a_month[3], '%b'), (self.am_pm[1], '%p'),
-                             ('1999', '%Y'), ('99', '%y'), ('22', '%H'),
-                             ('44', '%M'), ('55', '%S'), ('76', '%j'),
-                             ('17', '%d'), ('03', '%m'), ('3', '%m'),
-                             # '3' needed for when no leading zero.
-                             ('2', '%w'), ('10', '%I')]
-        replacement_pairs.extend([(tz, "%Z") for tz_values in self.timezone
-                                  for tz in tz_values])
-        for offset, directive in ((0, '%c'), (1, '%x'), (2, '%X')):
-            current_format = date_time[offset]
-            for old, new in replacement_pairs:
-                # Must deal with possible lack of locale info
-                # manifesting itself as the empty string (e.g., Swedish's
-                # lack of AM/PM info) or a platform returning a tuple of empty
-                # strings (e.g., MacOS 9 having timezone as ('','')).
-                if old:
-                    current_format = current_format.replace(old, new)
-            # If %W is used, then Sunday, 2005-01-03 will fall on week 0 since
-            # 2005-01-03 occurs before the first Monday of the year.  Otherwise
-            # %U is used.
-            time_tuple = time.struct_time((1999, 1, 3, 1, 1, 1, 6, 3, 0))
-            if '00' in time.strftime(directive, time_tuple):
-                U_W = '%W'
-            else:
-                U_W = '%U'
-            date_time[offset] = current_format.replace('11', U_W)
-        self.LC_date_time = date_time[0]
-        self.LC_date = date_time[1]
-        self.LC_time = date_time[2]
-
-    def __calc_timezone(self):
-        # Set self.timezone by using time.tzname.
-        # Do not worry about possibility of time.tzname[0] == timetzname[1]
-        # and time.daylight; handle that in strptime .
-        try:
-            time.tzset()
-        except AttributeError:
-            pass
-        no_saving = frozenset(["utc", "gmt", time.tzname[0].lower()])
-        if time.daylight:
-            has_saving = frozenset([time.tzname[1].lower()])
-        else:
-            has_saving = frozenset()
-        self.timezone = (no_saving, has_saving)
+from _strptime import (
+    LocaleTime,
+    TimeRE as _TimeRE,
+    _getlang,
+)
 
 
-class TimeRE(dict):
+class TimeRE(_TimeRE):
     """
     Handle conversion from format directives to regexes.
 
@@ -532,100 +385,20 @@ class TimeRE(dict):
 
         Order of execution is important for dependency reasons.
         """
-        if locale_time:
-            self.locale_time = locale_time
-        else:
-            self.locale_time = LocaleTime()
         self._Z = None
-        base = super()
-        base.__init__({
-            # The " \d" part of the regex is to make %c from ANSI C work
-            'd': r"(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])",
-            'f': r"(?P<f>[0-9]{1,9})",
-            'G': r"(?P<G>\d\d\d\d)",
-            'H': r"(?P<H>2[0-3]|[0-1]\d|\d)",
-            'I': r"(?P<I>1[0-2]|0[1-9]|[1-9])",
-            'j': (r"(?P<j>36[0-6]|3[0-5]\d|[1-2]\d\d|0[1-9]\d|00[1-9]|"
-                  r"[1-9]\d|0[1-9]|[1-9])"),
-            'm': r"(?P<m>1[0-2]|0[1-9]|[1-9])",
-            'M': r"(?P<M>[0-5]\d|\d)",
-            'S': r"(?P<S>6[0-1]|[0-5]\d|\d)",
-            'u': r"(?P<u>[1-7])",
-            'U': r"(?P<U>5[0-3]|[0-4]\d|\d)",
-            'V': r"(?P<V>5[0-3]|0[1-9]|[1-4]\d|\d)",
-            'w': r"(?P<w>[0-6])",
-            # W is set below by using 'U'
-            'y': r"(?P<y>\d\d)",
-            # TODO: Does 'Y' need to worry about having less or more than
-            #     4 digits?
-            'Y': r"(?P<Y>\d\d\d\d)",
-            'z': r"(?P<z>[+-]\d\d:?[0-5]\d(:?[0-5]\d(\.\d{1,6})?)?|Z)",
-            'A': self.__seqToRE(self.locale_time.f_weekday, 'A'),
-            'a': self.__seqToRE(self.locale_time.a_weekday, 'a'),
-            'B': self.__seqToRE(self.locale_time.f_month[1:], 'B'),
-            'b': self.__seqToRE(self.locale_time.a_month[1:], 'b'),
-            'p': self.__seqToRE(self.locale_time.am_pm, 'p'),
-            # 'Z' key is generated lazily via __getitem__
-            '%': '%'})
-        base.__setitem__('W', base.__getitem__('U').replace('U', 'W'))
-        base.__setitem__('c', self.pattern(self.locale_time.LC_date_time))
-        base.__setitem__('x', self.pattern(self.locale_time.LC_date))
-        base.__setitem__('X', self.pattern(self.locale_time.LC_time))
+        super().__init__(locale_time=locale_time)
 
     def __getitem__(self, key):
         if key == "Z":
             # lazy computation
             if self._Z is None:
                 self._Z = self.__seqToRE(pytz.all_timezones, 'Z')
+            # Note: handling Z is the key difference vs using the stdlib
+            # _strptime.TimeRE. test_to_datetime_parse_tzname_or_tzoffset with
+            # fmt='%Y-%m-%d %H:%M:%S %Z' fails with the stdlib version.
             return self._Z
         return super().__getitem__(key)
 
-    def __seqToRE(self, to_convert, directive):
-        """
-        Convert a list to a regex string for matching a directive.
-
-        Want possible matching values to be from longest to shortest.  This
-        prevents the possibility of a match occurring for a value that also
-        a substring of a larger value that should have matched (e.g., 'abc'
-        matching when 'abcdef' should have been the match).
-        """
-        to_convert = sorted(to_convert, key=len, reverse=True)
-        for value in to_convert:
-            if value != '':
-                break
-        else:
-            return ''
-        regex = '|'.join(re.escape(stuff) for stuff in to_convert)
-        regex = f"(?P<{directive}>{regex})"
-        return regex
-
-    def pattern(self, format):
-        """
-        Return regex pattern for the format string.
-
-        Need to make sure that any characters that might be interpreted as
-        regex syntax are escaped.
-        """
-        processed_format = ''
-        # The sub() call escapes all characters that might be misconstrued
-        # as regex syntax.  Cannot use re.escape since we have to deal with
-        # format directives (%m, etc.).
-        regex_chars = re.compile(r"([\\.^$*+?\(\){}\[\]|])")
-        format = regex_chars.sub(r"\\\1", format)
-        whitespace_replacement = re.compile(r'\s+')
-        format = whitespace_replacement.sub(r'\\s+', format)
-        while '%' in format:
-            directive_index = format.index('%') +1
-            processed_format = (f"{processed_format}"
-                                f"{format[:directive_index -1]}"
-                                f"{self[format[directive_index]]}")
-            format = format[directive_index +1:]
-        return f"{processed_format}{format}"
-
-    def compile(self, format):
-        """Return a compiled re object for the format string."""
-        return re.compile(self.pattern(format), re.IGNORECASE)
-
 
 _cache_lock = _thread_allocate_lock()
 # DO NOT modify _TimeRE_cache or _regex_cache without acquiring the cache lock