|
1 """Strptime-related classes and functions. |
|
2 |
|
3 CLASSES: |
|
4 LocaleTime -- Discovers and stores locale-specific time information |
|
5 TimeRE -- Creates regexes for pattern matching a string of text containing |
|
6 time information |
|
7 |
|
8 FUNCTIONS: |
|
9 _getlang -- Figure out what language is being used for the locale |
|
10 strptime -- Calculates the time struct represented by the passed-in string |
|
11 |
|
12 """ |
|
13 import time |
|
14 import locale |
|
15 import calendar |
|
16 from re import compile as re_compile |
|
17 from re import IGNORECASE |
|
18 from re import escape as re_escape |
|
19 from datetime import date as datetime_date |
|
20 try: |
|
21 from thread import allocate_lock as _thread_allocate_lock |
|
22 except: |
|
23 from dummy_thread import allocate_lock as _thread_allocate_lock |
|
24 |
|
25 __author__ = "Brett Cannon" |
|
26 __email__ = "brett@python.org" |
|
27 |
|
28 __all__ = ['strptime'] |
|
29 |
|
30 def _getlang(): |
|
31 # Figure out what the current language is set to. |
|
32 return locale.getlocale(locale.LC_TIME) |
|
33 |
|
34 class LocaleTime(object): |
|
35 """Stores and handles locale-specific information related to time. |
|
36 |
|
37 ATTRIBUTES: |
|
38 f_weekday -- full weekday names (7-item list) |
|
39 a_weekday -- abbreviated weekday names (7-item list) |
|
40 f_month -- full month names (13-item list; dummy value in [0], which |
|
41 is added by code) |
|
42 a_month -- abbreviated month names (13-item list, dummy value in |
|
43 [0], which is added by code) |
|
44 am_pm -- AM/PM representation (2-item list) |
|
45 LC_date_time -- format string for date/time representation (string) |
|
46 LC_date -- format string for date representation (string) |
|
47 LC_time -- format string for time representation (string) |
|
48 timezone -- daylight- and non-daylight-savings timezone representation |
|
49 (2-item list of sets) |
|
50 lang -- Language used by instance (2-item tuple) |
|
51 """ |
|
52 |
|
53 def __init__(self): |
|
54 """Set all attributes. |
|
55 |
|
56 Order of methods called matters for dependency reasons. |
|
57 |
|
58 The locale language is set at the offset and then checked again before |
|
59 exiting. This is to make sure that the attributes were not set with a |
|
60 mix of information from more than one locale. This would most likely |
|
61 happen when using threads where one thread calls a locale-dependent |
|
62 function while another thread changes the locale while the function in |
|
63 the other thread is still running. Proper coding would call for |
|
64 locks to prevent changing the locale while locale-dependent code is |
|
65 running. The check here is done in case someone does not think about |
|
66 doing this. |
|
67 |
|
68 Only other possible issue is if someone changed the timezone and did |
|
69 not call tz.tzset . That is an issue for the programmer, though, |
|
70 since changing the timezone is worthless without that call. |
|
71 |
|
72 """ |
|
73 self.lang = _getlang() |
|
74 self.__calc_weekday() |
|
75 self.__calc_month() |
|
76 self.__calc_am_pm() |
|
77 self.__calc_timezone() |
|
78 self.__calc_date_time() |
|
79 if _getlang() != self.lang: |
|
80 raise ValueError("locale changed during initialization") |
|
81 |
|
82 def __pad(self, seq, front): |
|
83 # Add '' to seq to either the front (is True), else the back. |
|
84 seq = list(seq) |
|
85 if front: |
|
86 seq.insert(0, '') |
|
87 else: |
|
88 seq.append('') |
|
89 return seq |
|
90 |
|
91 def __calc_weekday(self): |
|
92 # Set self.a_weekday and self.f_weekday using the calendar |
|
93 # module. |
|
94 a_weekday = [calendar.day_abbr[i].lower() for i in range(7)] |
|
95 f_weekday = [calendar.day_name[i].lower() for i in range(7)] |
|
96 self.a_weekday = a_weekday |
|
97 self.f_weekday = f_weekday |
|
98 |
|
99 def __calc_month(self): |
|
100 # Set self.f_month and self.a_month using the calendar module. |
|
101 a_month = [calendar.month_abbr[i].lower() for i in range(13)] |
|
102 f_month = [calendar.month_name[i].lower() for i in range(13)] |
|
103 self.a_month = a_month |
|
104 self.f_month = f_month |
|
105 |
|
106 def __calc_am_pm(self): |
|
107 # Set self.am_pm by using time.strftime(). |
|
108 |
|
109 # The magic date (1999,3,17,hour,44,55,2,76,0) is not really that |
|
110 # magical; just happened to have used it everywhere else where a |
|
111 # static date was needed. |
|
112 am_pm = [] |
|
113 for hour in (01,22): |
|
114 time_tuple = time.struct_time((1999,3,17,hour,44,55,2,76,0)) |
|
115 am_pm.append(time.strftime("%p", time_tuple).lower()) |
|
116 self.am_pm = am_pm |
|
117 |
|
118 def __calc_date_time(self): |
|
119 # Set self.date_time, self.date, & self.time by using |
|
120 # time.strftime(). |
|
121 |
|
122 # Use (1999,3,17,22,44,55,2,76,0) for magic date because the amount of |
|
123 # overloaded numbers is minimized. The order in which searches for |
|
124 # values within the format string is very important; it eliminates |
|
125 # possible ambiguity for what something represents. |
|
126 time_tuple = time.struct_time((1999,3,17,22,44,55,2,76,0)) |
|
127 date_time = [None, None, None] |
|
128 date_time[0] = time.strftime("%c", time_tuple).lower() |
|
129 date_time[1] = time.strftime("%x", time_tuple).lower() |
|
130 date_time[2] = time.strftime("%X", time_tuple).lower() |
|
131 replacement_pairs = [('%', '%%'), (self.f_weekday[2], '%A'), |
|
132 (self.f_month[3], '%B'), (self.a_weekday[2], '%a'), |
|
133 (self.a_month[3], '%b'), (self.am_pm[1], '%p'), |
|
134 ('1999', '%Y'), ('99', '%y'), ('22', '%H'), |
|
135 ('44', '%M'), ('55', '%S'), ('76', '%j'), |
|
136 ('17', '%d'), ('03', '%m'), ('3', '%m'), |
|
137 # '3' needed for when no leading zero. |
|
138 ('2', '%w'), ('10', '%I')] |
|
139 replacement_pairs.extend([(tz, "%Z") for tz_values in self.timezone |
|
140 for tz in tz_values]) |
|
141 for offset,directive in ((0,'%c'), (1,'%x'), (2,'%X')): |
|
142 current_format = date_time[offset] |
|
143 for old, new in replacement_pairs: |
|
144 # Must deal with possible lack of locale info |
|
145 # manifesting itself as the empty string (e.g., Swedish's |
|
146 # lack of AM/PM info) or a platform returning a tuple of empty |
|
147 # strings (e.g., MacOS 9 having timezone as ('','')). |
|
148 if old: |
|
149 current_format = current_format.replace(old, new) |
|
150 # If %W is used, then Sunday, 2005-01-03 will fall on week 0 since |
|
151 # 2005-01-03 occurs before the first Monday of the year. Otherwise |
|
152 # %U is used. |
|
153 time_tuple = time.struct_time((1999,1,3,1,1,1,6,3,0)) |
|
154 if '00' in time.strftime(directive, time_tuple): |
|
155 U_W = '%W' |
|
156 else: |
|
157 U_W = '%U' |
|
158 date_time[offset] = current_format.replace('11', U_W) |
|
159 self.LC_date_time = date_time[0] |
|
160 self.LC_date = date_time[1] |
|
161 self.LC_time = date_time[2] |
|
162 |
|
163 def __calc_timezone(self): |
|
164 # Set self.timezone by using time.tzname. |
|
165 # Do not worry about possibility of time.tzname[0] == timetzname[1] |
|
166 # and time.daylight; handle that in strptime . |
|
167 try: |
|
168 time.tzset() |
|
169 except AttributeError: |
|
170 pass |
|
171 no_saving = frozenset(["utc", "gmt", time.tzname[0].lower()]) |
|
172 if time.daylight: |
|
173 has_saving = frozenset([time.tzname[1].lower()]) |
|
174 else: |
|
175 has_saving = frozenset() |
|
176 self.timezone = (no_saving, has_saving) |
|
177 |
|
178 |
|
179 class TimeRE(dict): |
|
180 """Handle conversion from format directives to regexes.""" |
|
181 |
|
182 def __init__(self, locale_time=None): |
|
183 """Create keys/values. |
|
184 |
|
185 Order of execution is important for dependency reasons. |
|
186 |
|
187 """ |
|
188 if locale_time: |
|
189 self.locale_time = locale_time |
|
190 else: |
|
191 self.locale_time = LocaleTime() |
|
192 base = super(TimeRE, self) |
|
193 base.__init__({ |
|
194 # The " \d" part of the regex is to make %c from ANSI C work |
|
195 'd': r"(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])", |
|
196 'H': r"(?P<H>2[0-3]|[0-1]\d|\d)", |
|
197 'I': r"(?P<I>1[0-2]|0[1-9]|[1-9])", |
|
198 '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])", |
|
199 'm': r"(?P<m>1[0-2]|0[1-9]|[1-9])", |
|
200 'M': r"(?P<M>[0-5]\d|\d)", |
|
201 'S': r"(?P<S>6[0-1]|[0-5]\d|\d)", |
|
202 'U': r"(?P<U>5[0-3]|[0-4]\d|\d)", |
|
203 'w': r"(?P<w>[0-6])", |
|
204 # W is set below by using 'U' |
|
205 'y': r"(?P<y>\d\d)", |
|
206 #XXX: Does 'Y' need to worry about having less or more than |
|
207 # 4 digits? |
|
208 'Y': r"(?P<Y>\d\d\d\d)", |
|
209 'A': self.__seqToRE(self.locale_time.f_weekday, 'A'), |
|
210 'a': self.__seqToRE(self.locale_time.a_weekday, 'a'), |
|
211 'B': self.__seqToRE(self.locale_time.f_month[1:], 'B'), |
|
212 'b': self.__seqToRE(self.locale_time.a_month[1:], 'b'), |
|
213 'p': self.__seqToRE(self.locale_time.am_pm, 'p'), |
|
214 'Z': self.__seqToRE((tz for tz_names in self.locale_time.timezone |
|
215 for tz in tz_names), |
|
216 'Z'), |
|
217 '%': '%'}) |
|
218 base.__setitem__('W', base.__getitem__('U').replace('U', 'W')) |
|
219 base.__setitem__('c', self.pattern(self.locale_time.LC_date_time)) |
|
220 base.__setitem__('x', self.pattern(self.locale_time.LC_date)) |
|
221 base.__setitem__('X', self.pattern(self.locale_time.LC_time)) |
|
222 |
|
223 def __seqToRE(self, to_convert, directive): |
|
224 """Convert a list to a regex string for matching a directive. |
|
225 |
|
226 Want possible matching values to be from longest to shortest. This |
|
227 prevents the possibility of a match occuring for a value that also |
|
228 a substring of a larger value that should have matched (e.g., 'abc' |
|
229 matching when 'abcdef' should have been the match). |
|
230 |
|
231 """ |
|
232 to_convert = sorted(to_convert, key=len, reverse=True) |
|
233 for value in to_convert: |
|
234 if value != '': |
|
235 break |
|
236 else: |
|
237 return '' |
|
238 regex = '|'.join(re_escape(stuff) for stuff in to_convert) |
|
239 regex = '(?P<%s>%s' % (directive, regex) |
|
240 return '%s)' % regex |
|
241 |
|
242 def pattern(self, format): |
|
243 """Return regex pattern for the format string. |
|
244 |
|
245 Need to make sure that any characters that might be interpreted as |
|
246 regex syntax are escaped. |
|
247 |
|
248 """ |
|
249 processed_format = '' |
|
250 # The sub() call escapes all characters that might be misconstrued |
|
251 # as regex syntax. Cannot use re.escape since we have to deal with |
|
252 # format directives (%m, etc.). |
|
253 regex_chars = re_compile(r"([\\.^$*+?\(\){}\[\]|])") |
|
254 format = regex_chars.sub(r"\\\1", format) |
|
255 whitespace_replacement = re_compile('\s+') |
|
256 format = whitespace_replacement.sub('\s+', format) |
|
257 while '%' in format: |
|
258 directive_index = format.index('%')+1 |
|
259 processed_format = "%s%s%s" % (processed_format, |
|
260 format[:directive_index-1], |
|
261 self[format[directive_index]]) |
|
262 format = format[directive_index+1:] |
|
263 return "%s%s" % (processed_format, format) |
|
264 |
|
265 def compile(self, format): |
|
266 """Return a compiled re object for the format string.""" |
|
267 return re_compile(self.pattern(format), IGNORECASE) |
|
268 |
|
269 _cache_lock = _thread_allocate_lock() |
|
270 # DO NOT modify _TimeRE_cache or _regex_cache without acquiring the cache lock |
|
271 # first! |
|
272 _TimeRE_cache = TimeRE() |
|
273 _CACHE_MAX_SIZE = 5 # Max number of regexes stored in _regex_cache |
|
274 _regex_cache = {} |
|
275 |
|
276 def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_starts_Mon): |
|
277 """Calculate the Julian day based on the year, week of the year, and day of |
|
278 the week, with week_start_day representing whether the week of the year |
|
279 assumes the week starts on Sunday or Monday (6 or 0).""" |
|
280 first_weekday = datetime_date(year, 1, 1).weekday() |
|
281 # If we are dealing with the %U directive (week starts on Sunday), it's |
|
282 # easier to just shift the view to Sunday being the first day of the |
|
283 # week. |
|
284 if not week_starts_Mon: |
|
285 first_weekday = (first_weekday + 1) % 7 |
|
286 day_of_week = (day_of_week + 1) % 7 |
|
287 # Need to watch out for a week 0 (when the first day of the year is not |
|
288 # the same as that specified by %U or %W). |
|
289 week_0_length = (7 - first_weekday) % 7 |
|
290 if week_of_year == 0: |
|
291 return 1 + day_of_week - first_weekday |
|
292 else: |
|
293 days_to_week = week_0_length + (7 * (week_of_year - 1)) |
|
294 return 1 + days_to_week + day_of_week |
|
295 |
|
296 |
|
297 def strptime(data_string, format="%a %b %d %H:%M:%S %Y"): |
|
298 """Return a time struct based on the input string and the format string.""" |
|
299 global _TimeRE_cache, _regex_cache |
|
300 _cache_lock.acquire() |
|
301 try: |
|
302 if _getlang() != _TimeRE_cache.locale_time.lang: |
|
303 _TimeRE_cache = TimeRE() |
|
304 _regex_cache.clear() |
|
305 if len(_regex_cache) > _CACHE_MAX_SIZE: |
|
306 _regex_cache.clear() |
|
307 locale_time = _TimeRE_cache.locale_time |
|
308 format_regex = _regex_cache.get(format) |
|
309 if not format_regex: |
|
310 try: |
|
311 format_regex = _TimeRE_cache.compile(format) |
|
312 # KeyError raised when a bad format is found; can be specified as |
|
313 # \\, in which case it was a stray % but with a space after it |
|
314 except KeyError, err: |
|
315 bad_directive = err.args[0] |
|
316 if bad_directive == "\\": |
|
317 bad_directive = "%" |
|
318 del err |
|
319 raise ValueError("'%s' is a bad directive in format '%s'" % |
|
320 (bad_directive, format)) |
|
321 # IndexError only occurs when the format string is "%" |
|
322 except IndexError: |
|
323 raise ValueError("stray %% in format '%s'" % format) |
|
324 _regex_cache[format] = format_regex |
|
325 finally: |
|
326 _cache_lock.release() |
|
327 found = format_regex.match(data_string) |
|
328 if not found: |
|
329 raise ValueError("time data did not match format: data=%s fmt=%s" % |
|
330 (data_string, format)) |
|
331 if len(data_string) != found.end(): |
|
332 raise ValueError("unconverted data remains: %s" % |
|
333 data_string[found.end():]) |
|
334 year = 1900 |
|
335 month = day = 1 |
|
336 hour = minute = second = 0 |
|
337 tz = -1 |
|
338 # Default to -1 to signify that values not known; not critical to have, |
|
339 # though |
|
340 week_of_year = -1 |
|
341 week_of_year_start = -1 |
|
342 # weekday and julian defaulted to -1 so as to signal need to calculate |
|
343 # values |
|
344 weekday = julian = -1 |
|
345 found_dict = found.groupdict() |
|
346 for group_key in found_dict.iterkeys(): |
|
347 # Directives not explicitly handled below: |
|
348 # c, x, X |
|
349 # handled by making out of other directives |
|
350 # U, W |
|
351 # worthless without day of the week |
|
352 if group_key == 'y': |
|
353 year = int(found_dict['y']) |
|
354 # Open Group specification for strptime() states that a %y |
|
355 #value in the range of [00, 68] is in the century 2000, while |
|
356 #[69,99] is in the century 1900 |
|
357 if year <= 68: |
|
358 year += 2000 |
|
359 else: |
|
360 year += 1900 |
|
361 elif group_key == 'Y': |
|
362 year = int(found_dict['Y']) |
|
363 elif group_key == 'm': |
|
364 month = int(found_dict['m']) |
|
365 elif group_key == 'B': |
|
366 month = locale_time.f_month.index(found_dict['B'].lower()) |
|
367 elif group_key == 'b': |
|
368 month = locale_time.a_month.index(found_dict['b'].lower()) |
|
369 elif group_key == 'd': |
|
370 day = int(found_dict['d']) |
|
371 elif group_key == 'H': |
|
372 hour = int(found_dict['H']) |
|
373 elif group_key == 'I': |
|
374 hour = int(found_dict['I']) |
|
375 ampm = found_dict.get('p', '').lower() |
|
376 # If there was no AM/PM indicator, we'll treat this like AM |
|
377 if ampm in ('', locale_time.am_pm[0]): |
|
378 # We're in AM so the hour is correct unless we're |
|
379 # looking at 12 midnight. |
|
380 # 12 midnight == 12 AM == hour 0 |
|
381 if hour == 12: |
|
382 hour = 0 |
|
383 elif ampm == locale_time.am_pm[1]: |
|
384 # We're in PM so we need to add 12 to the hour unless |
|
385 # we're looking at 12 noon. |
|
386 # 12 noon == 12 PM == hour 12 |
|
387 if hour != 12: |
|
388 hour += 12 |
|
389 elif group_key == 'M': |
|
390 minute = int(found_dict['M']) |
|
391 elif group_key == 'S': |
|
392 second = int(found_dict['S']) |
|
393 elif group_key == 'A': |
|
394 weekday = locale_time.f_weekday.index(found_dict['A'].lower()) |
|
395 elif group_key == 'a': |
|
396 weekday = locale_time.a_weekday.index(found_dict['a'].lower()) |
|
397 elif group_key == 'w': |
|
398 weekday = int(found_dict['w']) |
|
399 if weekday == 0: |
|
400 weekday = 6 |
|
401 else: |
|
402 weekday -= 1 |
|
403 elif group_key == 'j': |
|
404 julian = int(found_dict['j']) |
|
405 elif group_key in ('U', 'W'): |
|
406 week_of_year = int(found_dict[group_key]) |
|
407 if group_key == 'U': |
|
408 # U starts week on Sunday. |
|
409 week_of_year_start = 6 |
|
410 else: |
|
411 # W starts week on Monday. |
|
412 week_of_year_start = 0 |
|
413 elif group_key == 'Z': |
|
414 # Since -1 is default value only need to worry about setting tz if |
|
415 # it can be something other than -1. |
|
416 found_zone = found_dict['Z'].lower() |
|
417 for value, tz_values in enumerate(locale_time.timezone): |
|
418 if found_zone in tz_values: |
|
419 # Deal with bad locale setup where timezone names are the |
|
420 # same and yet time.daylight is true; too ambiguous to |
|
421 # be able to tell what timezone has daylight savings |
|
422 if (time.tzname[0] == time.tzname[1] and |
|
423 time.daylight and found_zone not in ("utc", "gmt")): |
|
424 break |
|
425 else: |
|
426 tz = value |
|
427 break |
|
428 # If we know the week of the year and what day of that week, we can figure |
|
429 # out the Julian day of the year. |
|
430 if julian == -1 and week_of_year != -1 and weekday != -1: |
|
431 week_starts_Mon = True if week_of_year_start == 0 else False |
|
432 julian = _calc_julian_from_U_or_W(year, week_of_year, weekday, |
|
433 week_starts_Mon) |
|
434 # Cannot pre-calculate datetime_date() since can change in Julian |
|
435 # calculation and thus could have different value for the day of the week |
|
436 # calculation. |
|
437 if julian == -1: |
|
438 # Need to add 1 to result since first day of the year is 1, not 0. |
|
439 julian = datetime_date(year, month, day).toordinal() - \ |
|
440 datetime_date(year, 1, 1).toordinal() + 1 |
|
441 else: # Assume that if they bothered to include Julian day it will |
|
442 # be accurate. |
|
443 datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal()) |
|
444 year = datetime_result.year |
|
445 month = datetime_result.month |
|
446 day = datetime_result.day |
|
447 if weekday == -1: |
|
448 weekday = datetime_date(year, month, day).weekday() |
|
449 return time.struct_time((year, month, day, |
|
450 hour, minute, second, |
|
451 weekday, julian, tz)) |