Skip to content

C
cpython
Commit 474335ce authored by Brett Cannon's avatar Brett Cannon
Browse files
Options

Re-introduce caching of TimeRE and compiled regexes with added thread-safety. 

Also remove now unnecessary property attributes for thread safety
(no longer have lazy attributes) and code simplicity reasons.

Timezone storage has been reworked to be simpler and more flexible.  All values
in LocaleTime instances are lower-cased.  This is all done to simplify the
module.

The module now assumes nothing beyond the strptime function will be exposed for
general use beyond providing functionality for strptime.
parent 8ab27dfa
Hide whitespace changes
Inline Side-by-side
Showing with 190 additions and 335 deletions
Lib/_strptime.py
View file @ 474335ce
"""Strptime-related classes and functions. """Strptime-related classes and functions.
CLASSES: CLASSES:
LocaleTime -- Discovers and/or stores locale-specific time information LocaleTime -- Discovers and stores locale-specific time information
TimeRE -- Creates regexes for pattern matching a string of text containing TimeRE -- Creates regexes for pattern matching a string of text containing
time information as is returned by time.strftime() time information
FUNCTIONS: FUNCTIONS:
_getlang -- Figure out what language is being used for the locale _getlang -- Figure out what language is being used for the locale
strptime -- Calculates the time struct represented by the passed-in string strptime -- Calculates the time struct represented by the passed-in string
Requires Python 2.2.1 or higher (mainly because of the use of property()).
Can be used in Python 2.2 if the following line is added:
True = 1; False = 0
""" """
import time import time
import locale import locale
...@@ -19,6 +16,11 @@ import calendar ...@@ -19,6 +16,11 @@ import calendar
from re import compile as re_compile from re import compile as re_compile
from re import IGNORECASE from re import IGNORECASE
from datetime import date as datetime_date from datetime import date as datetime_date
from sets import ImmutableSet as sets_ImmutableSet
try:
from thread import allocate_lock as _thread_allocate_lock
except:
from dummy_thread import allocate_lock as _thread_allocate_lock
__author__ = "Brett Cannon" __author__ = "Brett Cannon"
__email__ = "brett@python.org" __email__ = "brett@python.org"
...@@ -32,12 +34,7 @@ def _getlang(): ...@@ -32,12 +34,7 @@ def _getlang():
class LocaleTime(object): class LocaleTime(object):
"""Stores and handles locale-specific information related to time. """Stores and handles locale-specific information related to time.
This is not thread-safe! Attributes are lazily calculated and no ATTRIBUTES:
precaution is taken to check to see if the locale information has changed
since the creation of the instance in use.
ATTRIBUTES (all read-only after instance creation! Instance variables that
store the values have mangled names):
f_weekday -- full weekday names (7-item list) f_weekday -- full weekday names (7-item list)
a_weekday -- abbreviated weekday names (7-item list) a_weekday -- abbreviated weekday names (7-item list)
f_month -- full weekday names (14-item list; dummy value in [0], which f_month -- full weekday names (14-item list; dummy value in [0], which
...@@ -49,63 +46,37 @@ class LocaleTime(object): ...@@ -49,63 +46,37 @@ class LocaleTime(object):
LC_date -- format string for date representation (string) LC_date -- format string for date representation (string)
LC_time -- format string for time representation (string) LC_time -- format string for time representation (string)
timezone -- daylight- and non-daylight-savings timezone representation timezone -- daylight- and non-daylight-savings timezone representation
(3-item list; code tacks on blank item at end for (2-item list of sets)
possible lack of timezone such as UTC) lang -- Language used by instance (2-item tuple)
lang -- Language used by instance (string)
""" """
def __init__(self, f_weekday=None, a_weekday=None, f_month=None, def __init__(self):
a_month=None, am_pm=None, LC_date_time=None, LC_time=None, """Set all attributes.
LC_date=None, timezone=None, lang=None):
"""Optionally set attributes with passed-in values.""" Order of methods called matters for dependency reasons.
if f_weekday is None:
self.__f_weekday = None The locale language is set at the offset and then checked again before
elif len(f_weekday) == 7: exiting. This is to make sure that the attributes were not set with a
self.__f_weekday = list(f_weekday) mix of information from more than one locale. This would most likely
else: happen when using threads where one thread calls a locale-dependent
raise TypeError("full weekday names must be a 7-item sequence") function while another thread changes the locale while the function in
if a_weekday is None: the other thread is still running. Proper coding would call for
self.__a_weekday = None locks to prevent changing the locale while locale-dependent code is
elif len(a_weekday) == 7: running. The check here is done in case someone does not think about
self.__a_weekday = list(a_weekday) doing this.
else:
raise TypeError( """
"abbreviated weekday names must be a 7-item sequence") self.lang = _getlang()
if f_month is None: self.__calc_weekday()
self.__f_month = None self.__calc_month()
elif len(f_month) == 12: self.__calc_am_pm()
self.__f_month = self.__pad(f_month, True) self.__calc_timezone()
else: self.__calc_date_time()
raise TypeError("full month names must be a 12-item sequence") if _getlang() != self.lang:
if a_month is None: raise ValueError("locale changed during initialization")
self.__a_month = None
elif len(a_month) == 12:
self.__a_month = self.__pad(a_month, True)
else:
raise TypeError(
"abbreviated month names must be a 12-item sequence")
if am_pm is None:
self.__am_pm = None
elif len(am_pm) == 2:
self.__am_pm = am_pm
else:
raise TypeError("AM/PM representation must be a 2-item sequence")
self.__LC_date_time = LC_date_time
self.__LC_time = LC_time
self.__LC_date = LC_date
self.__timezone = timezone
if timezone:
if len(timezone) != 2:
raise TypeError("timezone names must contain 2 items")
else:
self.__timezone = self.__pad(timezone, False)
if lang:
self.__lang = lang
else:
self.__lang = _getlang()
def __pad(self, seq, front): def __pad(self, seq, front):
# Add '' to seq to either front (is True), else the back. # Add '' to seq to either the front (is True), else the back.
seq = list(seq) seq = list(seq)
if front: if front:
seq.insert(0, '') seq.insert(0, '')
...@@ -113,112 +84,23 @@ class LocaleTime(object): ...@@ -113,112 +84,23 @@ class LocaleTime(object):
seq.append('') seq.append('')
return seq return seq
def __set_nothing(self, stuff):
# Raise TypeError when trying to set an attribute.
raise TypeError("attribute does not support assignment")
def __get_f_weekday(self):
# Fetch self.f_weekday.
if not self.__f_weekday:
self.__calc_weekday()
return self.__f_weekday
def __get_a_weekday(self):
# Fetch self.a_weekday.
if not self.__a_weekday:
self.__calc_weekday()
return self.__a_weekday
f_weekday = property(__get_f_weekday, __set_nothing,
doc="Full weekday names")
a_weekday = property(__get_a_weekday, __set_nothing,
doc="Abbreviated weekday names")
def __get_f_month(self):
# Fetch self.f_month.
if not self.__f_month:
self.__calc_month()
return self.__f_month
def __get_a_month(self):
# Fetch self.a_month.
if not self.__a_month:
self.__calc_month()
return self.__a_month
f_month = property(__get_f_month, __set_nothing,
doc="Full month names (dummy value at index 0)")
a_month = property(__get_a_month, __set_nothing,
doc="Abbreviated month names (dummy value at index 0)")
def __get_am_pm(self):
# Fetch self.am_pm.
if not self.__am_pm:
self.__calc_am_pm()
return self.__am_pm
am_pm = property(__get_am_pm, __set_nothing, doc="AM/PM representation")
def __get_timezone(self):
# Fetch self.timezone.
if not self.__timezone:
self.__calc_timezone()
return self.__timezone
timezone = property(__get_timezone, __set_nothing,
doc="Timezone representation (dummy value at index 2)")
def __get_LC_date_time(self):
# Fetch self.LC_date_time.
if not self.__LC_date_time:
self.__calc_date_time()
return self.__LC_date_time
def __get_LC_date(self):
# Fetch self.LC_date.
if not self.__LC_date:
self.__calc_date_time()
return self.__LC_date
def __get_LC_time(self):
# Fetch self.LC_time.
if not self.__LC_time:
self.__calc_date_time()
return self.__LC_time
LC_date_time = property(
__get_LC_date_time, __set_nothing,
doc=
"Format string for locale's date/time representation ('%c' format)")
LC_date = property(__get_LC_date, __set_nothing,
doc="Format string for locale's date representation ('%x' format)")
LC_time = property(__get_LC_time, __set_nothing,
doc="Format string for locale's time representation ('%X' format)")
lang = property(lambda self: self.__lang, __set_nothing,
doc="Language used for instance")
def __calc_weekday(self): def __calc_weekday(self):
# Set self.__a_weekday and self.__f_weekday using the calendar # Set self.a_weekday and self.f_weekday using the calendar
# module. # module.
a_weekday = [calendar.day_abbr[i] for i in range(7)] a_weekday = [calendar.day_abbr[i].lower() for i in range(7)]
f_weekday = [calendar.day_name[i] for i in range(7)] f_weekday = [calendar.day_name[i].lower() for i in range(7)]
if not self.__a_weekday: self.a_weekday = a_weekday
self.__a_weekday = a_weekday self.f_weekday = f_weekday
if not self.__f_weekday:
self.__f_weekday = f_weekday
def __calc_month(self): def __calc_month(self):
# Set self.__f_month and self.__a_month using the calendar module. # Set self.f_month and self.a_month using the calendar module.
a_month = [calendar.month_abbr[i] for i in range(13)] a_month = [calendar.month_abbr[i].lower() for i in range(13)]
f_month = [calendar.month_name[i] for i in range(13)] f_month = [calendar.month_name[i].lower() for i in range(13)]
if not self.__a_month: self.a_month = a_month
self.__a_month = a_month self.f_month = f_month
if not self.__f_month:
self.__f_month = f_month
def __calc_am_pm(self): def __calc_am_pm(self):
# Set self.__am_pm by using time.strftime(). # Set self.am_pm by using time.strftime().
# The magic date (1999,3,17,hour,44,55,2,76,0) is not really that # The magic date (1999,3,17,hour,44,55,2,76,0) is not really that
# magical; just happened to have used it everywhere else where a # magical; just happened to have used it everywhere else where a
...@@ -226,11 +108,11 @@ class LocaleTime(object): ...@@ -226,11 +108,11 @@ class LocaleTime(object):
am_pm = [] am_pm = []
for hour in (01,22): for hour in (01,22):
time_tuple = time.struct_time((1999,3,17,hour,44,55,2,76,0)) time_tuple = time.struct_time((1999,3,17,hour,44,55,2,76,0))
am_pm.append(time.strftime("%p", time_tuple)) am_pm.append(time.strftime("%p", time_tuple).lower())
self.__am_pm = am_pm self.am_pm = am_pm
def __calc_date_time(self): def __calc_date_time(self):
# Set self.__date_time, self.__date, & self.__time by using # Set self.date_time, self.date, & self.time by using
# time.strftime(). # time.strftime().
# Use (1999,3,17,22,44,55,2,76,0) for magic date because the amount of # Use (1999,3,17,22,44,55,2,76,0) for magic date because the amount of
...@@ -239,21 +121,22 @@ class LocaleTime(object): ...@@ -239,21 +121,22 @@ class LocaleTime(object):
# possible ambiguity for what something represents. # possible ambiguity for what something represents.
time_tuple = time.struct_time((1999,3,17,22,44,55,2,76,0)) time_tuple = time.struct_time((1999,3,17,22,44,55,2,76,0))
date_time = [None, None, None] date_time = [None, None, None]
date_time[0] = time.strftime("%c", time_tuple) date_time[0] = time.strftime("%c", time_tuple).lower()
date_time[1] = time.strftime("%x", time_tuple) date_time[1] = time.strftime("%x", time_tuple).lower()
date_time[2] = time.strftime("%X", time_tuple) date_time[2] = time.strftime("%X", time_tuple).lower()
for offset,directive in ((0,'%c'), (1,'%x'), (2,'%X')): replacement_pairs = [('%', '%%'), (self.f_weekday[2], '%A'),
current_format = date_time[offset]
for old, new in (
('%', '%%'), (self.f_weekday[2], '%A'),
(self.f_month[3], '%B'), (self.a_weekday[2], '%a'), (self.f_month[3], '%B'), (self.a_weekday[2], '%a'),
(self.a_month[3], '%b'), (self.am_pm[1], '%p'), (self.a_month[3], '%b'), (self.am_pm[1], '%p'),
(self.timezone[0], '%Z'), (self.timezone[1], '%Z'),
('1999', '%Y'), ('99', '%y'), ('22', '%H'), ('1999', '%Y'), ('99', '%y'), ('22', '%H'),
('44', '%M'), ('55', '%S'), ('76', '%j'), ('44', '%M'), ('55', '%S'), ('76', '%j'),
('17', '%d'), ('03', '%m'), ('3', '%m'), ('17', '%d'), ('03', '%m'), ('3', '%m'),
# '3' needed for when no leading zero. # '3' needed for when no leading zero.
('2', '%w'), ('10', '%I')): ('2', '%w'), ('10', '%I')]
replacement_pairs.extend([(tz, "%Z") for tz_values in self.timezone
for tz in tz_values])
for offset,directive in ((0,'%c'), (1,'%x'), (2,'%X')):
current_format = date_time[offset]
for old, new in replacement_pairs:
# Must deal with possible lack of locale info # Must deal with possible lack of locale info
# manifesting itself as the empty string (e.g., Swedish's # manifesting itself as the empty string (e.g., Swedish's
# lack of AM/PM info) or a platform returning a tuple of empty # lack of AM/PM info) or a platform returning a tuple of empty
...@@ -266,38 +149,40 @@ class LocaleTime(object): ...@@ -266,38 +149,40 @@ class LocaleTime(object):
else: else:
U_W = '%W' U_W = '%W'
date_time[offset] = current_format.replace('11', U_W) date_time[offset] = current_format.replace('11', U_W)
if not self.__LC_date_time: self.LC_date_time = date_time[0]
self.__LC_date_time = date_time[0] self.LC_date = date_time[1]
if not self.__LC_date: self.LC_time = date_time[2]
self.__LC_date = date_time[1]
if not self.__LC_time:
self.__LC_time = date_time[2]
def __calc_timezone(self): def __calc_timezone(self):
# Set self.__timezone by using time.tzname. # Set self.timezone by using time.tzname.
#
# Empty string used for matching when timezone is not used/needed.
try: try:
time.tzset() time.tzset()
except AttributeError: except AttributeError:
pass pass
time_zones = ["UTC", "GMT"] no_saving = sets_ImmutableSet(["utc", "gmt", time.tzname[0].lower()])
if time.daylight: if time.daylight:
time_zones.extend(time.tzname) has_saving = sets_ImmutableSet([time.tzname[1].lower()])
else: else:
time_zones.append(time.tzname[0]) has_saving = sets_ImmutableSet()
self.__timezone = self.__pad(time_zones, 0) self.timezone = (no_saving, has_saving)
class TimeRE(dict): class TimeRE(dict):
"""Handle conversion from format directives to regexes.""" """Handle conversion from format directives to regexes."""
def __init__(self, locale_time=None): def __init__(self, locale_time=None):
"""Init inst with non-locale regexes and store LocaleTime object.""" """Create keys/values.
#XXX: Does 'Y' need to worry about having less or more than 4 digits?
Order of execution is important for dependency reasons.
"""
if locale_time:
self.locale_time = locale_time
else:
self.locale_time = LocaleTime()
base = super(TimeRE, self) base = super(TimeRE, self)
base.__init__({ base.__init__({
# The " \d" option is to make %c from ANSI C work # The " \d" part of the regex is to make %c from ANSI C work
'd': r"(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])", 'd': r"(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])",
'H': r"(?P<H>2[0-3]|[0-1]\d|\d)", 'H': r"(?P<H>2[0-3]|[0-1]\d|\d)",
'I': r"(?P<I>1[0-2]|0[1-9]|[1-9])", 'I': r"(?P<I>1[0-2]|0[1-9]|[1-9])",
...@@ -309,70 +194,47 @@ class TimeRE(dict): ...@@ -309,70 +194,47 @@ class TimeRE(dict):
'w': r"(?P<w>[0-6])", 'w': r"(?P<w>[0-6])",
# W is set below by using 'U' # W is set below by using 'U'
'y': r"(?P<y>\d\d)", 'y': r"(?P<y>\d\d)",
'Y': r"(?P<Y>\d\d\d\d)"}) #XXX: Does 'Y' need to worry about having less or more than
# 4 digits?
'Y': r"(?P<Y>\d\d\d\d)",
'A': self.__seqToRE(self.locale_time.f_weekday, 'A'),
'a': self.__seqToRE(self.locale_time.a_weekday, 'a'),
'B': self.__seqToRE(self.locale_time.f_month[1:], 'B'),
'b': self.__seqToRE(self.locale_time.a_month[1:], 'b'),
'p': self.__seqToRE(self.locale_time.am_pm, 'p'),
'Z': self.__seqToRE([tz for tz_names in self.locale_time.timezone
for tz in tz_names],
'Z'),
'%': '%'})
base.__setitem__('W', base.__getitem__('U')) base.__setitem__('W', base.__getitem__('U'))
if locale_time: base.__setitem__('c', self.pattern(self.locale_time.LC_date_time))
self.locale_time = locale_time base.__setitem__('x', self.pattern(self.locale_time.LC_date))
else: base.__setitem__('X', self.pattern(self.locale_time.LC_time))
self.locale_time = LocaleTime()
def __getitem__(self, fetch):
"""Try to fetch regex; if it does not exist, construct it."""
try:
return super(TimeRE, self).__getitem__(fetch)
except KeyError:
constructors = {
'A': lambda: self.__seqToRE(self.locale_time.f_weekday, fetch),
'a': lambda: self.__seqToRE(self.locale_time.a_weekday, fetch),
'B': lambda: self.__seqToRE(self.locale_time.f_month[1:],
fetch),
'b': lambda: self.__seqToRE(self.locale_time.a_month[1:],
fetch),
'c': lambda: self.pattern(self.locale_time.LC_date_time),
'p': lambda: self.__seqToRE(self.locale_time.am_pm, fetch),
'x': lambda: self.pattern(self.locale_time.LC_date),
'X': lambda: self.pattern(self.locale_time.LC_time),
'Z': lambda: self.__seqToRE(self.locale_time.timezone, fetch),
'%': lambda: '%',
}
if fetch in constructors:
self[fetch] = constructors[fetch]()
return self[fetch]
else:
raise
def __seqToRE(self, to_convert, directive): def __seqToRE(self, to_convert, directive):
"""Convert a list to a regex string for matching a directive.""" """Convert a list to a regex string for matching a directive.
def sorter(a, b):
"""Sort based on length. Want possible matching values to be from longest to shortest. This
prevents the possibility of a match occuring for a value that also
Done in case for some strange reason that names in the locale only a substring of a larger value that should have matched (e.g., 'abc'
differ by a suffix and thus want the name with the suffix to match matching when 'abcdef' should have been the match).
first.
""" """
try:
a_length = len(a)
except TypeError:
a_length = 0
try:
b_length = len(b)
except TypeError:
b_length = 0
return cmp(b_length, a_length)
to_convert = to_convert[:] # Don't want to change value in-place.
for value in to_convert: for value in to_convert:
if value != '': if value != '':
break break
else: else:
return '' return ''
to_convert.sort(sorter) to_sort = [(len(item), item) for item in to_convert]
to_sort.sort()
to_sort.reverse()
to_convert = [item for length, item in to_sort]
regex = '|'.join(to_convert) regex = '|'.join(to_convert)
regex = '(?P<%s>%s' % (directive, regex) regex = '(?P<%s>%s' % (directive, regex)
return '%s)' % regex return '%s)' % regex
def pattern(self, format): def pattern(self, format):
"""Return re pattern for the format string. """Return regex pattern for the format string.
Need to make sure that any characters that might be interpreted as Need to make sure that any characters that might be interpreted as
regex syntax is escaped. regex syntax is escaped.
...@@ -397,12 +259,30 @@ class TimeRE(dict): ...@@ -397,12 +259,30 @@ class TimeRE(dict):
"""Return a compiled re object for the format string.""" """Return a compiled re object for the format string."""
return re_compile(self.pattern(format), IGNORECASE) return re_compile(self.pattern(format), IGNORECASE)
_cache_lock = _thread_allocate_lock()
# DO NOT modify _TimeRE_cache or _regex_cache without acquiring the cache lock
# first!
_TimeRE_cache = TimeRE()
_CACHE_MAX_SIZE = 5
_regex_cache = {}
def strptime(data_string, format="%a %b %d %H:%M:%S %Y"): def strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
"""Return a time struct based on the input data and the format string.""" """Return a time struct based on the input data and the format string."""
time_re = TimeRE() global _TimeRE_cache
locale_time = time_re.locale_time _cache_lock.acquire()
format_regex = time_re.compile(format) try:
time_re = _TimeRE_cache
locale_time = time_re.locale_time
if _getlang() != locale_time.lang:
_TimeRE_cache = TimeRE()
if len(_regex_cache) > _CACHE_MAX_SIZE:
_regex_cache.clear()
format_regex = _regex_cache.get(format)
if not format_regex:
format_regex = time_re.compile(format)
_regex_cache[format] = format_regex
finally:
_cache_lock.release()
found = format_regex.match(data_string) found = format_regex.match(data_string)
if not found: if not found:
raise ValueError("time data did not match format: data=%s fmt=%s" % raise ValueError("time data did not match format: data=%s fmt=%s" %
...@@ -432,9 +312,9 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"): ...@@ -432,9 +312,9 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
elif group_key == 'm': elif group_key == 'm':
month = int(found_dict['m']) month = int(found_dict['m'])
elif group_key == 'B': elif group_key == 'B':
month = _insensitiveindex(locale_time.f_month, found_dict['B']) month = locale_time.f_month.index(found_dict['B'].lower())
elif group_key == 'b': elif group_key == 'b':
month = _insensitiveindex(locale_time.a_month, found_dict['b']) month = locale_time.a_month.index(found_dict['b'].lower())
elif group_key == 'd': elif group_key == 'd':
day = int(found_dict['d']) day = int(found_dict['d'])
elif group_key == 'H': elif group_key == 'H':
...@@ -443,13 +323,13 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"): ...@@ -443,13 +323,13 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
hour = int(found_dict['I']) hour = int(found_dict['I'])
ampm = found_dict.get('p', '').lower() ampm = found_dict.get('p', '').lower()
# If there was no AM/PM indicator, we'll treat this like AM # If there was no AM/PM indicator, we'll treat this like AM
if ampm in ('', locale_time.am_pm[0].lower()): if ampm in ('', locale_time.am_pm[0]):
# We're in AM so the hour is correct unless we're # We're in AM so the hour is correct unless we're
# looking at 12 midnight. # looking at 12 midnight.
# 12 midnight == 12 AM == hour 0 # 12 midnight == 12 AM == hour 0
if hour == 12: if hour == 12:
hour = 0 hour = 0
elif ampm == locale_time.am_pm[1].lower(): elif ampm == locale_time.am_pm[1]:
# We're in PM so we need to add 12 to the hour unless # We're in PM so we need to add 12 to the hour unless
# we're looking at 12 noon. # we're looking at 12 noon.
# 12 noon == 12 PM == hour 12 # 12 noon == 12 PM == hour 12
...@@ -460,11 +340,9 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"): ...@@ -460,11 +340,9 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
elif group_key == 'S': elif group_key == 'S':
second = int(found_dict['S']) second = int(found_dict['S'])
elif group_key == 'A': elif group_key == 'A':
weekday = _insensitiveindex(locale_time.f_weekday, weekday = locale_time.f_weekday.index(found_dict['A'].lower())
found_dict['A'])
elif group_key == 'a': elif group_key == 'a':
weekday = _insensitiveindex(locale_time.a_weekday, weekday = locale_time.a_weekday.index(found_dict['a'].lower())
found_dict['a'])
elif group_key == 'w': elif group_key == 'w':
weekday = int(found_dict['w']) weekday = int(found_dict['w'])
if weekday == 0: if weekday == 0:
...@@ -481,14 +359,10 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"): ...@@ -481,14 +359,10 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
time.daylight: time.daylight:
pass #Deals with bad locale setup where timezone info is pass #Deals with bad locale setup where timezone info is
# the same; first found on FreeBSD 4.4. # the same; first found on FreeBSD 4.4.
elif found_zone in ("utc", "gmt"): else:
tz = 0 for value, tz_values in enumerate(locale_time.timezone):
elif locale_time.timezone[2].lower() == found_zone: if found_zone in tz_values:
tz = 0 tz = value
elif time.daylight and \
locale_time.timezone[3].lower() == found_zone:
tz = 1
# Cannot pre-calculate datetime_date() since can change in Julian # Cannot pre-calculate datetime_date() since can change in Julian
#calculation and thus could have different value for the day of the week #calculation and thus could have different value for the day of the week
#calculation #calculation
...@@ -507,16 +381,3 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"): ...@@ -507,16 +381,3 @@ def strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
return time.struct_time((year, month, day, return time.struct_time((year, month, day,
hour, minute, second, hour, minute, second,
weekday, julian, tz)) weekday, julian, tz))
def _insensitiveindex(lst, findme):
# Perform a case-insensitive index search.
#XXX <bc>: If LocaleTime is not exposed, then consider removing this and
# just lowercase when LocaleTime sets its vars and lowercasing
# search values.
findme = findme.lower()
for key,item in enumerate(lst):
if item.lower() == findme:
return key
else:
raise ValueError("value not in list")
Lib/test/test_strptime.py
View file @ 474335ce
...@@ -4,6 +4,7 @@ import unittest ...@@ -4,6 +4,7 @@ import unittest
import time import time
import locale import locale
import re import re
import sets
from test import test_support from test import test_support
import _strptime import _strptime
...@@ -14,7 +15,12 @@ class getlang_Tests(unittest.TestCase): ...@@ -14,7 +15,12 @@ class getlang_Tests(unittest.TestCase):
self.failUnlessEqual(_strptime._getlang(), locale.getlocale(locale.LC_TIME)) self.failUnlessEqual(_strptime._getlang(), locale.getlocale(locale.LC_TIME))
class LocaleTime_Tests(unittest.TestCase): class LocaleTime_Tests(unittest.TestCase):
"""Tests for _strptime.LocaleTime.""" """Tests for _strptime.LocaleTime.
All values are lower-cased when stored in LocaleTime, so make sure to
compare values after running ``lower`` on them.
"""
def setUp(self): def setUp(self):
"""Create time tuple based on current time.""" """Create time tuple based on current time."""
...@@ -27,7 +33,7 @@ class LocaleTime_Tests(unittest.TestCase): ...@@ -27,7 +33,7 @@ class LocaleTime_Tests(unittest.TestCase):
tuple_position of time_tuple. Uses error_msg as error message. tuple_position of time_tuple. Uses error_msg as error message.
""" """
strftime_output = time.strftime(directive, self.time_tuple) strftime_output = time.strftime(directive, self.time_tuple).lower()
comparison = testing[self.time_tuple[tuple_position]] comparison = testing[self.time_tuple[tuple_position]]
self.failUnless(strftime_output in testing, "%s: not found in tuple" % self.failUnless(strftime_output in testing, "%s: not found in tuple" %
error_msg) error_msg)
...@@ -53,7 +59,7 @@ class LocaleTime_Tests(unittest.TestCase): ...@@ -53,7 +59,7 @@ class LocaleTime_Tests(unittest.TestCase):
def test_am_pm(self): def test_am_pm(self):
# Make sure AM/PM representation done properly # Make sure AM/PM representation done properly
strftime_output = time.strftime("%p", self.time_tuple) strftime_output = time.strftime("%p", self.time_tuple).lower()
self.failUnless(strftime_output in self.LT_ins.am_pm, self.failUnless(strftime_output in self.LT_ins.am_pm,
"AM/PM representation not in tuple") "AM/PM representation not in tuple")
if self.time_tuple[3] < 12: position = 0 if self.time_tuple[3] < 12: position = 0
...@@ -63,9 +69,10 @@ class LocaleTime_Tests(unittest.TestCase): ...@@ -63,9 +69,10 @@ class LocaleTime_Tests(unittest.TestCase):
def test_timezone(self): def test_timezone(self):
# Make sure timezone is correct # Make sure timezone is correct
timezone = time.strftime("%Z", self.time_tuple) timezone = time.strftime("%Z", self.time_tuple).lower()
if timezone: if timezone:
self.failUnless(timezone in self.LT_ins.timezone, self.failUnless(timezone in self.LT_ins.timezone[0] or \
timezone in self.LT_ins.timezone[1],
"timezone %s not found in %s" % "timezone %s not found in %s" %
(timezone, self.LT_ins.timezone)) (timezone, self.LT_ins.timezone))
...@@ -89,7 +96,8 @@ class LocaleTime_Tests(unittest.TestCase): ...@@ -89,7 +96,8 @@ class LocaleTime_Tests(unittest.TestCase):
self.failUnless(strftime_output == time.strftime(self.LT_ins.LC_time, self.failUnless(strftime_output == time.strftime(self.LT_ins.LC_time,
magic_date), magic_date),
"LC_time incorrect") "LC_time incorrect")
LT = _strptime.LocaleTime(am_pm=('','')) LT = _strptime.LocaleTime()
LT.am_pm = ('', '')
self.failUnless(LT.LC_time, "LocaleTime's LC directives cannot handle " self.failUnless(LT.LC_time, "LocaleTime's LC directives cannot handle "
"empty strings") "empty strings")
...@@ -98,44 +106,6 @@ class LocaleTime_Tests(unittest.TestCase): ...@@ -98,44 +106,6 @@ class LocaleTime_Tests(unittest.TestCase):
# Assuming locale has not changed between now and when self.LT_ins was created # Assuming locale has not changed between now and when self.LT_ins was created
self.failUnlessEqual(self.LT_ins.lang, _strptime._getlang()) self.failUnlessEqual(self.LT_ins.lang, _strptime._getlang())
def test_by_hand_input(self):
# Test passed-in initialization value checks
self.failUnless(_strptime.LocaleTime(f_weekday=range(7)),
"Argument size check for f_weekday failed")
self.assertRaises(TypeError, _strptime.LocaleTime, f_weekday=range(8))
self.assertRaises(TypeError, _strptime.LocaleTime, f_weekday=range(6))
self.failUnless(_strptime.LocaleTime(a_weekday=range(7)),
"Argument size check for a_weekday failed")
self.assertRaises(TypeError, _strptime.LocaleTime, a_weekday=range(8))
self.assertRaises(TypeError, _strptime.LocaleTime, a_weekday=range(6))
self.failUnless(_strptime.LocaleTime(f_month=range(12)),
"Argument size check for f_month failed")
self.assertRaises(TypeError, _strptime.LocaleTime, f_month=range(11))
self.assertRaises(TypeError, _strptime.LocaleTime, f_month=range(13))
self.failUnless(len(_strptime.LocaleTime(f_month=range(12)).f_month) == 13,
"dummy value for f_month not added")
self.failUnless(_strptime.LocaleTime(a_month=range(12)),
"Argument size check for a_month failed")
self.assertRaises(TypeError, _strptime.LocaleTime, a_month=range(11))
self.assertRaises(TypeError, _strptime.LocaleTime, a_month=range(13))
self.failUnless(len(_strptime.LocaleTime(a_month=range(12)).a_month) == 13,
"dummy value for a_month not added")
self.failUnless(_strptime.LocaleTime(am_pm=range(2)),
"Argument size check for am_pm failed")
self.assertRaises(TypeError, _strptime.LocaleTime, am_pm=range(1))
self.assertRaises(TypeError, _strptime.LocaleTime, am_pm=range(3))
self.failUnless(_strptime.LocaleTime(timezone=range(2)),
"Argument size check for timezone failed")
self.assertRaises(TypeError, _strptime.LocaleTime, timezone=range(1))
self.assertRaises(TypeError, _strptime.LocaleTime, timezone=range(3))
def test_unknowntimezone(self):
# Handle timezone set to ('','') properly.
# Fixes bug #661354
locale_time = _strptime.LocaleTime(timezone=('',''))
self.failUnless("%Z" not in locale_time.LC_date,
"when timezone == ('',''), string.replace('','%Z') is "
"occuring")
class TimeRETests(unittest.TestCase): class TimeRETests(unittest.TestCase):
"""Tests for TimeRE.""" """Tests for TimeRE."""
...@@ -145,21 +115,6 @@ class TimeRETests(unittest.TestCase): ...@@ -145,21 +115,6 @@ class TimeRETests(unittest.TestCase):
self.time_re = _strptime.TimeRE() self.time_re = _strptime.TimeRE()
self.locale_time = _strptime.LocaleTime() self.locale_time = _strptime.LocaleTime()
def test_getitem(self):
# Make sure that __getitem__ works properly
self.failUnless(self.time_re['m'],
"Fetching 'm' directive (built-in) failed")
self.failUnless(self.time_re['b'],
"Fetching 'b' directive (built w/ __tupleToRE) failed")
for name in self.locale_time.a_month:
self.failUnless(self.time_re['b'].find(name) != -1,
"Not all abbreviated month names in regex")
self.failUnless(self.time_re['c'],
"Fetching 'c' directive (built w/ format) failed")
self.failUnless(self.time_re['c'].find('%') == -1,
"Conversion of 'c' directive failed; '%' found")
self.assertRaises(KeyError, self.time_re.__getitem__, '1')
def test_pattern(self): def test_pattern(self):
# Test TimeRE.pattern # Test TimeRE.pattern
pattern_string = self.time_re.pattern(r"%a %A %d") pattern_string = self.time_re.pattern(r"%a %A %d")
...@@ -210,7 +165,8 @@ class TimeRETests(unittest.TestCase): ...@@ -210,7 +165,8 @@ class TimeRETests(unittest.TestCase):
def test_blankpattern(self): def test_blankpattern(self):
# Make sure when tuple or something has no values no regex is generated. # Make sure when tuple or something has no values no regex is generated.
# Fixes bug #661354 # Fixes bug #661354
test_locale = _strptime.LocaleTime(timezone=('','')) test_locale = _strptime.LocaleTime()
test_locale.timezone = (sets.ImmutableSet(), sets.ImmutableSet())
self.failUnless(_strptime.TimeRE(test_locale).pattern("%Z") == '', self.failUnless(_strptime.TimeRE(test_locale).pattern("%Z") == '',
"with timezone == ('',''), TimeRE().pattern('%Z') != ''") "with timezone == ('',''), TimeRE().pattern('%Z') != ''")
...@@ -413,6 +369,43 @@ class CalculationTests(unittest.TestCase): ...@@ -413,6 +369,43 @@ class CalculationTests(unittest.TestCase):
self.failUnless(result.tm_wday == self.time_tuple.tm_wday, self.failUnless(result.tm_wday == self.time_tuple.tm_wday,
"Calculation of day of the week failed;" "Calculation of day of the week failed;"
"%s != %s" % (result.tm_wday, self.time_tuple.tm_wday)) "%s != %s" % (result.tm_wday, self.time_tuple.tm_wday))
class CacheTests(unittest.TestCase):
"""Test that caching works properly."""
def test_time_re_recreation(self):
# Make sure cache is recreated when current locale does not match what
# cached object was created with.
_strptime.strptime("10", "%d")
_strptime._TimeRE_cache.locale_time.lang = "Ni"
original_time_re = id(_strptime._TimeRE_cache)
_strptime.strptime("10", "%d")
self.failIfEqual(original_time_re, id(_strptime._TimeRE_cache))
def test_regex_cleanup(self):
# Make sure cached regexes are discarded when cache becomes "full".
try:
del _strptime._regex_cache['%d']
except KeyError:
pass
bogus_key = 0
while len(_strptime._regex_cache) <= _strptime._CACHE_MAX_SIZE:
_strptime._regex_cache[bogus_key] = None
bogus_key += 1
_strptime.strptime("10", "%d")
self.failUnlessEqual(len(_strptime._regex_cache), 1)
def test_new_localetime(self):
# A new LocaleTime instance should be created when a new TimeRE object
# is created.
locale_time_id = id(_strptime._TimeRE_cache.locale_time)
_strptime._TimeRE_cache.locale_time.lang = "Ni"
_strptime.strptime("10", "%d")
self.failIfEqual(locale_time_id,
id(_strptime._TimeRE_cache.locale_time))
def test_main(): def test_main():
test_support.run_unittest( test_support.run_unittest(
getlang_Tests, getlang_Tests,
...@@ -422,6 +415,7 @@ def test_main(): ...@@ -422,6 +415,7 @@ def test_main():
Strptime12AMPMTests, Strptime12AMPMTests,
JulianTests, JulianTests,
CalculationTests, CalculationTests,
CacheTests
) )
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7