[Python-checkins] python/dist/src/Lib _strptime.py,1.23,1.24

bcannon at users.sourceforge.net bcannon at users.sourceforge.net
Mon Aug 4 22:02:51 EDT 2003


Update of /cvsroot/python/python/dist/src/Lib
In directory sc8-pr-cvs1:/tmp/cvs-serv18944/Lib

Modified Files:
	_strptime.py 
Log Message:
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.


Index: _strptime.py
===================================================================
RCS file: /cvsroot/python/python/dist/src/Lib/_strptime.py,v
retrieving revision 1.23
retrieving revision 1.24
diff -C2 -d -r1.23 -r1.24
*** _strptime.py	24 Jul 2003 20:02:28 -0000	1.23
--- _strptime.py	5 Aug 2003 04:02:49 -0000	1.24
***************
*** 2,8 ****
  
  CLASSES:
!     LocaleTime -- Discovers and/or stores locale-specific time information
      TimeRE -- Creates regexes for pattern matching a string of text containing
!                 time information as is returned by time.strftime()
  
  FUNCTIONS:
--- 2,8 ----
  
  CLASSES:
!     LocaleTime -- Discovers and stores locale-specific time information
      TimeRE -- Creates regexes for pattern matching a string of text containing
!                 time information
  
  FUNCTIONS:
***************
*** 10,16 ****
      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
--- 10,13 ----
***************
*** 20,23 ****
--- 17,25 ----
  from re import IGNORECASE
  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"
***************
*** 33,42 ****
      """Stores and handles locale-specific information related to time.
  
!     This is not thread-safe!  Attributes are lazily calculated and no
!     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)
          a_weekday -- abbreviated weekday names (7-item list)
--- 35,39 ----
      """Stores and handles locale-specific information related to time.
  
!     ATTRIBUTES:
          f_weekday -- full weekday names (7-item list)
          a_weekday -- abbreviated weekday names (7-item list)
***************
*** 50,110 ****
          LC_time -- format string for time representation (string)
          timezone -- daylight- and non-daylight-savings timezone representation
!                     (3-item list; code tacks on blank item at end for
!                     possible lack of timezone such as UTC)
!         lang -- Language used by instance (string)
      """
  
!     def __init__(self, f_weekday=None, a_weekday=None, f_month=None,
!                  a_month=None, am_pm=None, LC_date_time=None, LC_time=None,
!                  LC_date=None, timezone=None, lang=None):
!         """Optionally set attributes with passed-in values."""
!         if f_weekday is None:
!             self.__f_weekday = None
!         elif len(f_weekday) == 7:
!             self.__f_weekday = list(f_weekday)
!         else:
!             raise TypeError("full weekday names must be a 7-item sequence")
!         if a_weekday is None:
!             self.__a_weekday = None
!         elif len(a_weekday) == 7:
!             self.__a_weekday = list(a_weekday)
!         else:
!             raise TypeError(
!                 "abbreviated weekday names must be a 7-item  sequence")
!         if f_month is None:
!             self.__f_month = None
!         elif len(f_month) == 12:
!             self.__f_month = self.__pad(f_month, True)
!         else:
!             raise TypeError("full month names must be a 12-item sequence")
!         if a_month is None:
!             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):
!         # Add '' to seq to either front (is True), else the back.
          seq = list(seq)
          if front:
--- 47,81 ----
          LC_time -- format string for time representation (string)
          timezone -- daylight- and non-daylight-savings timezone representation
!                     (2-item list of sets)
!         lang -- Language used by instance (2-item tuple)
      """
  
!     def __init__(self):
!         """Set all attributes.
!         
!         Order of methods called matters for dependency reasons.
! 
!         The locale language is set at the offset and then checked again before
!         exiting.  This is to make sure that the attributes were not set with a
!         mix of information from more than one locale.  This would most likely
!         happen when using threads where one thread calls a locale-dependent
!         function while another thread changes the locale while the function in
!         the other thread is still running.  Proper coding would call for
!         locks to prevent changing the locale while locale-dependent code is
!         running.  The check here is done in case someone does not think about
!         doing this.
!         
!         """
!         self.lang = _getlang()
!         self.__calc_weekday()
!         self.__calc_month()
!         self.__calc_am_pm()
!         self.__calc_timezone()
!         self.__calc_date_time()
!         if _getlang() != self.lang:
!             raise ValueError("locale changed during initialization")
  
      def __pad(self, seq, front):
