_strptime.py revision a783d06f8cb4077dd34567fde418bf6c23073912
1"""Strptime-related classes and functions. 2 3CLASSES: 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 8FUNCTIONS: 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""" 13import time 14import locale 15import calendar 16from re import compile as re_compile 17from re import IGNORECASE 18from re import escape as re_escape 19from datetime import date as datetime_date 20try: 21 from thread import allocate_lock as _thread_allocate_lock 22except: 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 30def _getlang(): 31 # Figure out what the current language is set to. 32 return locale.getlocale(locale.LC_TIME) 33 34class 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 179class 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 276def strptime(data_string, format="%a %b %d %H:%M:%S %Y"): 277 """Return a time struct based on the input string and the format string.""" 278 global _TimeRE_cache, _regex_cache 279 _cache_lock.acquire() 280 try: 281 time_re = _TimeRE_cache 282 locale_time = time_re.locale_time 283 if _getlang() != locale_time.lang: 284 _TimeRE_cache = TimeRE() 285 _regex_cache = {} 286 if len(_regex_cache) > _CACHE_MAX_SIZE: 287 _regex_cache.clear() 288 format_regex = _regex_cache.get(format) 289 if not format_regex: 290 format_regex = time_re.compile(format) 291 _regex_cache[format] = format_regex 292 finally: 293 _cache_lock.release() 294 found = format_regex.match(data_string) 295 if not found: 296 raise ValueError("time data did not match format: data=%s fmt=%s" % 297 (data_string, format)) 298 if len(data_string) != found.end(): 299 raise ValueError("unconverted data remains: %s" % 300 data_string[found.end():]) 301 year = 1900 302 month = day = 1 303 hour = minute = second = 0 304 tz = -1 305 # Default to -1 to signify that values not known; not critical to have, 306 # though 307 week_of_year = -1 308 week_of_year_start = -1 309 # weekday and julian defaulted to -1 so as to signal need to calculate 310 # values 311 weekday = julian = -1 312 found_dict = found.groupdict() 313 for group_key in found_dict.iterkeys(): 314 # Directives not explicitly handled below: 315 # c, x, X 316 # handled by making out of other directives 317 # U, W 318 # worthless without day of the week 319 if group_key == 'y': 320 year = int(found_dict['y']) 321 # Open Group specification for strptime() states that a %y 322 #value in the range of [00, 68] is in the century 2000, while 323 #[69,99] is in the century 1900 324 if year <= 68: 325 year += 2000 326 else: 327 year += 1900 328 elif group_key == 'Y': 329 year = int(found_dict['Y']) 330 elif group_key == 'm': 331 month = int(found_dict['m']) 332 elif group_key == 'B': 333 month = locale_time.f_month.index(found_dict['B'].lower()) 334 elif group_key == 'b': 335 month = locale_time.a_month.index(found_dict['b'].lower()) 336 elif group_key == 'd': 337 day = int(found_dict['d']) 338 elif group_key == 'H': 339 hour = int(found_dict['H']) 340 elif group_key == 'I': 341 hour = int(found_dict['I']) 342 ampm = found_dict.get('p', '').lower() 343 # If there was no AM/PM indicator, we'll treat this like AM 344 if ampm in ('', locale_time.am_pm[0]): 345 # We're in AM so the hour is correct unless we're 346 # looking at 12 midnight. 347 # 12 midnight == 12 AM == hour 0 348 if hour == 12: 349 hour = 0 350 elif ampm == locale_time.am_pm[1]: 351 # We're in PM so we need to add 12 to the hour unless 352 # we're looking at 12 noon. 353 # 12 noon == 12 PM == hour 12 354 if hour != 12: 355 hour += 12 356 elif group_key == 'M': 357 minute = int(found_dict['M']) 358 elif group_key == 'S': 359 second = int(found_dict['S']) 360 elif group_key == 'A': 361 weekday = locale_time.f_weekday.index(found_dict['A'].lower()) 362 elif group_key == 'a': 363 weekday = locale_time.a_weekday.index(found_dict['a'].lower()) 364 elif group_key == 'w': 365 weekday = int(found_dict['w']) 366 if weekday == 0: 367 weekday = 6 368 else: 369 weekday -= 1 370 elif group_key == 'j': 371 julian = int(found_dict['j']) 372 elif group_key in ('U', 'W'): 373 week_of_year = int(found_dict[group_key]) 374 if group_key == 'U': 375 # U starts week on Sunday 376 week_of_year_start = 6 377 else: 378 # W starts week on Monday 379 week_of_year_start = 0 380 elif group_key == 'Z': 381 # Since -1 is default value only need to worry about setting tz if 382 # it can be something other than -1. 383 found_zone = found_dict['Z'].lower() 384 for value, tz_values in enumerate(locale_time.timezone): 385 if found_zone in tz_values: 386 # Deal with bad locale setup where timezone names are the 387 # same and yet time.daylight is true; too ambiguous to 388 # be able to tell what timezone has daylight savings 389 if (time.tzname[0] == time.tzname[1] and 390 time.daylight and found_zone not in ("utc", "gmt")): 391 break 392 else: 393 tz = value 394 break 395 # If we know the week of the year and what day of that week, we can figure 396 # out the Julian day of the year 397 # Calculations below assume 0 is a Monday 398 if julian == -1 and week_of_year != -1 and weekday != -1: 399 # Calculate how many days in week 0 400 first_weekday = datetime_date(year, 1, 1).weekday() 401 preceeding_days = 7 - first_weekday 402 if preceeding_days == 7: 403 preceeding_days = 0 404 # Adjust for U directive so that calculations are not dependent on 405 # directive used to figure out week of year 406 if weekday == 6 and week_of_year_start == 6: 407 week_of_year -= 1 408 # If a year starts and ends on a Monday but a week is specified to 409 # start on a Sunday we need to up the week to counter-balance the fact 410 # that with %W that first Monday starts week 1 while with %U that is 411 # week 0 and thus shifts everything by a week 412 if weekday == 0 and first_weekday == 0 and week_of_year_start == 6: 413 week_of_year += 1 414 # If in week 0, then just figure out how many days from Jan 1 to day of 415 # week specified, else calculate by multiplying week of year by 7, 416 # adding in days in week 0, and the number of days from Monday to the 417 # day of the week 418 if week_of_year == 0: 419 julian = 1 + weekday - first_weekday 420 else: 421 days_to_week = preceeding_days + (7 * (week_of_year - 1)) 422 julian = 1 + days_to_week + weekday 423 # Cannot pre-calculate datetime_date() since can change in Julian 424 #calculation and thus could have different value for the day of the week 425 #calculation 426 if julian == -1: 427 # Need to add 1 to result since first day of the year is 1, not 0. 428 julian = datetime_date(year, month, day).toordinal() - \ 429 datetime_date(year, 1, 1).toordinal() + 1 430 else: # Assume that if they bothered to include Julian day it will 431 #be accurate 432 datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal()) 433 year = datetime_result.year 434 month = datetime_result.month 435 day = datetime_result.day 436 if weekday == -1: 437 weekday = datetime_date(year, month, day).weekday() 438 return time.struct_time((year, month, day, 439 hour, minute, second, 440 weekday, julian, tz)) 441