ยปCore Development>Code coverage>Lib/_strptime.py

Python code coverage for Lib/_strptime.py

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