!         # Add '' to seq to either the front (is True), else the back.
          seq = list(seq)
          if front:
***************
*** 114,223 ****
          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):
!         # Set self.__a_weekday and self.__f_weekday using the calendar
          # module.
!         a_weekday = [calendar.day_abbr[i] for i in range(7)]
!         f_weekday = [calendar.day_name[i] for i in range(7)]
!         if not self.__a_weekday:
!             self.__a_weekday = a_weekday
!         if not self.__f_weekday:
!             self.__f_weekday = f_weekday
  
      def __calc_month(self):
!         # Set self.__f_month and self.__a_month using the calendar module.
!         a_month = [calendar.month_abbr[i] for i in range(13)]
!         f_month = [calendar.month_name[i] for i in range(13)]
!         if not self.__a_month:
!             self.__a_month = a_month
!         if not self.__f_month:
!             self.__f_month = f_month
  
      def __calc_am_pm(self):
!         # Set self.__am_pm by using time.strftime().
  
          # The magic date (1999,3,17,hour,44,55,2,76,0) is not really that
--- 85,105 ----
          return seq
  
      def __calc_weekday(self):
!         # Set self.a_weekday and self.f_weekday using the calendar
          # module.
!         a_weekday = [calendar.day_abbr[i].lower() for i in range(7)]
!         f_weekday = [calendar.day_name[i].lower() for i in range(7)]
!         self.a_weekday = a_weekday
!         self.f_weekday = f_weekday
  
      def __calc_month(self):
!         # Set self.f_month and self.a_month using the calendar module.
!         a_month = [calendar.month_abbr[i].lower() for i in range(13)]
!         f_month = [calendar.month_name[i].lower() for i in range(13)]
!         self.a_month = a_month
!         self.f_month = f_month
  
      def __calc_am_pm(self):
!         # Set self.am_pm by using time.strftime().
  
          # The magic date (1999,3,17,hour,44,55,2,76,0) is not really that
***************
*** 227,235 ****
          for hour in (01,22):
              time_tuple = time.struct_time((1999,3,17,hour,44,55,2,76,0))
!             am_pm.append(time.strftime("%p", time_tuple))
!         self.__am_pm = am_pm
  
      def __calc_date_time(self):
!         # Set self.__date_time, self.__date, & self.__time by using
          # time.strftime().
  
--- 109,117 ----
          for hour in (01,22):
              time_tuple = time.struct_time((1999,3,17,hour,44,55,2,76,0))
!             am_pm.append(time.strftime("%p", time_tuple).lower())
!         self.am_pm = am_pm
  
      def __calc_date_time(self):
!         # Set self.date_time, self.date, & self.time by using
          # time.strftime().
  
***************
*** 240,258 ****
          time_tuple = time.struct_time((1999,3,17,22,44,55,2,76,0))
          date_time = [None, None, None]
!         date_time[0] = time.strftime("%c", time_tuple)
!         date_time[1] = time.strftime("%x", time_tuple)
!         date_time[2] = time.strftime("%X", time_tuple)
!         for offset,directive in ((0,'%c'), (1,'%x'), (2,'%X')):
!             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.a_month[3], '%b'), (self.am_pm[1], '%p'),
-                     (self.timezone[0], '%Z'), (self.timezone[1], '%Z'),
                      ('1999', '%Y'), ('99', '%y'), ('22', '%H'),
                      ('44', '%M'), ('55', '%S'), ('76', '%j'),
                      ('17', '%d'), ('03', '%m'), ('3', '%m'),
                      # '3' needed for when no leading zero.
!                     ('2', '%w'), ('10', '%I')):
                  # Must deal with possible lack of locale info
                  # manifesting itself as the empty string (e.g., Swedish's
--- 122,141 ----
          time_tuple = time.struct_time((1999,3,17,22,44,55,2,76,0))
          date_time = [None, None, None]
