Python code coverage for Lib/_strptime.py

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