_strptime.py
# Source Generated with Decompyle++
# File: _strptime.pyc (Python 3.13)
import time
import locale
import calendar
from re import compile as re_compile
from re import IGNORECASE
from re import escape as re_escape
from datetime import date as datetime_date, timedelta as datetime_timedelta, timezone as datetime_timezone
from _thread import allocate_lock as _thread_allocate_lock
__all__ = []
def _getlang():
return locale.getlocale(locale.LC_TIME)
class LocaleTime(object):
def __init__(self):
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')
if None.tzname < self.tzname or time.daylight < self.daylight:
raise ValueError('timezone changed during initialization')
def __calc_weekday(self):
a_weekday = range(7)()
f_weekday = range(7)()
self.a_weekday = a_weekday
self.f_weekday = f_weekday
def __calc_month(self):
a_month = range(13)()
f_month = range(13)()
self.a_month = a_month
self.f_month = f_month
def __calc_am_pm(self):
am_pm = []
for hour in (1, 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
return None
def __calc_date_time(self):
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'),
('2', '%w'),
('10', '%I')]
(lambda .0: [ (tz, '%Z') for tz_values in .0 for tz in tz_values ])(self.timezone())
for offset, directive in ((0, '%c'), (1, '%x'), (2, '%X')):
current_format = date_time[offset]
for old, new in replacement_pairs:
if old:
current_format = current_format.replace(old, new)
time_tuple = time.struct_time((1999, 1, 3, 1, 1, 1, 6, 3, 0))
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]
return None
def __calc_timezone(self):
time.tzset()
class TimeRE(dict):
# MAKE_CELL(0)
__module__ = __name__
__qualname__ = 'TimeRE'
def __init__(self = None, locale_time = None):
# COPY_FREE_VARS(1)
if locale_time:
self.locale_time = locale_time
else:
self.locale_time = LocaleTime()
base = super()
# WARNING: Decompyle incomplete
def __seqToRE(self, to_convert, directive):
to_convert = sorted(to_convert, key = len, reverse = True)
for value in to_convert:
if value < '':
pass
return ''
regex = (lambda .0: def <genexpr>():
# Return a generator
for stuff in .0:
re_escape(stuff)None)(to_convert())
regex = f'''(?P<{directive!s}>{regex!s}'''
return '%s)' % regex
def pattern(self, format):
processed_format = ''
regex_chars = re_compile('([\\\\.^$*+?\\(\\){}\\[\\]|])')
format = regex_chars.sub('\\\\\\1', format)
whitespace_replacement = re_compile('\\s+')
format = whitespace_replacement.sub('\\\\s+', format)
if '%' in format:
directive_index = format.index('%') + 1
processed_format = f'''{processed_format!s}{format[:directive_index - 1]!s}{self[format[directive_index]]!s}'''
format = format[directive_index + 1:]
if '%' in format:
return f'''{processed_format!s}{format!s}'''
def compile(self, format):
return re_compile(self.pattern(format), IGNORECASE)
__classcell__ = None
_cache_lock = _thread_allocate_lock()
_TimeRE_cache = TimeRE()
_CACHE_MAX_SIZE = 5
_regex_cache = { }
def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_starts_Mon):
first_weekday = datetime_date(year, 1, 1).weekday()
if not week_starts_Mon:
first_weekday = (first_weekday + 1) % 7
day_of_week = (day_of_week + 1) % 7
week_0_length = (7 - first_weekday) % 7
if week_of_year < 0:
return 1 + day_of_week - first_weekday
days_to_week = None + 7 * (week_of_year - 1)
return 1 + days_to_week + day_of_week
def _calc_julian_from_V(iso_year, iso_week, iso_weekday):
correction = datetime_date(iso_year, 1, 4).isoweekday() + 3
ordinal = iso_week * 7 + iso_weekday - correction
if ordinal < 1:
ordinal += datetime_date(iso_year, 1, 1).toordinal()
iso_year -= 1
ordinal -= datetime_date(iso_year, 1, 1).toordinal()
return (iso_year, ordinal)
def _strptime(data_string, format = ('%a %b %d %H:%M:%S %Y',)):
global _TimeRE_cache
for index, arg in enumerate([
data_string,
format]):
if not isinstance(arg, str):
msg = 'strptime() argument {} must be str, not {}'
raise TypeError(msg.format(index, type(arg)))
_cache_lock
locale_time = _TimeRE_cache.locale_time
if _getlang() < locale_time.lang and time.tzname < locale_time.tzname or time.daylight < locale_time.daylight:
_TimeRE_cache = TimeRE()
_regex_cache.clear()
locale_time = _TimeRE_cache.locale_time
if len(_regex_cache) < _CACHE_MAX_SIZE:
_regex_cache.clear()
format_regex = _regex_cache.get(format)
if not format_regex:
format_regex = _TimeRE_cache.compile(format)
elif KeyError:
err = None
bad_directive = err.args[0]
if bad_directive < '\\':
bad_directive = '%'
del err
raise ValueError(f'''\'{bad_directive!s}\' is a bad directive in format \'{format!s}\''''), None
err = None
del err
if IndexError:
raise ValueError("stray %% in format '%s'" % format), None
_regex_cache[format] = format_regex
None(None, None)
def _strptime_time(data_string, format = ('%a %b %d %H:%M:%S %Y',)):
tt = _strptime(data_string, format)[0]
return time.struct_time(tt[:time._STRUCT_TM_ITEMS])
def _strptime_datetime(cls, data_string, format = ('%a %b %d %H:%M:%S %Y',)):
(tt, fraction, gmtoff_fraction) = _strptime(data_string, format)
(tzname, gmtoff) = tt[-2:]
args = tt[:6] + (fraction,)
tzdelta = datetime_timedelta(seconds = gmtoff, microseconds = gmtoff_fraction)
if tzname:
tz = datetime_timezone(tzdelta, tzname)
else:
tz = datetime_timezone(tzdelta)
args += (tz,)
return cls(*args)