!         date_time[0] = time.strftime("%c", time_tuple).lower()
!         date_time[1] = time.strftime("%x", time_tuple).lower()
!         date_time[2] = time.strftime("%X", time_tuple).lower()
!         replacement_pairs = [('%', '%%'), (self.f_weekday[2], '%A'),
                      (self.f_month[3], '%B'), (self.a_weekday[2], '%a'),
                      (self.a_month[3], '%b'), (self.am_pm[1], '%p'),
                      ('1999', '%Y'), ('99', '%y'), ('22', '%H'),
                      ('44', '%M'), ('55', '%S'), ('76', '%j'),
                      ('17', '%d'), ('03', '%m'), ('3', '%m'),
                      # '3' needed for when no leading zero.
!                     ('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
                  # manifesting itself as the empty string (e.g., Swedish's
***************
*** 267,291 ****
                  U_W = '%W'
              date_time[offset] = current_format.replace('11', U_W)
!         if not self.__LC_date_time:
!             self.__LC_date_time = date_time[0]
!         if not self.__LC_date:
!             self.__LC_date = date_time[1]
!         if not self.__LC_time:
!             self.__LC_time = date_time[2]
  
      def __calc_timezone(self):
!         # Set self.__timezone by using time.tzname.
!         #
!         # Empty string used for matching when timezone is not used/needed.
          try:
              time.tzset()
          except AttributeError:
              pass
!         time_zones = ["UTC", "GMT"]
          if time.daylight:
!             time_zones.extend(time.tzname)
          else:
!             time_zones.append(time.tzname[0])
!         self.__timezone = self.__pad(time_zones, 0)
  
  
--- 150,169 ----
                  U_W = '%W'
              date_time[offset] = current_format.replace('11', U_W)
!         self.LC_date_time = date_time[0]
!         self.LC_date = date_time[1]
!         self.LC_time = date_time[2] 
  
      def __calc_timezone(self):
!         # Set self.timezone by using time.tzname.
          try:
              time.tzset()
          except AttributeError:
              pass
!         no_saving = sets_ImmutableSet(["utc", "gmt", time.tzname[0].lower()])
          if time.daylight:
!             has_saving = sets_ImmutableSet([time.tzname[1].lower()])
          else:
!             has_saving = sets_ImmutableSet()
!         self.timezone = (no_saving, has_saving)
  
  
***************
*** 294,302 ****
  
      def __init__(self, locale_time=None):
!         """Init inst with non-locale regexes and store LocaleTime object."""
!         #XXX: Does 'Y' need to worry about having less or more than 4 digits?
          base = super(TimeRE, self)
          base.__init__({
!             # The " \d" option 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])",
              'H': r"(?P<H>2[0-3]|[0-1]\d|\d)",
--- 172,187 ----
  
      def __init__(self, locale_time=None):
!         """Create keys/values.
!         
!         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.__init__({
!             # 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])",
              'H': r"(?P<H>2[0-3]|[0-1]\d|\d)",
***************
*** 310,365 ****
              # W is set below by using 'U'
              'y': r"(?P<y>\d\d)",
!             'Y': r"(?P<Y>\d\d\d\d)"})
          base.__setitem__('W', base.__getitem__('U'))
!         if locale_time:
!             self.locale_time = locale_time
!         else:
!             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):
!         """Convert a list to a regex string for matching a directive."""
!         def sorter(a, b):
!             """Sort based on length.
! 
!             Done in case for some strange reason that names in the locale only
!             differ by a suffix and thus want the name with the suffix to 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:
              if value != '':
--- 195,224 ----
              # W is set below by using 'U'
              'y': r"(?P<y>\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__('c', self.pattern(self.locale_time.LC_date_time))
!         base.__setitem__('x', self.pattern(self.locale_time.LC_date))
!         base.__setitem__('X', self.pattern(self.locale_time.LC_time))
  
      def __seqToRE(self, to_convert, directive):
!         """Convert a list to a regex string for matching a directive.
!         
!         Want possible matching values to be from longest to shortest.  This
!         prevents the possibility of a match occuring for a value that also
!         a substring of a larger value that should have matched (e.g., 'abc'
!         matching when 'abcdef' should have been the match).
!         
!         """
          for value in to_convert:
              if value != '':
***************
*** 367,371 ****
          else:
              return ''
!         to_convert.sort(sorter)
          regex = '|'.join(to_convert)
          regex = '(?P<%s>%s' % (directive, regex)
--- 226,233 ----
          else:
              return ''
!         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 = '(?P<%s>%s' % (directive, regex)
***************
*** 373,377 ****
  
      def pattern(self, format):
!         """Return re pattern for the format string.
  
          Need to make sure that any characters that might be interpreted as
--- 235,239 ----
  
      def pattern(self, format):
!         """Return regex pattern for the format string.
  
          Need to make sure that any characters that might be interpreted as
***************
*** 398,407 ****
          return re_compile(self.pattern(format), IGNORECASE)
  
  
  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."""
!     time_re = TimeRE()
!     locale_time = time_re.locale_time
!     format_regex = time_re.compile(format)
      found = format_regex.match(data_string)
      if not found:
--- 260,287 ----
          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"):
      """Return a time struct based on the input data and the format string."""
!     global _TimeRE_cache
!     _cache_lock.acquire()
!     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)
      if not found:
***************
*** 433,439 ****
              month = int(found_dict['m'])
          elif group_key == 'B':
!             month = _insensitiveindex(locale_time.f_month, found_dict['B'])
          elif group_key == 'b':
!             month = _insensitiveindex(locale_time.a_month, found_dict['b'])
          elif group_key == 'd':
              day = int(found_dict['d'])
--- 313,319 ----
              month = int(found_dict['m'])
          elif group_key == 'B':
!             month = locale_time.f_month.index(found_dict['B'].lower())
          elif group_key == 'b':
!             month = locale_time.a_month.index(found_dict['b'].lower())
          elif group_key == 'd':
              day = int(found_dict['d'])
***************
*** 444,448 ****
              ampm = found_dict.get('p', '').lower()
              # If there was no AM/PM indicator, we'll treat this like AM
!             if ampm in ('', locale_time.am_pm[0].lower()):
                  # We're in AM so the hour is correct unless we're
                  # looking at 12 midnight.
--- 324,328 ----
              ampm = found_dict.get('p', '').lower()
              # If there was no AM/PM indicator, we'll treat this like AM
!             if ampm in ('', locale_time.am_pm[0]):
                  # We're in AM so the hour is correct unless we're
                  # looking at 12 midnight.
***************
*** 450,454 ****
                  if hour == 12:
                      hour = 0
!             elif ampm == locale_time.am_pm[1].lower():
                  # We're in PM so we need to add 12 to the hour unless
                  # we're looking at 12 noon.
--- 330,334 ----
                  if hour == 12:
                      hour = 0
!             elif ampm == locale_time.am_pm[1]:
                  # We're in PM so we need to add 12 to the hour unless
                  # we're looking at 12 noon.
***************
*** 461,469 ****
              second = int(found_dict['S'])
          elif group_key == 'A':
!             weekday = _insensitiveindex(locale_time.f_weekday,
!                                         found_dict['A'])
          elif group_key == 'a':
!             weekday = _insensitiveindex(locale_time.a_weekday,
!                                         found_dict['a'])
          elif group_key == 'w':
              weekday = int(found_dict['w'])
--- 341,347 ----
              second = int(found_dict['S'])
          elif group_key == 'A':
!             weekday = locale_time.f_weekday.index(found_dict['A'].lower())
          elif group_key == 'a':
!             weekday = locale_time.a_weekday.index(found_dict['a'].lower())
          elif group_key == 'w':
              weekday = int(found_dict['w'])
***************
*** 482,493 ****
                  pass #Deals with bad locale setup where timezone info is
                       # the same; first found on FreeBSD 4.4.
!             elif found_zone in ("utc", "gmt"):
!                 tz = 0
!             elif locale_time.timezone[2].lower() == found_zone:
!                 tz = 0
!             elif time.daylight and \
!                 locale_time.timezone[3].lower() == found_zone:
!                 tz = 1
! 
      # Cannot pre-calculate datetime_date() since can change in Julian
      #calculation and thus could have different value for the day of the week
--- 360,367 ----
                  pass #Deals with bad locale setup where timezone info is
                       # the same; first found on FreeBSD 4.4.
!             else:
!                 for value, tz_values in enumerate(locale_time.timezone):
!                     if found_zone in tz_values:
!                         tz = value
      # Cannot pre-calculate datetime_date() since can change in Julian
      #calculation and thus could have different value for the day of the week
***************
*** 508,522 ****
                               hour, minute, second,
                               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")
--- 382,383 ----





More information about the Python-checkins mailing list