Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 1 | """Strptime-related classes and functions. |
| 2 | |
| 3 | CLASSES: |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 4 | LocaleTime -- Discovers and stores locale-specific time information |
Barry Warsaw | 4d895fa | 2002-09-23 22:46:49 +0000 | [diff] [blame] | 5 | TimeRE -- Creates regexes for pattern matching a string of text containing |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 6 | time information |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 7 | |
| 8 | FUNCTIONS: |
Raymond Hettinger | 1fdb633 | 2003-03-09 07:44:42 +0000 | [diff] [blame] | 9 | _getlang -- Figure out what language is being used for the locale |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 10 | strptime -- Calculates the time struct represented by the passed-in string |
| 11 | |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 12 | """ |
| 13 | import time |
| 14 | import locale |
| 15 | import calendar |
| 16 | from re import compile as re_compile |
Victor Stinner | 7fa767e | 2014-03-20 09:16:38 +0100 | [diff] [blame] | 17 | from re import IGNORECASE |
Brett Cannon | 4f35c71 | 2004-10-06 02:11:37 +0000 | [diff] [blame] | 18 | from re import escape as re_escape |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 19 | from datetime import (date as datetime_date, |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 20 | timedelta as datetime_timedelta, |
| 21 | timezone as datetime_timezone) |
Antoine Pitrou | a6a4dc8 | 2017-09-07 18:56:24 +0200 | [diff] [blame] | 22 | from _thread import allocate_lock as _thread_allocate_lock |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 23 | |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 24 | __all__ = [] |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 25 | |
Tim Peters | 80cebc1 | 2003-01-19 04:40:44 +0000 | [diff] [blame] | 26 | def _getlang(): |
| 27 | # Figure out what the current language is set to. |
Brett Cannon | 175ddb5 | 2003-07-24 06:27:17 +0000 | [diff] [blame] | 28 | return locale.getlocale(locale.LC_TIME) |
Barry Warsaw | 35816e6 | 2002-08-29 16:24:50 +0000 | [diff] [blame] | 29 | |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 30 | class LocaleTime(object): |
| 31 | """Stores and handles locale-specific information related to time. |
| 32 | |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 33 | ATTRIBUTES: |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 34 | f_weekday -- full weekday names (7-item list) |
| 35 | a_weekday -- abbreviated weekday names (7-item list) |
Brett Cannon | f5c96fb | 2003-08-08 01:53:05 +0000 | [diff] [blame] | 36 | f_month -- full month names (13-item list; dummy value in [0], which |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 37 | is added by code) |
Brett Cannon | f5c96fb | 2003-08-08 01:53:05 +0000 | [diff] [blame] | 38 | a_month -- abbreviated month names (13-item list, dummy value in |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 39 | [0], which is added by code) |
| 40 | am_pm -- AM/PM representation (2-item list) |
| 41 | LC_date_time -- format string for date/time representation (string) |
| 42 | LC_date -- format string for date representation (string) |
| 43 | LC_time -- format string for time representation (string) |
Tim Peters | 469cdad | 2002-08-08 20:19:19 +0000 | [diff] [blame] | 44 | timezone -- daylight- and non-daylight-savings timezone representation |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 45 | (2-item list of sets) |
| 46 | lang -- Language used by instance (2-item tuple) |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 47 | """ |
| 48 | |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 49 | def __init__(self): |
| 50 | """Set all attributes. |
Raymond Hettinger | 6b59f5f | 2003-10-16 05:53:16 +0000 | [diff] [blame] | 51 | |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 52 | Order of methods called matters for dependency reasons. |
| 53 | |
| 54 | The locale language is set at the offset and then checked again before |
| 55 | exiting. This is to make sure that the attributes were not set with a |
| 56 | mix of information from more than one locale. This would most likely |
| 57 | happen when using threads where one thread calls a locale-dependent |
| 58 | function while another thread changes the locale while the function in |
| 59 | the other thread is still running. Proper coding would call for |
| 60 | locks to prevent changing the locale while locale-dependent code is |
| 61 | running. The check here is done in case someone does not think about |
| 62 | doing this. |
Brett Cannon | 5187a3b | 2003-08-11 07:24:05 +0000 | [diff] [blame] | 63 | |
| 64 | Only other possible issue is if someone changed the timezone and did |
| 65 | not call tz.tzset . That is an issue for the programmer, though, |
| 66 | since changing the timezone is worthless without that call. |
Raymond Hettinger | 6b59f5f | 2003-10-16 05:53:16 +0000 | [diff] [blame] | 67 | |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 68 | """ |
| 69 | self.lang = _getlang() |
| 70 | self.__calc_weekday() |
| 71 | self.__calc_month() |
| 72 | self.__calc_am_pm() |
| 73 | self.__calc_timezone() |
| 74 | self.__calc_date_time() |
| 75 | if _getlang() != self.lang: |
| 76 | raise ValueError("locale changed during initialization") |
Serhiy Storchaka | c7217d7 | 2015-12-03 22:21:07 +0200 | [diff] [blame] | 77 | if time.tzname != self.tzname or time.daylight != self.daylight: |
| 78 | raise ValueError("timezone changed during initialization") |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 79 | |
| 80 | def __pad(self, seq, front): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 81 | # Add '' to seq to either the front (is True), else the back. |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 82 | seq = list(seq) |
Barry Warsaw | 35816e6 | 2002-08-29 16:24:50 +0000 | [diff] [blame] | 83 | if front: |
| 84 | seq.insert(0, '') |
| 85 | else: |
| 86 | seq.append('') |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 87 | return seq |
| 88 | |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 89 | def __calc_weekday(self): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 90 | # Set self.a_weekday and self.f_weekday using the calendar |
Barry Warsaw | 35816e6 | 2002-08-29 16:24:50 +0000 | [diff] [blame] | 91 | # module. |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 92 | a_weekday = [calendar.day_abbr[i].lower() for i in range(7)] |
| 93 | f_weekday = [calendar.day_name[i].lower() for i in range(7)] |
| 94 | self.a_weekday = a_weekday |
| 95 | self.f_weekday = f_weekday |
Tim Peters | 469cdad | 2002-08-08 20:19:19 +0000 | [diff] [blame] | 96 | |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 97 | def __calc_month(self): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 98 | # Set self.f_month and self.a_month using the calendar module. |
| 99 | a_month = [calendar.month_abbr[i].lower() for i in range(13)] |
| 100 | f_month = [calendar.month_name[i].lower() for i in range(13)] |
| 101 | self.a_month = a_month |
| 102 | self.f_month = f_month |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 103 | |
| 104 | def __calc_am_pm(self): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 105 | # Set self.am_pm by using time.strftime(). |
Tim Peters | 469cdad | 2002-08-08 20:19:19 +0000 | [diff] [blame] | 106 | |
Barry Warsaw | 35816e6 | 2002-08-29 16:24:50 +0000 | [diff] [blame] | 107 | # The magic date (1999,3,17,hour,44,55,2,76,0) is not really that |
| 108 | # magical; just happened to have used it everywhere else where a |
| 109 | # static date was needed. |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 110 | am_pm = [] |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 111 | for hour in (1, 22): |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 112 | time_tuple = time.struct_time((1999,3,17,hour,44,55,2,76,0)) |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 113 | am_pm.append(time.strftime("%p", time_tuple).lower()) |
| 114 | self.am_pm = am_pm |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 115 | |
| 116 | def __calc_date_time(self): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 117 | # Set self.date_time, self.date, & self.time by using |
Barry Warsaw | 35816e6 | 2002-08-29 16:24:50 +0000 | [diff] [blame] | 118 | # time.strftime(). |
Tim Peters | 469cdad | 2002-08-08 20:19:19 +0000 | [diff] [blame] | 119 | |
Barry Warsaw | 35816e6 | 2002-08-29 16:24:50 +0000 | [diff] [blame] | 120 | # Use (1999,3,17,22,44,55,2,76,0) for magic date because the amount of |
| 121 | # overloaded numbers is minimized. The order in which searches for |
| 122 | # values within the format string is very important; it eliminates |
| 123 | # possible ambiguity for what something represents. |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 124 | time_tuple = time.struct_time((1999,3,17,22,44,55,2,76,0)) |
| 125 | date_time = [None, None, None] |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 126 | date_time[0] = time.strftime("%c", time_tuple).lower() |
| 127 | date_time[1] = time.strftime("%x", time_tuple).lower() |
| 128 | date_time[2] = time.strftime("%X", time_tuple).lower() |
| 129 | replacement_pairs = [('%', '%%'), (self.f_weekday[2], '%A'), |
Barry Warsaw | 4d895fa | 2002-09-23 22:46:49 +0000 | [diff] [blame] | 130 | (self.f_month[3], '%B'), (self.a_weekday[2], '%a'), |
| 131 | (self.a_month[3], '%b'), (self.am_pm[1], '%p'), |
Barry Warsaw | 4d895fa | 2002-09-23 22:46:49 +0000 | [diff] [blame] | 132 | ('1999', '%Y'), ('99', '%y'), ('22', '%H'), |
| 133 | ('44', '%M'), ('55', '%S'), ('76', '%j'), |
| 134 | ('17', '%d'), ('03', '%m'), ('3', '%m'), |
| 135 | # '3' needed for when no leading zero. |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 136 | ('2', '%w'), ('10', '%I')] |
| 137 | replacement_pairs.extend([(tz, "%Z") for tz_values in self.timezone |
| 138 | for tz in tz_values]) |
| 139 | for offset,directive in ((0,'%c'), (1,'%x'), (2,'%X')): |
| 140 | current_format = date_time[offset] |
| 141 | for old, new in replacement_pairs: |
Jack Jansen | 62fe755 | 2003-01-15 22:59:39 +0000 | [diff] [blame] | 142 | # Must deal with possible lack of locale info |
| 143 | # manifesting itself as the empty string (e.g., Swedish's |
| 144 | # lack of AM/PM info) or a platform returning a tuple of empty |
| 145 | # strings (e.g., MacOS 9 having timezone as ('','')). |
| 146 | if old: |
Barry Warsaw | 4d895fa | 2002-09-23 22:46:49 +0000 | [diff] [blame] | 147 | current_format = current_format.replace(old, new) |
Brett Cannon | f1b2ba6 | 2005-08-29 18:25:55 +0000 | [diff] [blame] | 148 | # If %W is used, then Sunday, 2005-01-03 will fall on week 0 since |
| 149 | # 2005-01-03 occurs before the first Monday of the year. Otherwise |
| 150 | # %U is used. |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 151 | time_tuple = time.struct_time((1999,1,3,1,1,1,6,3,0)) |
Brett Cannon | 6e372d1 | 2005-08-27 19:25:59 +0000 | [diff] [blame] | 152 | if '00' in time.strftime(directive, time_tuple): |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 153 | U_W = '%W' |
Brett Cannon | f1b2ba6 | 2005-08-29 18:25:55 +0000 | [diff] [blame] | 154 | else: |
| 155 | U_W = '%U' |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 156 | date_time[offset] = current_format.replace('11', U_W) |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 157 | self.LC_date_time = date_time[0] |
| 158 | self.LC_date = date_time[1] |
Raymond Hettinger | 6b59f5f | 2003-10-16 05:53:16 +0000 | [diff] [blame] | 159 | self.LC_time = date_time[2] |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 160 | |
| 161 | def __calc_timezone(self): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 162 | # Set self.timezone by using time.tzname. |
Serhiy Storchaka | c7217d7 | 2015-12-03 22:21:07 +0200 | [diff] [blame] | 163 | # Do not worry about possibility of time.tzname[0] == time.tzname[1] |
| 164 | # and time.daylight; handle that in strptime. |
Brett Cannon | abe8eb0 | 2003-05-13 20:28:15 +0000 | [diff] [blame] | 165 | try: |
| 166 | time.tzset() |
| 167 | except AttributeError: |
| 168 | pass |
Serhiy Storchaka | c7217d7 | 2015-12-03 22:21:07 +0200 | [diff] [blame] | 169 | self.tzname = time.tzname |
| 170 | self.daylight = time.daylight |
Serhiy Storchaka | b1f64e7 | 2015-12-03 22:26:36 +0200 | [diff] [blame] | 171 | no_saving = frozenset({"utc", "gmt", self.tzname[0].lower()}) |
Serhiy Storchaka | c7217d7 | 2015-12-03 22:21:07 +0200 | [diff] [blame] | 172 | if self.daylight: |
Serhiy Storchaka | b1f64e7 | 2015-12-03 22:26:36 +0200 | [diff] [blame] | 173 | has_saving = frozenset({self.tzname[1].lower()}) |
Brett Cannon | 172d9ef | 2003-05-11 06:23:36 +0000 | [diff] [blame] | 174 | else: |
Raymond Hettinger | a690a99 | 2003-11-16 16:17:49 +0000 | [diff] [blame] | 175 | has_saving = frozenset() |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 176 | self.timezone = (no_saving, has_saving) |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 177 | |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 178 | |
| 179 | class TimeRE(dict): |
| 180 | """Handle conversion from format directives to regexes.""" |
| 181 | |
Brett Cannon | 2c24d42 | 2003-07-24 20:02:28 +0000 | [diff] [blame] | 182 | def __init__(self, locale_time=None): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 183 | """Create keys/values. |
Raymond Hettinger | 6b59f5f | 2003-10-16 05:53:16 +0000 | [diff] [blame] | 184 | |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 185 | Order of execution is important for dependency reasons. |
Raymond Hettinger | 6b59f5f | 2003-10-16 05:53:16 +0000 | [diff] [blame] | 186 | |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 187 | """ |
| 188 | if locale_time: |
| 189 | self.locale_time = locale_time |
| 190 | else: |
| 191 | self.locale_time = LocaleTime() |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 192 | base = super() |
Neal Norwitz | 5efc50d | 2002-12-30 22:23:12 +0000 | [diff] [blame] | 193 | base.__init__({ |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 194 | # The " \d" part of the regex is to make %c from ANSI C work |
Neal Norwitz | 5efc50d | 2002-12-30 22:23:12 +0000 | [diff] [blame] | 195 | 'd': r"(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])", |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 196 | 'f': r"(?P<f>[0-9]{1,6})", |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 197 | 'H': r"(?P<H>2[0-3]|[0-1]\d|\d)", |
Neal Norwitz | 5efc50d | 2002-12-30 22:23:12 +0000 | [diff] [blame] | 198 | 'I': r"(?P<I>1[0-2]|0[1-9]|[1-9])", |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 199 | 'G': r"(?P<G>\d\d\d\d)", |
Neal Norwitz | 5efc50d | 2002-12-30 22:23:12 +0000 | [diff] [blame] | 200 | 'j': r"(?P<j>36[0-6]|3[0-5]\d|[1-2]\d\d|0[1-9]\d|00[1-9]|[1-9]\d|0[1-9]|[1-9])", |
| 201 | 'm': r"(?P<m>1[0-2]|0[1-9]|[1-9])", |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 202 | 'M': r"(?P<M>[0-5]\d|\d)", |
| 203 | 'S': r"(?P<S>6[0-1]|[0-5]\d|\d)", |
| 204 | 'U': r"(?P<U>5[0-3]|[0-4]\d|\d)", |
| 205 | 'w': r"(?P<w>[0-6])", |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 206 | 'u': r"(?P<u>[1-7])", |
| 207 | 'V': r"(?P<V>5[0-3]|0[1-9]|[1-4]\d|\d)", |
Neal Norwitz | 5efc50d | 2002-12-30 22:23:12 +0000 | [diff] [blame] | 208 | # W is set below by using 'U' |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 209 | 'y': r"(?P<y>\d\d)", |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 210 | #XXX: Does 'Y' need to worry about having less or more than |
| 211 | # 4 digits? |
| 212 | 'Y': r"(?P<Y>\d\d\d\d)", |
Mario Corchero | 3231893 | 2017-10-26 01:35:41 +0100 | [diff] [blame] | 213 | 'z': r"(?P<z>[+-]\d\d:?[0-5]\d(:?[0-5]\d(\.\d{1,6})?)?|Z)", |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 214 | 'A': self.__seqToRE(self.locale_time.f_weekday, 'A'), |
| 215 | 'a': self.__seqToRE(self.locale_time.a_weekday, 'a'), |
| 216 | 'B': self.__seqToRE(self.locale_time.f_month[1:], 'B'), |
| 217 | 'b': self.__seqToRE(self.locale_time.a_month[1:], 'b'), |
| 218 | 'p': self.__seqToRE(self.locale_time.am_pm, 'p'), |
Brett Cannon | f7948c2 | 2004-10-06 02:23:14 +0000 | [diff] [blame] | 219 | 'Z': self.__seqToRE((tz for tz_names in self.locale_time.timezone |
| 220 | for tz in tz_names), |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 221 | 'Z'), |
| 222 | '%': '%'}) |
Brett Cannon | 8abcc5d | 2004-10-18 01:37:57 +0000 | [diff] [blame] | 223 | base.__setitem__('W', base.__getitem__('U').replace('U', 'W')) |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 224 | base.__setitem__('c', self.pattern(self.locale_time.LC_date_time)) |
| 225 | base.__setitem__('x', self.pattern(self.locale_time.LC_date)) |
| 226 | base.__setitem__('X', self.pattern(self.locale_time.LC_time)) |
Tim Peters | 469cdad | 2002-08-08 20:19:19 +0000 | [diff] [blame] | 227 | |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 228 | def __seqToRE(self, to_convert, directive): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 229 | """Convert a list to a regex string for matching a directive. |
Raymond Hettinger | 6b59f5f | 2003-10-16 05:53:16 +0000 | [diff] [blame] | 230 | |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 231 | Want possible matching values to be from longest to shortest. This |
Ezio Melotti | 30b9d5d | 2013-08-17 15:50:46 +0300 | [diff] [blame] | 232 | prevents the possibility of a match occurring for a value that also |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 233 | a substring of a larger value that should have matched (e.g., 'abc' |
| 234 | matching when 'abcdef' should have been the match). |
Raymond Hettinger | 6b59f5f | 2003-10-16 05:53:16 +0000 | [diff] [blame] | 235 | |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 236 | """ |
Brett Cannon | ffa5cf9 | 2004-10-06 22:48:58 +0000 | [diff] [blame] | 237 | to_convert = sorted(to_convert, key=len, reverse=True) |
Jack Jansen | 62fe755 | 2003-01-15 22:59:39 +0000 | [diff] [blame] | 238 | for value in to_convert: |
| 239 | if value != '': |
| 240 | break |
| 241 | else: |
| 242 | return '' |
Brett Cannon | 4f35c71 | 2004-10-06 02:11:37 +0000 | [diff] [blame] | 243 | regex = '|'.join(re_escape(stuff) for stuff in to_convert) |
Barry Warsaw | 4d895fa | 2002-09-23 22:46:49 +0000 | [diff] [blame] | 244 | regex = '(?P<%s>%s' % (directive, regex) |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 245 | return '%s)' % regex |
| 246 | |
| 247 | def pattern(self, format): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 248 | """Return regex pattern for the format string. |
Tim Peters | 0eadaac | 2003-04-24 16:02:54 +0000 | [diff] [blame] | 249 | |
Brett Cannon | 1e91d8e | 2003-04-19 04:00:56 +0000 | [diff] [blame] | 250 | Need to make sure that any characters that might be interpreted as |
Brett Cannon | 5187a3b | 2003-08-11 07:24:05 +0000 | [diff] [blame] | 251 | regex syntax are escaped. |
Tim Peters | 0eadaac | 2003-04-24 16:02:54 +0000 | [diff] [blame] | 252 | |
Brett Cannon | 1e91d8e | 2003-04-19 04:00:56 +0000 | [diff] [blame] | 253 | """ |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 254 | processed_format = '' |
Brett Cannon | 1e91d8e | 2003-04-19 04:00:56 +0000 | [diff] [blame] | 255 | # The sub() call escapes all characters that might be misconstrued |
Brett Cannon | 4f35c71 | 2004-10-06 02:11:37 +0000 | [diff] [blame] | 256 | # as regex syntax. Cannot use re.escape since we have to deal with |
| 257 | # format directives (%m, etc.). |
Brett Cannon | 953c6f5 | 2003-08-29 02:28:54 +0000 | [diff] [blame] | 258 | regex_chars = re_compile(r"([\\.^$*+?\(\){}\[\]|])") |
Brett Cannon | 1e91d8e | 2003-04-19 04:00:56 +0000 | [diff] [blame] | 259 | format = regex_chars.sub(r"\\\1", format) |
Serhiy Storchaka | 15fa1c4 | 2015-03-25 01:21:50 +0200 | [diff] [blame] | 260 | whitespace_replacement = re_compile(r'\s+') |
| 261 | format = whitespace_replacement.sub(r'\\s+', format) |
Raymond Hettinger | bac788a | 2004-05-04 09:21:43 +0000 | [diff] [blame] | 262 | while '%' in format: |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 263 | directive_index = format.index('%')+1 |
Tim Peters | 469cdad | 2002-08-08 20:19:19 +0000 | [diff] [blame] | 264 | processed_format = "%s%s%s" % (processed_format, |
Barry Warsaw | 35816e6 | 2002-08-29 16:24:50 +0000 | [diff] [blame] | 265 | format[:directive_index-1], |
| 266 | self[format[directive_index]]) |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 267 | format = format[directive_index+1:] |
| 268 | return "%s%s" % (processed_format, format) |
| 269 | |
| 270 | def compile(self, format): |
| 271 | """Return a compiled re object for the format string.""" |
Brett Cannon | 7f6b4f8 | 2009-03-30 21:30:26 +0000 | [diff] [blame] | 272 | return re_compile(self.pattern(format), IGNORECASE) |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 273 | |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 274 | _cache_lock = _thread_allocate_lock() |
| 275 | # DO NOT modify _TimeRE_cache or _regex_cache without acquiring the cache lock |
| 276 | # first! |
| 277 | _TimeRE_cache = TimeRE() |
Brett Cannon | 5187a3b | 2003-08-11 07:24:05 +0000 | [diff] [blame] | 278 | _CACHE_MAX_SIZE = 5 # Max number of regexes stored in _regex_cache |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 279 | _regex_cache = {} |
Guido van Rossum | 00efe7e | 2002-07-19 17:04:46 +0000 | [diff] [blame] | 280 | |
Thomas Wouters | 9fe394c | 2007-02-05 01:24:16 +0000 | [diff] [blame] | 281 | def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_starts_Mon): |
| 282 | """Calculate the Julian day based on the year, week of the year, and day of |
| 283 | the week, with week_start_day representing whether the week of the year |
| 284 | assumes the week starts on Sunday or Monday (6 or 0).""" |
| 285 | first_weekday = datetime_date(year, 1, 1).weekday() |
| 286 | # If we are dealing with the %U directive (week starts on Sunday), it's |
| 287 | # easier to just shift the view to Sunday being the first day of the |
| 288 | # week. |
| 289 | if not week_starts_Mon: |
| 290 | first_weekday = (first_weekday + 1) % 7 |
| 291 | day_of_week = (day_of_week + 1) % 7 |
| 292 | # Need to watch out for a week 0 (when the first day of the year is not |
| 293 | # the same as that specified by %U or %W). |
| 294 | week_0_length = (7 - first_weekday) % 7 |
| 295 | if week_of_year == 0: |
| 296 | return 1 + day_of_week - first_weekday |
| 297 | else: |
| 298 | days_to_week = week_0_length + (7 * (week_of_year - 1)) |
| 299 | return 1 + days_to_week + day_of_week |
| 300 | |
| 301 | |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 302 | def _calc_julian_from_V(iso_year, iso_week, iso_weekday): |
| 303 | """Calculate the Julian day based on the ISO 8601 year, week, and weekday. |
| 304 | ISO weeks start on Mondays, with week 01 being the week containing 4 Jan. |
| 305 | ISO week days range from 1 (Monday) to 7 (Sunday). |
| 306 | """ |
| 307 | correction = datetime_date(iso_year, 1, 4).isoweekday() + 3 |
| 308 | ordinal = (iso_week * 7) + iso_weekday - correction |
| 309 | # ordinal may be negative or 0 now, which means the date is in the previous |
| 310 | # calendar year |
| 311 | if ordinal < 1: |
| 312 | ordinal += datetime_date(iso_year, 1, 1).toordinal() |
| 313 | iso_year -= 1 |
| 314 | ordinal -= datetime_date(iso_year, 1, 1).toordinal() |
| 315 | return iso_year, ordinal |
| 316 | |
| 317 | |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 318 | def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"): |
Alexander Belopolsky | f568218 | 2010-06-18 18:44:37 +0000 | [diff] [blame] | 319 | """Return a 2-tuple consisting of a time struct and an int containing |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 320 | the number of microseconds based on the input string and the |
| 321 | format string.""" |
Brett Cannon | 7f6b4f8 | 2009-03-30 21:30:26 +0000 | [diff] [blame] | 322 | |
| 323 | for index, arg in enumerate([data_string, format]): |
| 324 | if not isinstance(arg, str): |
| 325 | msg = "strptime() argument {} must be str, not {}" |
Brett Cannon | 71095ea | 2009-03-31 03:58:04 +0000 | [diff] [blame] | 326 | raise TypeError(msg.format(index, type(arg))) |
Brett Cannon | 7f6b4f8 | 2009-03-30 21:30:26 +0000 | [diff] [blame] | 327 | |
Brett Cannon | a783d06 | 2005-09-15 02:34:56 +0000 | [diff] [blame] | 328 | global _TimeRE_cache, _regex_cache |
Thomas Wouters | 9fe394c | 2007-02-05 01:24:16 +0000 | [diff] [blame] | 329 | with _cache_lock: |
Serhiy Storchaka | c7217d7 | 2015-12-03 22:21:07 +0200 | [diff] [blame] | 330 | locale_time = _TimeRE_cache.locale_time |
| 331 | if (_getlang() != locale_time.lang or |
| 332 | time.tzname != locale_time.tzname or |
| 333 | time.daylight != locale_time.daylight): |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 334 | _TimeRE_cache = TimeRE() |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 335 | _regex_cache.clear() |
Serhiy Storchaka | c7217d7 | 2015-12-03 22:21:07 +0200 | [diff] [blame] | 336 | locale_time = _TimeRE_cache.locale_time |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 337 | if len(_regex_cache) > _CACHE_MAX_SIZE: |
| 338 | _regex_cache.clear() |
| 339 | format_regex = _regex_cache.get(format) |
| 340 | if not format_regex: |
Brett Cannon | 5d0bf94 | 2005-11-02 23:04:26 +0000 | [diff] [blame] | 341 | try: |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 342 | format_regex = _TimeRE_cache.compile(format) |
Brett Cannon | 5d0bf94 | 2005-11-02 23:04:26 +0000 | [diff] [blame] | 343 | # KeyError raised when a bad format is found; can be specified as |
| 344 | # \\, in which case it was a stray % but with a space after it |
Guido van Rossum | b940e11 | 2007-01-10 16:19:56 +0000 | [diff] [blame] | 345 | except KeyError as err: |
Brett Cannon | 5d0bf94 | 2005-11-02 23:04:26 +0000 | [diff] [blame] | 346 | bad_directive = err.args[0] |
| 347 | if bad_directive == "\\": |
| 348 | bad_directive = "%" |
| 349 | del err |
| 350 | raise ValueError("'%s' is a bad directive in format '%s'" % |
Ezio Melotti | 0f38908 | 2013-04-04 02:09:20 +0300 | [diff] [blame] | 351 | (bad_directive, format)) from None |
Brett Cannon | 5d0bf94 | 2005-11-02 23:04:26 +0000 | [diff] [blame] | 352 | # IndexError only occurs when the format string is "%" |
| 353 | except IndexError: |
Serhiy Storchaka | cdac302 | 2013-11-24 18:15:37 +0200 | [diff] [blame] | 354 | raise ValueError("stray %% in format '%s'" % format) from None |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 355 | _regex_cache[format] = format_regex |
Tim Peters | 80cebc1 | 2003-01-19 04:40:44 +0000 | [diff] [blame] | 356 | found = format_regex.match(data_string) |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 357 | if not found: |
Thomas Wouters | 89f507f | 2006-12-13 04:49:30 +0000 | [diff] [blame] | 358 | raise ValueError("time data %r does not match format %r" % |
Raymond Hettinger | 4a6302b | 2003-07-13 01:31:38 +0000 | [diff] [blame] | 359 | (data_string, format)) |
Brett Cannon | 2b6dfec | 2003-04-28 21:30:13 +0000 | [diff] [blame] | 360 | if len(data_string) != found.end(): |
| 361 | raise ValueError("unconverted data remains: %s" % |
| 362 | data_string[found.end():]) |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 363 | |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 364 | iso_year = year = None |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 365 | month = day = 1 |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 366 | hour = minute = second = fraction = 0 |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 367 | tz = -1 |
Mario Corchero | 3231893 | 2017-10-26 01:35:41 +0100 | [diff] [blame] | 368 | gmtoff = None |
| 369 | gmtoff_fraction = 0 |
Brett Cannon | 8dc25ad | 2004-10-18 01:47:46 +0000 | [diff] [blame] | 370 | # Default to -1 to signify that values not known; not critical to have, |
| 371 | # though |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 372 | iso_week = week_of_year = None |
| 373 | week_of_year_start = None |
Serhiy Storchaka | 423feea | 2015-03-19 19:13:37 +0200 | [diff] [blame] | 374 | # weekday and julian defaulted to None so as to signal need to calculate |
Brett Cannon | 8dc25ad | 2004-10-18 01:47:46 +0000 | [diff] [blame] | 375 | # values |
Serhiy Storchaka | 423feea | 2015-03-19 19:13:37 +0200 | [diff] [blame] | 376 | weekday = julian = None |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 377 | found_dict = found.groupdict() |
Guido van Rossum | cc2b016 | 2007-02-11 06:12:03 +0000 | [diff] [blame] | 378 | for group_key in found_dict.keys(): |
Brett Cannon | 8abcc5d | 2004-10-18 01:37:57 +0000 | [diff] [blame] | 379 | # Directives not explicitly handled below: |
| 380 | # c, x, X |
| 381 | # handled by making out of other directives |
| 382 | # U, W |
| 383 | # worthless without day of the week |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 384 | if group_key == 'y': |
| 385 | year = int(found_dict['y']) |
| 386 | # Open Group specification for strptime() states that a %y |
| 387 | #value in the range of [00, 68] is in the century 2000, while |
| 388 | #[69,99] is in the century 1900 |
| 389 | if year <= 68: |
| 390 | year += 2000 |
| 391 | else: |
| 392 | year += 1900 |
| 393 | elif group_key == 'Y': |
| 394 | year = int(found_dict['Y']) |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 395 | elif group_key == 'G': |
| 396 | iso_year = int(found_dict['G']) |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 397 | elif group_key == 'm': |
| 398 | month = int(found_dict['m']) |
| 399 | elif group_key == 'B': |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 400 | month = locale_time.f_month.index(found_dict['B'].lower()) |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 401 | elif group_key == 'b': |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 402 | month = locale_time.a_month.index(found_dict['b'].lower()) |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 403 | elif group_key == 'd': |
| 404 | day = int(found_dict['d']) |
Neal Norwitz | 77290f2 | 2003-06-29 04:16:49 +0000 | [diff] [blame] | 405 | elif group_key == 'H': |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 406 | hour = int(found_dict['H']) |
| 407 | elif group_key == 'I': |
| 408 | hour = int(found_dict['I']) |
| 409 | ampm = found_dict.get('p', '').lower() |
| 410 | # If there was no AM/PM indicator, we'll treat this like AM |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 411 | if ampm in ('', locale_time.am_pm[0]): |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 412 | # We're in AM so the hour is correct unless we're |
| 413 | # looking at 12 midnight. |
| 414 | # 12 midnight == 12 AM == hour 0 |
| 415 | if hour == 12: |
| 416 | hour = 0 |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 417 | elif ampm == locale_time.am_pm[1]: |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 418 | # We're in PM so we need to add 12 to the hour unless |
| 419 | # we're looking at 12 noon. |
| 420 | # 12 noon == 12 PM == hour 12 |
| 421 | if hour != 12: |
| 422 | hour += 12 |
| 423 | elif group_key == 'M': |
| 424 | minute = int(found_dict['M']) |
| 425 | elif group_key == 'S': |
| 426 | second = int(found_dict['S']) |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 427 | elif group_key == 'f': |
| 428 | s = found_dict['f'] |
| 429 | # Pad to always return microseconds. |
| 430 | s += "0" * (6 - len(s)) |
| 431 | fraction = int(s) |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 432 | elif group_key == 'A': |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 433 | weekday = locale_time.f_weekday.index(found_dict['A'].lower()) |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 434 | elif group_key == 'a': |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 435 | weekday = locale_time.a_weekday.index(found_dict['a'].lower()) |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 436 | elif group_key == 'w': |
| 437 | weekday = int(found_dict['w']) |
| 438 | if weekday == 0: |
| 439 | weekday = 6 |
| 440 | else: |
| 441 | weekday -= 1 |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 442 | elif group_key == 'u': |
| 443 | weekday = int(found_dict['u']) |
| 444 | weekday -= 1 |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 445 | elif group_key == 'j': |
| 446 | julian = int(found_dict['j']) |
Brett Cannon | 8abcc5d | 2004-10-18 01:37:57 +0000 | [diff] [blame] | 447 | elif group_key in ('U', 'W'): |
| 448 | week_of_year = int(found_dict[group_key]) |
| 449 | if group_key == 'U': |
Thomas Wouters | 9fe394c | 2007-02-05 01:24:16 +0000 | [diff] [blame] | 450 | # U starts week on Sunday. |
Brett Cannon | 8abcc5d | 2004-10-18 01:37:57 +0000 | [diff] [blame] | 451 | week_of_year_start = 6 |
| 452 | else: |
Thomas Wouters | 9fe394c | 2007-02-05 01:24:16 +0000 | [diff] [blame] | 453 | # W starts week on Monday. |
Brett Cannon | 8abcc5d | 2004-10-18 01:37:57 +0000 | [diff] [blame] | 454 | week_of_year_start = 0 |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 455 | elif group_key == 'V': |
| 456 | iso_week = int(found_dict['V']) |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 457 | elif group_key == 'z': |
| 458 | z = found_dict['z'] |
Mario Corchero | 3231893 | 2017-10-26 01:35:41 +0100 | [diff] [blame] | 459 | if z == 'Z': |
| 460 | gmtoff = 0 |
| 461 | else: |
| 462 | if z[3] == ':': |
| 463 | z = z[:3] + z[4:] |
| 464 | if len(z) > 5: |
| 465 | if z[5] != ':': |
| 466 | msg = f"Unconsistent use of : in {found_dict['z']}" |
| 467 | raise ValueError(msg) |
| 468 | z = z[:5] + z[6:] |
| 469 | hours = int(z[1:3]) |
| 470 | minutes = int(z[3:5]) |
| 471 | seconds = int(z[5:7] or 0) |
| 472 | gmtoff = (hours * 60 * 60) + (minutes * 60) + seconds |
Mario Corchero | f80c0ca | 2018-01-09 21:37:26 +0000 | [diff] [blame^] | 473 | gmtoff_remainder = z[8:] |
| 474 | # Pad to always return microseconds. |
| 475 | gmtoff_remainder_padding = "0" * (6 - len(gmtoff_remainder)) |
| 476 | gmtoff_fraction = int(gmtoff_remainder + gmtoff_remainder_padding) |
Mario Corchero | 3231893 | 2017-10-26 01:35:41 +0100 | [diff] [blame] | 477 | if z.startswith("-"): |
| 478 | gmtoff = -gmtoff |
| 479 | gmtoff_fraction = -gmtoff_fraction |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 480 | elif group_key == 'Z': |
Brett Cannon | 172d9ef | 2003-05-11 06:23:36 +0000 | [diff] [blame] | 481 | # Since -1 is default value only need to worry about setting tz if |
| 482 | # it can be something other than -1. |
Tim Peters | 08e5427 | 2003-01-18 03:53:49 +0000 | [diff] [blame] | 483 | found_zone = found_dict['Z'].lower() |
Brett Cannon | 5187a3b | 2003-08-11 07:24:05 +0000 | [diff] [blame] | 484 | for value, tz_values in enumerate(locale_time.timezone): |
| 485 | if found_zone in tz_values: |
| 486 | # Deal with bad locale setup where timezone names are the |
| 487 | # same and yet time.daylight is true; too ambiguous to |
| 488 | # be able to tell what timezone has daylight savings |
Brett Cannon | 8172ac3 | 2004-03-07 23:16:27 +0000 | [diff] [blame] | 489 | if (time.tzname[0] == time.tzname[1] and |
| 490 | time.daylight and found_zone not in ("utc", "gmt")): |
Tim Peters | 58eb11c | 2004-01-18 20:29:55 +0000 | [diff] [blame] | 491 | break |
Brett Cannon | 5187a3b | 2003-08-11 07:24:05 +0000 | [diff] [blame] | 492 | else: |
Brett Cannon | 474335c | 2003-08-05 04:02:49 +0000 | [diff] [blame] | 493 | tz = value |
Brett Cannon | 5187a3b | 2003-08-11 07:24:05 +0000 | [diff] [blame] | 494 | break |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 495 | # Deal with the cases where ambiguities arize |
| 496 | # don't assume default values for ISO week/year |
| 497 | if year is None and iso_year is not None: |
| 498 | if iso_week is None or weekday is None: |
| 499 | raise ValueError("ISO year directive '%G' must be used with " |
| 500 | "the ISO week directive '%V' and a weekday " |
| 501 | "directive ('%A', '%a', '%w', or '%u').") |
| 502 | if julian is not None: |
| 503 | raise ValueError("Day of the year directive '%j' is not " |
| 504 | "compatible with ISO year directive '%G'. " |
| 505 | "Use '%Y' instead.") |
| 506 | elif week_of_year is None and iso_week is not None: |
| 507 | if weekday is None: |
| 508 | raise ValueError("ISO week directive '%V' must be used with " |
| 509 | "the ISO year directive '%G' and a weekday " |
| 510 | "directive ('%A', '%a', '%w', or '%u').") |
| 511 | else: |
| 512 | raise ValueError("ISO week directive '%V' is incompatible with " |
| 513 | "the year directive '%Y'. Use the ISO year '%G' " |
| 514 | "instead.") |
| 515 | |
Antoine Pitrou | 072e4a3 | 2012-05-14 19:44:59 +0200 | [diff] [blame] | 516 | leap_year_fix = False |
Antoine Pitrou | 1682e5d | 2012-05-10 20:17:46 +0200 | [diff] [blame] | 517 | if year is None and month == 2 and day == 29: |
| 518 | year = 1904 # 1904 is first leap year of 20th century |
Antoine Pitrou | 072e4a3 | 2012-05-14 19:44:59 +0200 | [diff] [blame] | 519 | leap_year_fix = True |
Antoine Pitrou | 1682e5d | 2012-05-10 20:17:46 +0200 | [diff] [blame] | 520 | elif year is None: |
| 521 | year = 1900 |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 522 | |
| 523 | |
Brett Cannon | 8abcc5d | 2004-10-18 01:37:57 +0000 | [diff] [blame] | 524 | # If we know the week of the year and what day of that week, we can figure |
Thomas Wouters | 9fe394c | 2007-02-05 01:24:16 +0000 | [diff] [blame] | 525 | # out the Julian day of the year. |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 526 | if julian is None and weekday is not None: |
| 527 | if week_of_year is not None: |
| 528 | week_starts_Mon = True if week_of_year_start == 0 else False |
| 529 | julian = _calc_julian_from_U_or_W(year, week_of_year, weekday, |
| 530 | week_starts_Mon) |
| 531 | elif iso_year is not None and iso_week is not None: |
| 532 | year, julian = _calc_julian_from_V(iso_year, iso_week, weekday + 1) |
Serhiy Storchaka | 6e4150f | 2016-03-12 10:53:09 +0200 | [diff] [blame] | 533 | if julian is not None and julian <= 0: |
Serhiy Storchaka | 8a7240e | 2016-03-12 10:51:16 +0200 | [diff] [blame] | 534 | year -= 1 |
| 535 | yday = 366 if calendar.isleap(year) else 365 |
| 536 | julian += yday |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 537 | |
Serhiy Storchaka | 423feea | 2015-03-19 19:13:37 +0200 | [diff] [blame] | 538 | if julian is None: |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 539 | # Cannot pre-calculate datetime_date() since can change in Julian |
| 540 | # calculation and thus could have different value for the day of |
| 541 | # the week calculation. |
Raymond Hettinger | 1fdb633 | 2003-03-09 07:44:42 +0000 | [diff] [blame] | 542 | # Need to add 1 to result since first day of the year is 1, not 0. |
| 543 | julian = datetime_date(year, month, day).toordinal() - \ |
| 544 | datetime_date(year, 1, 1).toordinal() + 1 |
Alexander Belopolsky | 68713e4 | 2015-10-06 13:29:56 -0400 | [diff] [blame] | 545 | else: # Assume that if they bothered to include Julian day (or if it was |
| 546 | # calculated above with year/week/weekday) it will be accurate. |
| 547 | datetime_result = datetime_date.fromordinal( |
| 548 | (julian - 1) + |
| 549 | datetime_date(year, 1, 1).toordinal()) |
Raymond Hettinger | 1fdb633 | 2003-03-09 07:44:42 +0000 | [diff] [blame] | 550 | year = datetime_result.year |
| 551 | month = datetime_result.month |
| 552 | day = datetime_result.day |
Serhiy Storchaka | 423feea | 2015-03-19 19:13:37 +0200 | [diff] [blame] | 553 | if weekday is None: |
Raymond Hettinger | 1fdb633 | 2003-03-09 07:44:42 +0000 | [diff] [blame] | 554 | weekday = datetime_date(year, month, day).weekday() |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 555 | # Add timezone info |
| 556 | tzname = found_dict.get("Z") |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 557 | |
Antoine Pitrou | 072e4a3 | 2012-05-14 19:44:59 +0200 | [diff] [blame] | 558 | if leap_year_fix: |
| 559 | # the caller didn't supply a year but asked for Feb 29th. We couldn't |
| 560 | # use the default of 1900 for computations. We set it back to ensure |
| 561 | # that February 29th is smaller than March 1st. |
| 562 | year = 1900 |
| 563 | |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 564 | return (year, month, day, |
| 565 | hour, minute, second, |
Mario Corchero | 3231893 | 2017-10-26 01:35:41 +0100 | [diff] [blame] | 566 | weekday, julian, tz, tzname, gmtoff), fraction, gmtoff_fraction |
Christian Heimes | dd15f6c | 2008-03-16 00:07:10 +0000 | [diff] [blame] | 567 | |
| 568 | def _strptime_time(data_string, format="%a %b %d %H:%M:%S %Y"): |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 569 | """Return a time struct based on the input string and the |
| 570 | format string.""" |
| 571 | tt = _strptime(data_string, format)[0] |
Alexander Belopolsky | c142bba | 2012-06-13 22:15:26 -0400 | [diff] [blame] | 572 | return time.struct_time(tt[:time._STRUCT_TM_ITEMS]) |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 573 | |
Alexander Belopolsky | 4988d7a | 2010-07-14 13:46:57 +0000 | [diff] [blame] | 574 | def _strptime_datetime(cls, data_string, format="%a %b %d %H:%M:%S %Y"): |
| 575 | """Return a class cls instance based on the input string and the |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 576 | format string.""" |
Mario Corchero | 3231893 | 2017-10-26 01:35:41 +0100 | [diff] [blame] | 577 | tt, fraction, gmtoff_fraction = _strptime(data_string, format) |
Alexander Belopolsky | c142bba | 2012-06-13 22:15:26 -0400 | [diff] [blame] | 578 | tzname, gmtoff = tt[-2:] |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 579 | args = tt[:6] + (fraction,) |
| 580 | if gmtoff is not None: |
Mario Corchero | 3231893 | 2017-10-26 01:35:41 +0100 | [diff] [blame] | 581 | tzdelta = datetime_timedelta(seconds=gmtoff, microseconds=gmtoff_fraction) |
Alexander Belopolsky | ca94f55 | 2010-06-17 18:30:34 +0000 | [diff] [blame] | 582 | if tzname: |
| 583 | tz = datetime_timezone(tzdelta, tzname) |
| 584 | else: |
| 585 | tz = datetime_timezone(tzdelta) |
| 586 | args += (tz,) |
| 587 | |
Alexander Belopolsky | 4988d7a | 2010-07-14 13:46:57 +0000 | [diff] [blame] | 588 | return cls(*args) |