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