def test_parse_line_date(self):
data = '2015-06-23 aaa\n2044-12-29 bbb'
date = Date(13, 'date')
str = String(3, 'str')
definition = (date, str)
expected1 = [
{'key':'date', 'value':datetime_date(2015, 6, 23)},
{'key':'str', 'value':'aaa'},
]
expected2 = [
{'key':'date', 'value':datetime_date(2044, 12, 29)},
{'key':'str', 'value':'bbb'},
]
fw = FixedWidth(definition, data)
elems = list(fw)
actual1 = elems[0]
actual2 = elems[1]
self.compare_line(expected1, actual1)
self.compare_line(expected2, actual2)
def yearmonth_to_date(x, day=1):
if type(x) is int:
year = x // 100
month = x % 100
elif type(x) is str:
x = str(x)
year = int(re.findall(pattern='^\d+', string=x)[0][:4])
month = int(re.findall(pattern='\d+$', string=x)[0][-2:])
elif type(x) is YearMonth:
year = x.year.value
month = x.month.value
else:
return None
try:
result = datetime_date(year=year, month=month, day=day)
except:
# There is an exception if the day of the month we're in does not exist in the target month
# Go to the FIRST of the month AFTER, then go back one day.
first_day_of_the_month = datetime_date(year=year, month=month, day=1)
first_day_of_next_month = add_months(date=first_day_of_the_month,
months=1)
last_day_of_the_month = add_days(date=first_day_of_next_month, days=-1)
result = last_day_of_the_month
return result
def test_parse_line_date_custom_format(self):
class MyDate(Date):
parse_kwargs = {
'date_formats': ['%y%m---%d']
}
data = '9901---03aaa\n6612---23bbb'
date = MyDate(9, 'date')
str = String(3, 'str')
definition = (date, str)
expected1 = [
{'key':'date', 'value':datetime_date(1999, 1, 3)},
{'key':'str', 'value':'aaa'},
]
expected2 = [
{'key':'date', 'value':datetime_date(2066, 12, 23)},
{'key':'str', 'value':'bbb'},
]
fw = FixedWidth(definition, data)
elems = list(fw)
actual1 = elems[0]
actual2 = elems[1]
self.compare_line(expected1, actual1)
self.compare_line(expected2, actual2)
def populate_db(self):
""" Populates the database """
b1 = bookings.Booking(user=1, date=datetime_date(2019, 11, 1), movie=1)
b2 = bookings.Booking(user=2, date=datetime_date(2019, 11, 2), movie=2)
b3 = bookings.Booking(user=3, date=datetime_date(2019, 11, 3), movie=3)
bookings.db.session.add(b1)
bookings.db.session.add(b2)
bookings.db.session.add(b3)
bookings.db.session.commit()
def populate_db(self):
""" Populates the database """
s1 = showtimes.Showtime(date=datetime_date(2019, 11, 1), movie=1)
s2 = showtimes.Showtime(date=datetime_date(2019, 11, 2), movie=2)
s3 = showtimes.Showtime(date=datetime_date(2019, 11, 3), movie=3)
showtimes.db.session.add(s1)
showtimes.db.session.add(s2)
showtimes.db.session.add(s3)
showtimes.db.session.commit()
def _calc_julian_from_V(iso_year, iso_week, iso_weekday):
"""Calculate the Julian day based on the ISO 8601 year, week, and weekday.
ISO weeks start on Mondays, with week 01 being the week containing 4 Jan.
ISO week days range from 1 (Monday) to 7 (Sunday).
"""
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 test_serialize_line_date_from_date_input_with_output_format(self):
a = Date(12, 'a', '%m-%d-%y')
b = Date(12, 'b', '%m-%d-%y')
definition = (a, b)
response = Bunch()
response.a = datetime_date(2017, 1, 25)
response.b = datetime_date(2018, 2, 26)
fw = FixedWidth(definition)
result = fw.serialize(response)
self.assertEquals(result, '01-25-17 02-26-18 ')
def test_serialize_line_date_from_date_input(self):
a = Date(16, 'a')
b = Date(16, 'b')
definition = (a, b)
response = Bunch()
response.a = datetime_date(2017, 1, 25)
response.b = datetime_date(2018, 2, 26)
fw = FixedWidth(definition)
result = fw.serialize(response)
self.assertEquals(result, '2017-01-25 2018-02-26 ')
def _compute_date_from_to(self, date):
self.ensure_one()
date_from = date_to = fields.Date.from_string(date)
if self.range_reset == 'weekly':
date_from = date_from - timedelta(days=date_from.weekday())
date_to = date_from + timedelta(days=6)
elif self.range_reset == 'monthly':
date_from = datetime_date(date_from.year, date_from.month, 1)
date_to = date_from + relativedelta(months=1)
date_to += relativedelta(days=-1)
elif self.range_reset == 'yearly':
date_from = datetime_date(date_from.year, 1, 1)
date_to = datetime_date(date_from.year, 12, 31)
return date_from.strftime('%Y-%m-%d'), date_to.strftime('%Y-%m-%d')
def _compute_date_from_to(self, date):
self.ensure_one()
date_from = date_to = date
if self.range_reset == "weekly":
date_from = date_from - timedelta(days=date_from.weekday())
date_to = date_from + timedelta(days=6)
elif self.range_reset == "monthly":
date_from = datetime_date(date_from.year, date_from.month, 1)
date_to = date_from + relativedelta(months=1)
date_to += relativedelta(days=-1)
elif self.range_reset == "yearly":
date_from = datetime_date(date_from.year, 1, 1)
date_to = datetime_date(date_from.year, 12, 31)
return date_from, date_to
def _calc_julian_from_V(iso_year, iso_week, iso_weekday):
"""Calculate the Julian day based on the ISO 8601 year, week, and weekday.
ISO weeks start on Mondays, with week 01 being the week containing 4 Jan.
ISO week days range from 1 (Monday) to 7 (Sunday).
"""
correction = datetime_date(iso_year, 1, 4).isoweekday() + 3
ordinal = (iso_week * 7) + iso_weekday - correction
# ordinal may be negative or 0 now, which means the date is in the previous
# calendar year
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 _calc_julian_from_V(iso_year, iso_week, iso_weekday):
"""Calculate the Julian day based on the ISO 8601 year, week, and weekday.
ISO weeks start on Mondays, with week 01 being the week containing 4 Jan.
ISO week days range from 1 (Monday) to 7 (Sunday).
"""
correction = datetime_date(iso_year, 1, 4).isoweekday() + 3
ordinal = (iso_week * 7) + iso_weekday - correction
# ordinal may be negative or 0 now, which means the date is in the previous
# calendar year
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 read_c_timeseries(directory, stocks="All", days="All"):
stock_dic = {}
num_of_days = 0
all_dates = []
cur_dir = getcwd()
chdir(directory)
# Reading data from files - Keeping dates and close value
for fname in glob("*.txt"):
num_of_stocks = 0
if days == "All" or num_of_days < days:
file_iter = open(fname, "rU")
for line in file_iter:
if stocks == "All" or num_of_stocks < stocks:
temp = line.strip().rstrip(" ").split(",")
date = datetime_date(int(temp[0][0:4]), int(temp[0][4:6]), int(temp[0][6:8]))
if temp[1] not in stock_dic:
stock_dic[temp[1]] = [{"Date": date, "Close": float(temp[5])}]
else:
stock_dic[temp[1]].append({"Date": date, "Close": float(temp[5])})
else:
break
num_of_stocks += 1
all_dates.append(date)
file_iter.close()
num_of_days += 1
chdir(cur_dir)
return (stock_dic, all_dates)
def read_p_timeseries(directory, name, days="All"):
stock_dic = {}
num_of_days = 0
cur_dir = getcwd()
chdir(directory)
# Reading data from files - Keeping dates and close value
for fname in glob("*.txt"):
if days == "All" or num_of_days <= days - 1:
file_iter = open(fname, "rU")
for line in file_iter:
temp = line.strip().rstrip(" ").split(",")
if temp[1] == name:
date = datetime_date(int(temp[0][0:4]), int(temp[0][4:6]), int(temp[0][6:8]))
if temp[1] not in stock_dic:
stock_dic[temp[1]] = [{"Date": date, "Close": float(temp[5])}]
else:
stock_dic[temp[1]].append({"Date": date, "Close": float(temp[5])})
file_iter.close()
num_of_days += 1
chdir(cur_dir)
return stock_dic
def read_p_timeseries(directory, name, days='All'):
stock_dic = {}
num_of_days = 0
cur_dir = getcwd()
chdir(directory)
# Reading data from files - Keeping dates and close value
for fname in glob("*.txt"):
if days == 'All' or num_of_days <= days - 1:
file_iter = open(fname, 'rU')
for line in file_iter:
temp = line.strip().rstrip(' ').split(',')
if temp[1] == name:
date = datetime_date(int(temp[0][0:4]), int(temp[0][4:6]),
int(temp[0][6:8]))
if temp[1] not in stock_dic:
stock_dic[temp[1]] = [{
"Date": date,
"Close": float(temp[5])
}]
else:
stock_dic[temp[1]].append({
"Date": date,
"Close": float(temp[5])
})
file_iter.close()
num_of_days += 1
chdir(cur_dir)
return (stock_dic)
def run():
url = "https://open.senrigan.io/api/betterself/v2/productivity_logs/"
df = pd.read_excel(
"snapshots/personal_historical_pomodoros.xlsx", keep_default_na=""
)
token_key = f"Token {settings.BETTERSELF_PERSONAL_API_KEY}"
headers = {"Authorization": token_key}
for index, row in df.iterrows():
date = row["Date"].date().isoformat()
# interim when it failed on a na/string
last_progress = datetime_date(2020, 5, 21)
if row["Date"].date() > last_progress:
continue
notes = row["Description Of Day"]
mistakes = row["Mistakes"]
pomodoro_count = row["Pomodoros"]
if not pomodoro_count:
continue
data = {
"pomodoro_count": pomodoro_count,
"date": date,
"notes": notes,
"mistakes": mistakes,
}
response = requests.post(url, json=data, headers=headers)
if response.status_code != 200:
print(response.content)
assert response.status_code == 200
def generate_year_folder_id(service, file_name):
month, day, year = file_name
date_beginning = datetime_date(year, 8, 1)
league_date = datetime_date(year, month, day)
if league_date < date_beginning:
folder_name = '{}-{}'.format(year - 1, year)
else:
folder_name = '{}-{}'.format(year, year + 1)
file_metadata = {
'parents': [RESULTS_FOLDER_ID],
'name': folder_name,
'mimeType': 'application/vnd.google-apps.folder'
}
file = service.files().create(body=file_metadata, fields='id').execute()
return file['id']
def __init__(self, *args, url: str, date: str, sheet_id: str, **kwargs):
super().__init__(*args, **kwargs)
self.page_url = url
self.sheet_id = sheet_id
day, month, year = map(int, date.split('.'))
self.date = datetime_date(year=year, month=month, day=day)
def get(self, *args, **kwargs):
date = kwargs.get('date')
clan = Clan.objects.get(pk=int(self.request.GET.get('clan_id', 35039)))
force_update = self.request.GET.get('force_update') == 'true'
if force_update:
from global_map.management.commands.fetchdata import update_clan
update_clan(clan.id)
pa_query = ProvinceAssault.objects.distinct('province').order_by(
'province')
if date:
date = datetime_date(*[int(i) for i in date.split('-')])
assaults = [
assault.as_clan_json(clan, current_only=False)
for assault in pa_query.filter(date=date).filter(
Q(battles__clan_a=clan) | Q(battles__clan_b=clan)
| Q(clans=clan) | Q(current_owner=clan))
]
else:
date = datetime.now().date()
assaults = [
assault.as_clan_json(clan) for assault in pa_query.filter(
date=date).filter(Q(clans=clan) | Q(current_owner=clan))
]
# Remove assaults without battles
for assault in assaults[::]:
if not assault['battles']:
logger.debug("Removing assault on province %s",
assault['province_info']['province_id'])
assaults.remove(assault)
times = [
battle['planned_start_at'] for assault in assaults
for battle in assault['battles']
]
if times:
min_time = min(times)
min_time = min_time.replace(minute=min_time.minute -
min_time.minute % 30)
max_time = max(times)
else:
min_time = datetime.now().replace(hour=15, minute=00)
max_time = datetime.now().replace(hour=2,
minute=00) + timedelta(days=1)
return JsonResponse({
'time_range': [min_time, max_time],
'assaults':
sorted(
assaults,
key=lambda v:
(v['province_info']['prime_time'].minute == 15, v['battles'][0]
['planned_start_at'], v['province_info']['province_id'])),
})
def determine_year_folder_id(service, file_name):
results = service.files().list(
q="'{}' in parents".format(RESULTS_FOLDER_ID),
fields="nextPageToken, files(id, name)").execute()
year_folders = results.get('files', [])
if year_folders:
month, day, year = file_name
for folder in year_folders:
split_file_name = shared_functions.file_name_split(
folder['name'].strip())
if [element for element in split_file_name if element.isdigit()]:
year_beginning, year_end = tuple(split_file_name)
date_beginning = datetime_date(int(year_beginning), 8, 1)
date_end = datetime_date(int(year_end), 7, 31)
if date_beginning <= datetime_date(year, month,
day) <= date_end:
return folder['id']
return generate_year_folder_id(service=service, file_name=file_name)
def parse_metadata_time(sfield):
sdate = sfield.split(' ')[1]
if sdate:
de = sdate.split('_')
try:
return datetime_date(int(de[0]), int(de[1]), int(de[2]))
except ValueError:
# Catches conversion to int failure, in case the date is 'unknown'
pass
return None
def test_helper(ymd_tuple, test_reason):
for year_week_format in ("%Y %W", "%Y %U", "%G %V"):
for weekday_format in ("%w", "%u", "%a", "%A"):
format_string = year_week_format + " " + weekday_format
with self.subTest(test_reason, date=ymd_tuple, format=format_string):
dt_date = datetime_date(*ymd_tuple)
strp_input = dt_date.strftime(format_string)
strp_output = _strptime._strptime_time(strp_input, format_string)
msg = "%r: %s != %s" % (strp_input, strp_output[7], dt_date.timetuple()[7])
self.assertEqual(strp_output[:3], ymd_tuple, msg)
def parse_metadata_time(sfield):
sdate = sfield.split(' ')[1]
if sdate:
de = sdate.split('_')
try:
return datetime_date(int(de[0]),int(de[1]),int(de[2]))
except ValueError:
# Catches conversion to int failure, in case the date is 'unknown'
pass
return None
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 = week_0_length + 7 * (week_of_year - 1)
return 1 + days_to_week + day_of_week
def test_helper(ymd_tuple, test_reason):
for directive in ('W', 'U'):
format_string = "%%Y %%%s %%w" % directive
dt_date = datetime_date(*ymd_tuple)
strp_input = dt_date.strftime(format_string)
strp_output = _strptime._strptime_time(strp_input, format_string)
self.assertTrue(strp_output[:3] == ymd_tuple,
"%s(%s) test failed w/ '%s': %s != %s (%s != %s)" %
(test_reason, directive, strp_input,
strp_output[:3], ymd_tuple,
strp_output[7], dt_date.timetuple()[7]))
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
else:
days_to_week = week_0_length + 7 * (week_of_year - 1)
return 1 + days_to_week + day_of_week
def test_helper(ymd_tuple, test_reason):
for directive in ('W', 'U'):
format_string = "%%Y %%%s %%w" % directive
dt_date = datetime_date(*ymd_tuple)
strp_input = dt_date.strftime(format_string)
strp_output = _strptime._strptime_time(strp_input, format_string)
self.assertTrue(strp_output[:3] == ymd_tuple,
"%s(%s) test failed w/ '%s': %s != %s (%s != %s)" %
(test_reason, directive, strp_input,
strp_output[:3], ymd_tuple,
strp_output[7], dt_date.timetuple()[7]))
def find_any_date(str_or_match) -> datetime.date or None:
"""Try to find a date in input string and return it as a date object.
If there is no matching date, return None.
The returned date can't be from the future.
"""
if isinstance(str_or_match, str):
match = ANYDATE_SEARCH(str_or_match)
else:
match = str_or_match
if not match:
return None
groupdict = match.groupdict()
day = int(groupdict['d'])
year = int(groupdict['Y'])
month = groupdict.get('jB')
today = datetime.today().date()
if month:
date = jdate(year, jB_TO_NUM[month], day).togregorian()
if date <= today:
return date
return
month = groupdict.get('B')
if month:
date = datetime_date(year, B_TO_NUM[month.lower()], day)
if date <= today:
return date
return
month = groupdict.get('b')
if month:
date = datetime_date(year, b_TO_NUM[month.lower()], day)
if date <= today:
return date
return
month = groupdict.get('m')
if month:
date = datetime_date(year, int(month), day)
if date <= today:
return date
return
def crossref(doi) -> defaultdict:
"""Get the crossref.org json data for the given DOI. Return parsed data."""
# See https://github.com/CrossRef/rest-api-doc/blob/master/api_format.md
# for documentation.
# Force using the version 1 of the API to prevent breakage. See:
# https://github.com/CrossRef/rest-api-doc/blob/master/rest_api.md#how-to-manage-api-versions
j = requests_get(
'http://api.crossref.org/v1/works/' + doi, timeout=10
).json()
assert j['status'] == 'ok'
d = defaultdict(
lambda: None, {k.lower(): v for k, v in j['message'].items()})
d['cite_type'] = d.pop('type')
for field in ('title', 'container-title', 'issn', 'isbn'):
value = d[field]
if value:
d[field] = value[0]
date = d['issued']['date-parts'][0]
date_len = len(date)
if date_len == 3:
d['date'] = datetime_date(*date)
elif date_len == 2:
d['year'], d['month'] = str(date[0]), str(date[1])
else:
year = date[0]
# date can be of the form [None]
# https://github.com/CrossRef/rest-api-doc/issues/169
if year:
d['year'] = str(date[0])
authors = d['author']
if authors:
d['authors'] = \
[Name(name['given'], name['family']) for name in authors]
editors = d['editor']
if editors:
d['editors'] = \
[Name(name['given'], name['family']) for name in editors]
translators = d['translator']
if translators:
d['translators'] = \
[Name(name['given'], name['family']) for name in translators]
page = d['page']
if page:
d['page'] = page.replace('-', '–')
return d
def find_any_date(str_or_match) -> datetime.date or None:
"""Try to find a date in input string and return it as a date object.
If there is no matching date, return None.
The returned date can't be from the future.
"""
if isinstance(str_or_match, str):
match = ANYDATE_SEARCH(str_or_match)
else:
match = str_or_match
if not match:
return None
groupdict = match.groupdict()
day = int(groupdict['d'])
year = int(groupdict['Y'])
month = groupdict.get('jB')
today = datetime.today().date()
if month:
date = jdate(year, jB_TO_NUM[month], day).togregorian()
if date <= today:
return date
return
month = groupdict.get('B')
if month:
date = datetime_date(year, B_TO_NUM[month.lower()], day)
if date <= today:
return date
return
month = groupdict.get('b')
if month:
date = datetime_date(year, b_TO_NUM[month.lower()], day)
if date <= today:
return date
return
month = groupdict.get('m')
if month:
date = datetime_date(year, int(month), day)
if date <= today:
return date
return
def run():
url = "https://open.senrigan.io/api/betterself/v2/productivity_logs/"
df = pd.read_excel("snapshots/personal_historical_pomodoros.xlsx",
keep_default_na="")
token_key = f"Token {settings.BETTERSELF_PERSONAL_API_KEY}"
headers = {"Authorization": token_key}
df.index = df["Date"]
df = df.sort_index()
start_import_period = datetime_date(2020, 7, 9)
end_import_period = datetime_date(2020, 7, 28)
for index, row in df.iterrows():
date = row["Date"].date().isoformat()
should_import = start_import_period <= index.date(
) <= end_import_period
if not should_import:
continue
notes = row["Description Of Day"]
mistakes = row["Mistakes"]
pomodoro_count = row["Pomodoros"]
if not pomodoro_count:
continue
data = {
"pomodoro_count": pomodoro_count,
"date": date,
"notes": notes,
"mistakes": mistakes,
}
response = requests.post(url, json=data, headers=headers)
if response.status_code != 200:
print(response.content)
assert response.status_code == 200
def get(self, *args, **kwargs):
date = kwargs.get('date')
clan = Clan.objects.get(pk=int(self.request.GET.get('clan_id', 35039)))
force_update = self.request.GET.get('force_update') == 'true'
if force_update:
from global_map.management.commands.fetchdata import update_clan
update_clan(clan.id)
pa_query = ProvinceAssault.objects.distinct('province').order_by('province')
if date:
date = datetime_date(*[int(i) for i in date.split('-')])
assaults = [
assault.as_clan_json(clan, current_only=False)
for assault in pa_query.filter(date=date).filter(
Q(battles__clan_a=clan) | Q(battles__clan_b=clan) | Q(clans=clan) | Q(current_owner=clan))
]
else:
date = datetime.now().date()
assaults = [
assault.as_clan_json(clan)
for assault in pa_query.filter(date=date).filter(Q(clans=clan) | Q(current_owner=clan))
]
# Remove assaults without battles
for assault in assaults[::]:
if not assault['battles']:
logger.debug("Removing assault on province %s", assault['province_info']['province_id'])
assaults.remove(assault)
times = [
battle['planned_start_at']
for assault in assaults
for battle in assault['battles']
]
if times:
min_time = min(times)
min_time = min_time.replace(minute=min_time.minute - min_time.minute % 30)
max_time = max(times)
else:
min_time = datetime.now().replace(hour=15, minute=00)
max_time = datetime.now().replace(hour=2, minute=00) + timedelta(days=1)
return JsonResponse({
'time_range': [min_time, max_time],
'assaults': sorted(
assaults,
key=lambda v: (v['province_info']['prime_time'].minute == 15, v['battles'][0]['planned_start_at'],
v['province_info']['province_id'])
),
})
def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_starts_Mon):
"""Calculate the Julian day based on the year, week of the year, and day of
the week, with week_start_day representing whether the week of the year
assumes the week starts on Sunday or Monday (6 or 0)."""
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 = week_0_length + 7 * (week_of_year - 1)
return 1 + days_to_week + day_of_week
def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_starts_Mon):
"""Calculate the Julian day based on the year, week of the year, and day of
the week, with week_start_day representing whether the week of the year
assumes the week starts on Sunday or Monday (6 or 0)."""
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
else:
days_to_week = week_0_length + 7 * (week_of_year - 1)
return 1 + days_to_week + day_of_week
def test_helper(ymd_tuple, test_reason):
for year_week_format in ('%Y %W', '%Y %U', '%G %V'):
for weekday_format in ('%w', '%u', '%a', '%A'):
format_string = year_week_format + ' ' + weekday_format
with self.subTest(test_reason,
date=ymd_tuple,
format=format_string):
dt_date = datetime_date(*ymd_tuple)
strp_input = dt_date.strftime(format_string)
strp_output = _strptime._strptime_time(
strp_input, format_string)
msg = "%r: %s != %s" % (strp_input, strp_output[7],
dt_date.timetuple()[7])
self.assertEqual(strp_output[:3], ymd_tuple, msg)
def showtimes_record(date):
# maps a string to a datetime.date object
date_object = datetime_date(*map(int, date.split('-')))
showtimes = Showtime.query.filter_by(date=date_object).all()
if not showtimes:
raise NotFound
serialized_objects = showtimes_schema.dumps(showtimes,
sort_keys=True,
indent=4)
return Response(response=serialized_objects,
status=http_status.OK,
mimetype="application/json")
def test_helper(ymd_tuple, test_reason):
for year_week_format in ('%Y %W', '%Y %U', '%G %V'):
for weekday_format in ('%w', '%u', '%a', '%A'):
format_string = year_week_format + ' ' + weekday_format
with self.subTest(test_reason,
date=ymd_tuple,
format=format_string):
dt_date = datetime_date(*ymd_tuple)
strp_input = dt_date.strftime(format_string)
strp_output = _strptime._strptime_time(strp_input,
format_string)
msg = "%r: %s != %s" % (strp_input,
strp_output[7],
dt_date.timetuple()[7])
self.assertEqual(strp_output[:3], ymd_tuple, msg)
def getConferenceSessionsByTime(self, request):
"""Gets all the Sessions for a Conference within a time period"""
conference_id = request.websafeConferenceKey
conference_key = ndb.Key(urlsafe=request.websafeConferenceKey)
if conference_key.kind() != 'Conference':
raise endpoints.BadRequestException(
'Key %s is not a valid conference key' % conference_id
)
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# add this to all time objects to get the right datetime for querying datastore
filler_date = datetime_date(1970, 1, 1)
date = datetime.strptime(data['conferenceDate'], "%Y-%m-%d")
startTime = datetime.strptime(data['startTime'], "%H:%M").time()
startDateTime = datetime.combine(date=filler_date, time=startTime)
endTime = datetime.strptime(data['endTime'], "%H:%M").time()
endDateTime = datetime.combine(date=filler_date, time=endTime)
dateFilter = ndb.query.FilterNode(
'date',
OPERATORS['EQ'],
date,
)
startTimeFilter = ndb.query.FilterNode(
'startTime',
OPERATORS['GTEQ'],
startDateTime,
)
endTimeFilter = ndb.query.FilterNode(
'startTime',
OPERATORS['LTEQ'],
endDateTime,
)
sessions = Session.query(ancestor=conference_key).filter(dateFilter)\
.filter(startTimeFilter).filter(endTimeFilter)
return SessionForms(
items=[self._copySessionToForm(session) for session in sessions]
)
def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_starts_Mon):
"""Calculate the Julian day based on the year, week of the year, and day of
the week, with week_start_day representing whether the week of the year
assumes the week starts on Sunday or Monday (6 or 0)."""
first_weekday = datetime_date(year, 1, 1).weekday()
# If we are dealing with the %U directive (week starts on Sunday), it's
# easier to just shift the view to Sunday being the first day of the
# week.
if not week_starts_Mon:
first_weekday = (first_weekday + 1) % 7
day_of_week = (day_of_week + 1) % 7
# Need to watch out for a week 0 (when the first day of the year is not
# the same as that specified by %U or %W).
week_0_length = (7 - first_weekday) % 7
if week_of_year == 0:
return 1 + day_of_week - first_weekday
days_to_week = week_0_length + (7 * (week_of_year - 1))
return 1 + days_to_week + day_of_week
def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_starts_Mon):
"""Calculate the Julian day based on the year, week of the year, and day of
the week, with week_start_day representing whether the week of the year
assumes the week starts on Sunday or Monday (6 or 0)."""
first_weekday = datetime_date(year, 1, 1).weekday()
# If we are dealing with the %U directive (week starts on Sunday), it's
# easier to just shift the view to Sunday being the first day of the
# week.
if not week_starts_Mon:
first_weekday = (first_weekday + 1) % 7
day_of_week = (day_of_week + 1) % 7
# Need to watch out for a week 0 (when the first day of the year is not
# the same as that specified by %U or %W).
week_0_length = (7 - first_weekday) % 7
if week_of_year == 0:
return 1 + day_of_week - first_weekday
else:
days_to_week = week_0_length + (7 * (week_of_year - 1))
return 1 + days_to_week + day_of_week
def test_helper(ymd_tuple, test_reason):
for year_week_format in ('%Y %W', '%Y %U', '%G %V'):
if (year_week_format in self._formats_excluded
and ymd_tuple in self._ymd_excluded):
return
# skip all dates for format %G %V
if OPENVMS and year_week_format in self._formats_excluded:
return
for weekday_format in ('%w', '%u', '%a', '%A'):
format_string = year_week_format + ' ' + weekday_format
with self.subTest(test_reason,
date=ymd_tuple,
format=format_string):
dt_date = datetime_date(*ymd_tuple)
strp_input = dt_date.strftime(format_string)
strp_output = _strptime._strptime_time(
strp_input, format_string)
msg = "%r: %s != %s" % (strp_input, strp_output[7],
dt_date.timetuple()[7])
self.assertEqual(strp_output[:3], ymd_tuple, msg)
def getSessionsExcludeTypeTime(self, request):
"""Gets all Sessions not of the specified type and before the specified time"""
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# add this to all time objects to get the right datetime for querying datastore
filler_date = datetime_date(1970, 1, 1)
# set time filter
try:
latestTime = datetime.strptime(data['latestTime'], "%H:%M").time()
latestDateTime = datetime.combine(date=filler_date, time=latestTime)
timeFilter = ndb.query.FilterNode('startTime', OPERATORS['LT'], latestDateTime)
except (KeyError, TypeError):
timeFilter = None
# set type filter
try:
excludedSession = data['excludedSessionType']
allowed_types = SessionType.to_dict().keys()
allowed_types.remove(str(excludedSession))
except (KeyError, ValueError):
allowed_types = None
sessions = Session.query()
if timeFilter:
sessions = sessions.filter(timeFilter)
if allowed_types:
correct_sessions = []
for session in sessions:
if session.typeOfSession in allowed_types:
correct_sessions.append(session)
else:
correct_sessions = sessions
return SessionForms(
items=[self._copySessionToForm(session) for session in correct_sessions]
)
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 _locale_cache
global _regex_cache
locale_time = _locale_cache.locale_time
# If the language changes, caches are invalidated, so clear them
if locale_time.lang != _getlang():
_locale_cache = TimeRE()
_regex_cache.clear()
format_regex = _regex_cache.get(format)
if not format_regex:
# Limit regex cache size to prevent major bloating of the module;
# The value 5 is arbitrary
if len(_regex_cache) > 5:
_regex_cache.clear()
format_regex = _locale_cache.compile(format)
_regex_cache[format] = format_regex
found = format_regex.match(data_string)
if not found:
raise ValueError("time data did not match format: data=%s fmt=%s" %
(data_string, format))
if len(data_string) != found.end():
raise ValueError("unconverted data remains: %s" %
data_string[found.end():])
year = 1900
month = day = 1
hour = minute = second = 0
tz = -1
# weekday and julian defaulted to -1 so as to signal need to calculate values
weekday = julian = -1
found_dict = found.groupdict()
for group_key in found_dict.iterkeys():
if group_key == 'y':
year = int(found_dict['y'])
# Open Group specification for strptime() states that a %y
#value in the range of [00, 68] is in the century 2000, while
#[69,99] is in the century 1900
if year <= 68:
year += 2000
else:
year += 1900
elif group_key == 'Y':
year = int(found_dict['Y'])
elif group_key == 'm':
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'])
elif group_key == 'H':
hour = int(found_dict['H'])
elif group_key == 'I':
hour = int(found_dict['I'])
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.
# 12 midnight == 12 AM == hour 0
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.
# 12 noon == 12 PM == hour 12
if hour != 12:
hour += 12
elif group_key == 'M':
minute = int(found_dict['M'])
elif group_key == 'S':
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'])
if weekday == 0:
weekday = 6
else:
weekday -= 1
elif group_key == 'j':
julian = int(found_dict['j'])
elif group_key == 'Z':
# Since -1 is default value only need to worry about setting tz if
# it can be something other than -1.
found_zone = found_dict['Z'].lower()
if found_zone in ("utc", "gmt"):
tz = 0
elif time.tzname[0] == time.tzname[1] and \
time.daylight:
continue #Deals with bad locale setup where timezone info is
# the same; first found on FreeBSD 4.4.
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
#calculation
if julian == -1:
# Need to add 1 to result since first day of the year is 1, not 0.
julian = datetime_date(year, month, day).toordinal() - \
datetime_date(year, 1, 1).toordinal() + 1
else: # Assume that if they bothered to include Julian day it will
#be accurate
datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday == -1:
weekday = datetime_date(year, month, day).weekday()
return time.struct_time((year, month, day,
hour, minute, second,
weekday, julian, tz))
if (time.tzname[0] == time.tzname[1] and
time.daylight and found_zone not in ("utc", "gmt")):
break
else:
tz = value
break
# If we know the week of the year and what day of that week, we can figure
# out the Julian day of the year.
if julian == -1 and week_of_year != -1 and weekday != -1:
week_starts_Mon = True if week_of_year_start == 0 else False
julian = _calc_julian_from_U_or_W(year, week_of_year, weekday,
week_starts_Mon)
# Cannot pre-calculate datetime_date() since can change in Julian
# calculation and thus could have different value for the day of the week
# calculation.
if julian == -1:
# Need to add 1 to result since first day of the year is 1, not 0.
julian = datetime_date(year, month, day).toordinal() - \
datetime_date(year, 1, 1).toordinal() + 1
else: # Assume that if they bothered to include Julian day it will
# be accurate.
datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday == -1:
weekday = datetime_date(year, month, day).weekday()
return time.struct_time((year, month, day,
hour, minute, second,
weekday, julian, tz))
def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
"""Return a time struct based on the input string and the format string."""
global _TimeRE_cache
global _regex_cache
with _cache_lock:
if _getlang() != _TimeRE_cache.locale_time.lang:
_TimeRE_cache = TimeRE()
_regex_cache.clear()
if len(_regex_cache) > _CACHE_MAX_SIZE:
_regex_cache.clear()
locale_time = _TimeRE_cache.locale_time
format_regex = _regex_cache.get(format)
if not format_regex:
try:
format_regex = _TimeRE_cache.compile(format)
except KeyError as err:
bad_directive = err.args[0]
if bad_directive == "\\":
bad_directive = "%"
del err
raise ValueError("'%s' is a bad directive in format '%s'" % (bad_directive, format))
except IndexError:
raise ValueError("stray %% in format '%s'" % format)
_regex_cache[format] = format_regex
found = format_regex.match(data_string)
if not found:
raise ValueError("time data %r does not match format %r" % (data_string, format))
if len(data_string) != found.end():
raise ValueError("unconverted data remains: %s" % data_string[found.end() :])
year = None
month = day = 1
hour = minute = second = fraction = 0
tz = -1
week_of_year = -1
week_of_year_start = -1
weekday = julian = -1
found_dict = found.groupdict()
for group_key in found_dict.iterkeys():
if group_key == "y":
year = int(found_dict["y"])
if year <= 68:
year += 2000
else:
year += 1900
elif group_key == "Y":
year = int(found_dict["Y"])
elif group_key == "m":
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"])
elif group_key == "H":
hour = int(found_dict["H"])
elif group_key == "I":
hour = int(found_dict["I"])
ampm = found_dict.get("p", "").lower()
if ampm in ("", locale_time.am_pm[0]):
if hour == 12:
hour = 0
elif ampm == locale_time.am_pm[1]:
if hour != 12:
hour += 12
elif group_key == "M":
minute = int(found_dict["M"])
elif group_key == "S":
second = int(found_dict["S"])
elif group_key == "f":
s = found_dict["f"]
s += "0" * (6 - len(s))
fraction = int(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"])
if weekday == 0:
weekday = 6
else:
weekday -= 1
elif group_key == "j":
julian = int(found_dict["j"])
elif group_key in ("U", "W"):
week_of_year = int(found_dict[group_key])
if group_key == "U":
week_of_year_start = 6
else:
week_of_year_start = 0
elif group_key == "Z":
found_zone = found_dict["Z"].lower()
for value, tz_values in enumerate(locale_time.timezone):
if found_zone in tz_values:
if time.tzname[0] == time.tzname[1] and time.daylight and found_zone not in ("utc", "gmt"):
break
else:
tz = value
break
leap_year_fix = False
if year is None and month == 2 and day == 29:
year = 1904
leap_year_fix = True
elif year is None:
year = 1900
if julian == -1 and week_of_year != -1 and weekday != -1:
week_starts_Mon = True if week_of_year_start == 0 else False
julian = _calc_julian_from_U_or_W(year, week_of_year, weekday, week_starts_Mon)
if julian == -1:
julian = datetime_date(year, month, day).toordinal() - datetime_date(year, 1, 1).toordinal() + 1
else:
datetime_result = datetime_date.fromordinal(julian - 1 + datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday == -1:
weekday = datetime_date(year, month, day).weekday()
if leap_year_fix:
year = 1900
return (time.struct_time((year, month, day, hour, minute, second, weekday, julian, tz)), fraction)
def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
"""Return a 2-tuple consisting of a time struct and an int containing
the number of microseconds based on the input string and the
format string."""
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)))
global _TimeRE_cache, _regex_cache
with _cache_lock:
locale_time = _TimeRE_cache.locale_time
if (_getlang() != locale_time.lang or
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:
try:
format_regex = _TimeRE_cache.compile(format)
# KeyError raised when a bad format is found; can be specified as
# \\, in which case it was a stray % but with a space after it
except KeyError as err:
bad_directive = err.args[0]
if bad_directive == "\\":
bad_directive = "%"
del err
raise ValueError("'%s' is a bad directive in format '%s'" %
(bad_directive, format)) from None
# IndexError only occurs when the format string is "%"
except IndexError:
raise ValueError("stray %% in format '%s'" % format) from None
_regex_cache[format] = format_regex
found = format_regex.match(data_string)
if not found:
raise ValueError("time data %r does not match format %r" %
(data_string, format))
if len(data_string) != found.end():
raise ValueError("unconverted data remains: %s" %
data_string[found.end():])
iso_year = year = None
month = day = 1
hour = minute = second = fraction = 0
tz = -1
tzoffset = None
# Default to -1 to signify that values not known; not critical to have,
# though
iso_week = week_of_year = None
week_of_year_start = None
# weekday and julian defaulted to None so as to signal need to calculate
# values
weekday = julian = None
found_dict = found.groupdict()
for group_key in found_dict.keys():
# Directives not explicitly handled below:
# c, x, X
# handled by making out of other directives
# U, W
# worthless without day of the week
if group_key == 'y':
year = int(found_dict['y'])
# Open Group specification for strptime() states that a %y
#value in the range of [00, 68] is in the century 2000, while
#[69,99] is in the century 1900
if year <= 68:
year += 2000
else:
year += 1900
elif group_key == 'Y':
year = int(found_dict['Y'])
elif group_key == 'G':
iso_year = int(found_dict['G'])
elif group_key == 'm':
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'])
elif group_key == 'H':
hour = int(found_dict['H'])
elif group_key == 'I':
hour = int(found_dict['I'])
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.
# 12 midnight == 12 AM == hour 0
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.
# 12 noon == 12 PM == hour 12
if hour != 12:
hour += 12
elif group_key == 'M':
minute = int(found_dict['M'])
elif group_key == 'S':
second = int(found_dict['S'])
elif group_key == 'f':
s = found_dict['f']
# Pad to always return microseconds.
s += "0" * (6 - len(s))
fraction = int(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'])
if weekday == 0:
weekday = 6
else:
weekday -= 1
elif group_key == 'u':
weekday = int(found_dict['u'])
weekday -= 1
elif group_key == 'j':
julian = int(found_dict['j'])
elif group_key in ('U', 'W'):
week_of_year = int(found_dict[group_key])
if group_key == 'U':
# U starts week on Sunday.
week_of_year_start = 6
else:
# W starts week on Monday.
week_of_year_start = 0
elif group_key == 'V':
iso_week = int(found_dict['V'])
elif group_key == 'z':
z = found_dict['z']
tzoffset = int(z[1:3]) * 60 + int(z[3:5])
if z.startswith("-"):
tzoffset = -tzoffset
elif group_key == 'Z':
# Since -1 is default value only need to worry about setting tz if
# it can be something other than -1.
found_zone = found_dict['Z'].lower()
for value, tz_values in enumerate(locale_time.timezone):
if found_zone in tz_values:
# Deal with bad locale setup where timezone names are the
# same and yet time.daylight is true; too ambiguous to
# be able to tell what timezone has daylight savings
if (time.tzname[0] == time.tzname[1] and
time.daylight and found_zone not in ("utc", "gmt")):
break
else:
tz = value
break
# Deal with the cases where ambiguities arize
# don't assume default values for ISO week/year
if year is None and iso_year is not None:
if iso_week is None or weekday is None:
raise ValueError("ISO year directive '%G' must be used with "
"the ISO week directive '%V' and a weekday "
"directive ('%A', '%a', '%w', or '%u').")
if julian is not None:
raise ValueError("Day of the year directive '%j' is not "
"compatible with ISO year directive '%G'. "
"Use '%Y' instead.")
elif week_of_year is None and iso_week is not None:
if weekday is None:
raise ValueError("ISO week directive '%V' must be used with "
"the ISO year directive '%G' and a weekday "
"directive ('%A', '%a', '%w', or '%u').")
else:
raise ValueError("ISO week directive '%V' is incompatible with "
"the year directive '%Y'. Use the ISO year '%G' "
"instead.")
leap_year_fix = False
if year is None and month == 2 and day == 29:
year = 1904 # 1904 is first leap year of 20th century
leap_year_fix = True
elif year is None:
year = 1900
# If we know the week of the year and what day of that week, we can figure
# out the Julian day of the year.
if julian is None and weekday is not None:
if week_of_year is not None:
week_starts_Mon = True if week_of_year_start == 0 else False
julian = _calc_julian_from_U_or_W(year, week_of_year, weekday,
week_starts_Mon)
elif iso_year is not None and iso_week is not None:
year, julian = _calc_julian_from_V(iso_year, iso_week, weekday + 1)
if julian is None:
# Cannot pre-calculate datetime_date() since can change in Julian
# calculation and thus could have different value for the day of
# the week calculation.
# Need to add 1 to result since first day of the year is 1, not 0.
julian = datetime_date(year, month, day).toordinal() - \
datetime_date(year, 1, 1).toordinal() + 1
else: # Assume that if they bothered to include Julian day (or if it was
# calculated above with year/week/weekday) it will be accurate.
datetime_result = datetime_date.fromordinal(
(julian - 1) +
datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday is None:
weekday = datetime_date(year, month, day).weekday()
# Add timezone info
tzname = found_dict.get("Z")
if tzoffset is not None:
gmtoff = tzoffset * 60
else:
gmtoff = None
if leap_year_fix:
# the caller didn't supply a year but asked for Feb 29th. We couldn't
# use the default of 1900 for computations. We set it back to ensure
# that February 29th is smaller than March 1st.
year = 1900
return (year, month, day,
hour, minute, second,
weekday, julian, tz, tzname, gmtoff), fraction
def strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
"""Return a time struct based on the input string 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:
raise ValueError("time data did not match format: data=%s fmt=%s" %
(data_string, format))
if len(data_string) != found.end():
raise ValueError("unconverted data remains: %s" %
data_string[found.end():])
year = 1900
month = day = 1
hour = minute = second = 0
tz = -1
# weekday and julian defaulted to -1 so as to signal need to calculate values
weekday = julian = -1
found_dict = found.groupdict()
for group_key in found_dict.keys():
if group_key == 'y':
year = int(found_dict['y'])
# Open Group specification for strptime() states that a %y
#value in the range of [00, 68] is in the century 2000, while
#[69,99] is in the century 1900
if year <= 68:
year += 2000
else:
year += 1900
elif group_key == 'Y':
year = int(found_dict['Y'])
elif group_key == 'm':
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'])
elif group_key == 'H':
hour = int(found_dict['H'])
elif group_key == 'I':
hour = int(found_dict['I'])
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.
# 12 midnight == 12 AM == hour 0
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.
# 12 noon == 12 PM == hour 12
if hour != 12:
hour += 12
elif group_key == 'M':
minute = int(found_dict['M'])
elif group_key == 'S':
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'])
if weekday == 0:
weekday = 6
else:
weekday -= 1
elif group_key == 'j':
julian = int(found_dict['j'])
elif group_key == 'Z':
# Since -1 is default value only need to worry about setting tz if
# it can be something other than -1.
found_zone = found_dict['Z'].lower()
for value, tz_values in enumerate(locale_time.timezone):
if found_zone in tz_values:
# Deal with bad locale setup where timezone names are the
# same and yet time.daylight is true; too ambiguous to
# be able to tell what timezone has daylight savings
if time.tzname[0] == time.tzname[1] and \
time.daylight:
break
else:
tz = value
break
# Cannot pre-calculate datetime_date() since can change in Julian
#calculation and thus could have different value for the day of the week
#calculation
if datetime_date:
if julian == -1:
# Need to add 1 to result since first day of the year is 1, not 0.
julian = datetime_date(year, month, day).toordinal() - \
datetime_date(year, 1, 1).toordinal() + 1
else: # Assume that if they bothered to include Julian day it will
#be accurate
datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday == -1:
weekday = datetime_date(year, month, day).weekday()
return (year, month, day, hour, minute, second, weekday, julian, tz)
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 _locale_cache
global _regex_cache
locale_time = _locale_cache.locale_time
# If the language changes, caches are invalidated, so clear them
if locale_time.lang != _getlang():
_locale_cache = TimeRE()
_regex_cache.clear()
format_regex = _regex_cache.get(format)
if not format_regex:
# Limit regex cache size to prevent major bloating of the module;
# The value 5 is arbitrary
if len(_regex_cache) > 5:
_regex_cache.clear()
format_regex = _locale_cache.compile(format)
_regex_cache[format] = format_regex
found = format_regex.match(data_string)
if not found:
raise ValueError("time data did not match format: data=%s fmt=%s" %
(data_string, format))
if len(data_string) != found.end():
raise ValueError("unconverted data remains: %s" %
data_string[found.end():])
year = 1900
month = day = 1
hour = minute = second = 0
tz = -1
week_of_year = -1
week_of_year_start = -1
# weekday and julian defaulted to -1 so as to signal need to calculate values
weekday = julian = -1
found_dict = found.groupdict()
for group_key in found_dict.iterkeys():
if group_key == 'y':
year = int(found_dict['y'])
# Open Group specification for strptime() states that a %y
#value in the range of [00, 68] is in the century 2000, while
#[69,99] is in the century 1900
if year <= 68:
year += 2000
else:
year += 1900
elif group_key == 'Y':
year = int(found_dict['Y'])
elif group_key == 'm':
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'])
elif group_key == 'H':
hour = int(found_dict['H'])
elif group_key == 'I':
hour = int(found_dict['I'])
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.
# 12 midnight == 12 AM == hour 0
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.
# 12 noon == 12 PM == hour 12
if hour != 12:
hour += 12
elif group_key == 'M':
minute = int(found_dict['M'])
elif group_key == 'S':
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'])
if weekday == 0:
weekday = 6
else:
weekday -= 1
elif group_key == 'j':
julian = int(found_dict['j'])
elif group_key in ('U', 'W'):
week_of_year = int(found_dict[group_key])
if group_key == 'U':
# U starts week on Sunday
week_of_year_start = 6
else:
# W starts week on Monday
week_of_year_start = 0
elif group_key == 'Z':
# Since -1 is default value only need to worry about setting tz if
# it can be something other than -1.
found_zone = found_dict['Z'].lower()
if found_zone in ("utc", "gmt"):
tz = 0
elif time.tzname[0] == time.tzname[1] and \
time.daylight:
continue #Deals with bad locale setup where timezone info is
# the same; first found on FreeBSD 4.4.
elif locale_time.timezone[2].lower() == found_zone:
tz = 0
elif time.daylight and \
locale_time.timezone[3].lower() == found_zone:
tz = 1
# If we know the week of the year and what day of that week, we can figure
# out the Julian day of the year
# Calculations below assume 0 is a Monday
if julian == -1 and week_of_year != -1 and weekday != -1:
# Calculate how many days in week 0
first_weekday = datetime_date(year, 1, 1).weekday()
preceeding_days = 7 - first_weekday
if preceeding_days == 7:
preceeding_days = 0
# Adjust for U directive so that calculations are not dependent on
# directive used to figure out week of year
if weekday == 6 and week_of_year_start == 6:
week_of_year -= 1
# If a year starts and ends on a Monday but a week is specified to
# start on a Sunday we need to up the week to counter-balance the fact
# that with %W that first Monday starts week 1 while with %U that is
# week 0 and thus shifts everything by a week
if weekday == 0 and first_weekday == 0 and week_of_year_start == 6:
week_of_year += 1
# If in week 0, then just figure out how many days from Jan 1 to day of
# week specified, else calculate by multiplying week of year by 7,
# adding in days in week 0, and the number of days from Monday to the
# day of the week
if week_of_year == 0:
julian = 1 + weekday - first_weekday
else:
days_to_week = preceeding_days + (7 * (week_of_year - 1))
julian = 1 + days_to_week + weekday
# Cannot pre-calculate datetime_date() since can change in Julian
#calculation and thus could have different value for the day of the week
#calculation
if julian == -1:
# Need to add 1 to result since first day of the year is 1, not 0.
julian = datetime_date(year, month, day).toordinal() - \
datetime_date(year, 1, 1).toordinal() + 1
else: # Assume that if they bothered to include Julian day it will
#be accurate
datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday == -1:
weekday = datetime_date(year, month, day).weekday()
return time.struct_time((year, month, day,
hour, minute, second,
weekday, julian, tz))
def strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
"""Return a time struct based on the input string and the format string."""
global _TimeRE_cache, _regex_cache
_cache_lock.acquire()
try:
time_re = _TimeRE_cache
locale_time = time_re.locale_time
if _getlang() != locale_time.lang:
_TimeRE_cache = TimeRE()
_regex_cache = {}
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:
raise ValueError("time data did not match format: data=%s fmt=%s" %
(data_string, format))
if len(data_string) != found.end():
raise ValueError("unconverted data remains: %s" %
data_string[found.end():])
year = 1900
month = day = 1
hour = minute = second = 0
tz = -1
# Default to -1 to signify that values not known; not critical to have,
# though
week_of_year = -1
week_of_year_start = -1
# weekday and julian defaulted to -1 so as to signal need to calculate
# values
weekday = julian = -1
found_dict = found.groupdict()
for group_key in found_dict.iterkeys():
# Directives not explicitly handled below:
# c, x, X
# handled by making out of other directives
# U, W
# worthless without day of the week
if group_key == 'y':
year = int(found_dict['y'])
# Open Group specification for strptime() states that a %y
#value in the range of [00, 68] is in the century 2000, while
#[69,99] is in the century 1900
if year <= 68:
year += 2000
else:
year += 1900
elif group_key == 'Y':
year = int(found_dict['Y'])
elif group_key == 'm':
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'])
elif group_key == 'H':
hour = int(found_dict['H'])
elif group_key == 'I':
hour = int(found_dict['I'])
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.
# 12 midnight == 12 AM == hour 0
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.
# 12 noon == 12 PM == hour 12
if hour != 12:
hour += 12
elif group_key == 'M':
minute = int(found_dict['M'])
elif group_key == 'S':
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'])
if weekday == 0:
weekday = 6
else:
weekday -= 1
elif group_key == 'j':
julian = int(found_dict['j'])
elif group_key in ('U', 'W'):
week_of_year = int(found_dict[group_key])
if group_key == 'U':
# U starts week on Sunday
week_of_year_start = 6
else:
# W starts week on Monday
week_of_year_start = 0
elif group_key == 'Z':
# Since -1 is default value only need to worry about setting tz if
# it can be something other than -1.
found_zone = found_dict['Z'].lower()
for value, tz_values in enumerate(locale_time.timezone):
if found_zone in tz_values:
# Deal with bad locale setup where timezone names are the
# same and yet time.daylight is true; too ambiguous to
# be able to tell what timezone has daylight savings
if (time.tzname[0] == time.tzname[1] and
time.daylight and found_zone not in ("utc", "gmt")):
break
else:
tz = value
break
# If we know the week of the year and what day of that week, we can figure
# out the Julian day of the year
# Calculations below assume 0 is a Monday
if julian == -1 and week_of_year != -1 and weekday != -1:
# Calculate how many days in week 0
first_weekday = datetime_date(year, 1, 1).weekday()
preceeding_days = 7 - first_weekday
if preceeding_days == 7:
preceeding_days = 0
# Adjust for U directive so that calculations are not dependent on
# directive used to figure out week of year
if weekday == 6 and week_of_year_start == 6:
week_of_year -= 1
# If a year starts and ends on a Monday but a week is specified to
# start on a Sunday we need to up the week to counter-balance the fact
# that with %W that first Monday starts week 1 while with %U that is
# week 0 and thus shifts everything by a week
if weekday == 0 and first_weekday == 0 and week_of_year_start == 6:
week_of_year += 1
# If in week 0, then just figure out how many days from Jan 1 to day of
# week specified, else calculate by multiplying week of year by 7,
# adding in days in week 0, and the number of days from Monday to the
# day of the week
if week_of_year == 0:
julian = 1 + weekday - first_weekday
else:
days_to_week = preceeding_days + (7 * (week_of_year - 1))
julian = 1 + days_to_week + weekday
# Cannot pre-calculate datetime_date() since can change in Julian
#calculation and thus could have different value for the day of the week
#calculation
if julian == -1:
# Need to add 1 to result since first day of the year is 1, not 0.
julian = datetime_date(year, month, day).toordinal() - \
datetime_date(year, 1, 1).toordinal() + 1
else: # Assume that if they bothered to include Julian day it will
#be accurate
datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday == -1:
weekday = datetime_date(year, month, day).weekday()
return time.struct_time((year, month, day,
hour, minute, second,
weekday, julian, tz))
def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
"""Return a time struct based on the input string and the format string."""
global _TimeRE_cache, _regex_cache
with _cache_lock:
if _getlang() != _TimeRE_cache.locale_time.lang:
_TimeRE_cache = TimeRE()
_regex_cache.clear()
if len(_regex_cache) > _CACHE_MAX_SIZE:
_regex_cache.clear()
locale_time = _TimeRE_cache.locale_time
format_regex = _regex_cache.get(format)
if not format_regex:
try:
format_regex = _TimeRE_cache.compile(format)
# KeyError raised when a bad format is found; can be specified as
# \\, in which case it was a stray % but with a space after it
except KeyError as err:
bad_directive = err.args[0]
if bad_directive == "\\":
bad_directive = "%"
del err
raise ValueError("'%s' is a bad directive in format '%s'" %
(bad_directive, format))
# IndexError only occurs when the format string is "%"
except IndexError:
raise ValueError("stray %% in format '%s'" % format)
_regex_cache[format] = format_regex
found = format_regex.match(data_string)
if not found:
raise ValueError("time data %r does not match format %r" %
(data_string, format))
if len(data_string) != found.end():
raise ValueError("unconverted data remains: %s" %
data_string[found.end():])
year = 1900
month = day = 1
hour = minute = second = fraction = 0
tz = -1
# Default to -1 to signify that values not known; not critical to have,
# though
week_of_year = -1
week_of_year_start = -1
# weekday and julian defaulted to -1 so as to signal need to calculate
# values
weekday = julian = -1
found_dict = found.groupdict()
for group_key in found_dict.keys():
# Directives not explicitly handled below:
# c, x, X
# handled by making out of other directives
# U, W
# worthless without day of the week
if group_key == 'y':
year = int(found_dict['y'])
# Open Group specification for strptime() states that a %y
#value in the range of [00, 68] is in the century 2000, while
#[69,99] is in the century 1900
if year <= 68:
year += 2000
else:
year += 1900
elif group_key == 'Y':
year = int(found_dict['Y'])
elif group_key == 'm':
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'])
elif group_key == 'H':
hour = int(found_dict['H'])
elif group_key == 'I':
hour = int(found_dict['I'])
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.
# 12 midnight == 12 AM == hour 0
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.
# 12 noon == 12 PM == hour 12
if hour != 12:
hour += 12
elif group_key == 'M':
minute = int(found_dict['M'])
elif group_key == 'S':
second = int(found_dict['S'])
elif group_key == 'f':
s = found_dict['f']
# Pad to always return microseconds.
s += "0" * (6 - len(s))
fraction = int(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'])
if weekday == 0:
weekday = 6
else:
weekday -= 1
elif group_key == 'j':
julian = int(found_dict['j'])
elif group_key in ('U', 'W'):
week_of_year = int(found_dict[group_key])
if group_key == 'U':
# U starts week on Sunday.
week_of_year_start = 6
else:
# W starts week on Monday.
week_of_year_start = 0
elif group_key == 'Z':
# Since -1 is default value only need to worry about setting tz if
# it can be something other than -1.
found_zone = found_dict['Z'].lower()
for value, tz_values in enumerate(locale_time.timezone):
if found_zone in tz_values:
# Deal with bad locale setup where timezone names are the
# same and yet time.daylight is true; too ambiguous to
# be able to tell what timezone has daylight savings
if (time.tzname[0] == time.tzname[1] and
time.daylight and found_zone not in ("utc", "gmt")):
break
else:
tz = value
break
# If we know the week of the year and what day of that week, we can figure
# out the Julian day of the year.
if julian == -1 and week_of_year != -1 and weekday != -1:
week_starts_Mon = True if week_of_year_start == 0 else False
julian = _calc_julian_from_U_or_W(year, week_of_year, weekday,
week_starts_Mon)
# Cannot pre-calculate datetime_date() since can change in Julian
# calculation and thus could have different value for the day of the week
# calculation.
if julian == -1:
# Need to add 1 to result since first day of the year is 1, not 0.
julian = datetime_date(year, month, day).toordinal() - \
datetime_date(year, 1, 1).toordinal() + 1
else: # Assume that if they bothered to include Julian day it will
# be accurate.
datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday == -1:
weekday = datetime_date(year, month, day).weekday()
return (time.struct_time((year, month, day,
hour, minute, second,
weekday, julian, tz)), fraction)
def _strptime(data_string, format = '%a %b %d %H:%M:%S %Y'):
"""Return a time struct based on the input string and the format string."""
global _TimeRE_cache
global _regex_cache
with _cache_lock:
if _getlang() != _TimeRE_cache.locale_time.lang:
_TimeRE_cache = TimeRE()
_regex_cache.clear()
if len(_regex_cache) > _CACHE_MAX_SIZE:
_regex_cache.clear()
locale_time = _TimeRE_cache.locale_time
format_regex = _regex_cache.get(format)
if not format_regex:
try:
format_regex = _TimeRE_cache.compile(format)
except KeyError as err:
bad_directive = err.args[0]
if bad_directive == '\\':
bad_directive = '%'
del err
raise ValueError("'%s' is a bad directive in format '%s'" % (bad_directive, format))
except IndexError:
raise ValueError("stray %% in format '%s'" % format)
_regex_cache[format] = format_regex
found = format_regex.match(data_string)
if not found:
raise ValueError('time data %r does not match format %r' % (data_string, format))
if len(data_string) != found.end():
raise ValueError('unconverted data remains: %s' % data_string[found.end():])
year = None
month = day = 1
hour = minute = second = fraction = 0
tz = -1
week_of_year = -1
week_of_year_start = -1
weekday = julian = -1
found_dict = found.groupdict()
for group_key in found_dict.iterkeys():
if group_key == 'y':
year = int(found_dict['y'])
if year <= 68:
year += 2000
else:
year += 1900
elif group_key == 'Y':
year = int(found_dict['Y'])
elif group_key == 'm':
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'])
elif group_key == 'H':
hour = int(found_dict['H'])
elif group_key == 'I':
hour = int(found_dict['I'])
ampm = found_dict.get('p', '').lower()
if ampm in ('', locale_time.am_pm[0]):
if hour == 12:
hour = 0
elif ampm == locale_time.am_pm[1]:
if hour != 12:
hour += 12
elif group_key == 'M':
minute = int(found_dict['M'])
elif group_key == 'S':
second = int(found_dict['S'])
elif group_key == 'f':
s = found_dict['f']
s += '0' * (6 - len(s))
fraction = int(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'])
if weekday == 0:
weekday = 6
else:
weekday -= 1
elif group_key == 'j':
julian = int(found_dict['j'])
elif group_key in ('U', 'W'):
week_of_year = int(found_dict[group_key])
if group_key == 'U':
week_of_year_start = 6
else:
week_of_year_start = 0
elif group_key == 'Z':
found_zone = found_dict['Z'].lower()
for value, tz_values in enumerate(locale_time.timezone):
if found_zone in tz_values:
if time.tzname[0] == time.tzname[1] and time.daylight and found_zone not in ('utc', 'gmt'):
break
else:
tz = value
break
leap_year_fix = False
if year is None and month == 2 and day == 29:
year = 1904
leap_year_fix = True
elif year is None:
year = 1900
if julian == -1 and week_of_year != -1 and weekday != -1:
week_starts_Mon = True if week_of_year_start == 0 else False
julian = _calc_julian_from_U_or_W(year, week_of_year, weekday, week_starts_Mon)
if julian == -1:
julian = datetime_date(year, month, day).toordinal() - datetime_date(year, 1, 1).toordinal() + 1
else:
datetime_result = datetime_date.fromordinal(julian - 1 + datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday == -1:
weekday = datetime_date(year, month, day).weekday()
if leap_year_fix:
year = 1900
return (time.struct_time((year,
month,
day,
hour,
minute,
second,
weekday,
julian,
tz)), fraction)
def strptime(data_string, format="%a %b %d %H:%M:%S %Y",
reference=(1900, 1, 1, 0, 0, 0, -1, -1, -1),
complete_with_zeroes=True):
"""Return time struct and microseconds based on an input and format string
An optional ``reference`` is set by default to 1900-01-01 00:00:00.
``reference`` field is a tuple with:
(year, month, day, hour, minute, second, weekday, julian, tz), microseconds
Please note that weekday and julian will be ignored.
>>> from sact.epoch.strptime import strptime
>>> strptime('13:05', '%H:%M',
... reference=((2000, 1, 1, 0, 0, 30, -1, -1, -1), 5))
(time.struct_time(tm_year=2000, tm_mon=1, tm_mday=1, tm_hour=13, tm_min=5, tm_sec=0, tm_wday=5, tm_yday=1, tm_isdst=-1), 0)
Notice how all the left most values (the biggest weight value)
where used from the given reference, and how the left most value
(least weight values) was zeroed. The middle part is what was
parsed.
You can switch of the zeroing of the left most part:
>>> strptime('13:05', '%H:%M',
... reference=((2000, 1, 1, 0, 0, 0, -1, -1, -1), 5),
... complete_with_zeroes=False)
(time.struct_time(tm_year=2000, tm_mon=1, tm_mday=1, tm_hour=13, tm_min=5, tm_sec=0, tm_wday=5, tm_yday=1, tm_isdst=-1), 5)
"""
with _strptime._cache_lock:
if _strptime._getlang() != _strptime._TimeRE_cache.locale_time.lang:
_strptime._TimeRE_cache = TimeRE()
_strptime._regex_cache.clear()
if len(_strptime._regex_cache) > _strptime._CACHE_MAX_SIZE:
_strptime._regex_cache.clear()
locale_time = _strptime._TimeRE_cache.locale_time
format_regex = _strptime._regex_cache.get(format)
if not format_regex:
try:
format_regex = _strptime._TimeRE_cache.compile(format)
# KeyError raised when a bad format is found; can be specified as
# \\, in which case it was a stray % but with a space after it
except KeyError as err:
bad_directive = err.args[0]
if bad_directive == "\\":
bad_directive = "%"
del err
raise ValueError("'%s' is a bad directive in format '%s'" %
(bad_directive, format))
# IndexError only occurs when the format string is "%"
except IndexError:
raise ValueError("stray %% in format '%s'" % format)
_strptime._regex_cache[format] = format_regex
found = format_regex.match(data_string)
if not found:
raise ValueError("time data %r does not match format %r" %
(data_string, format))
if len(data_string) != found.end():
raise ValueError("unconverted data remains: %s" %
data_string[found.end():])
(year, month, day, hour, minute, second, weekday, julian, tz), \
fraction = reference
# Force calculation for julian and weekday
julian = -1
weekday = -1
# Default to -1 to signify that values not known; not critical to have,
# though
week_of_year = -1
week_of_year_start = -1
found_dict = found.groupdict()
for group_key in found_dict.keys():
# Directives not explicitly handled below:
# c, x, X
# handled by making out of other directives
# U, W
# worthless without day of the week
if group_key == 'y':
year = int(found_dict['y'])
# Open Group specification for strptime() states that a %y
#value in the range of [00, 68] is in the century 2000, while
#[69,99] is in the century 1900
if year <= 68:
year += 2000
else:
year += 1900
elif group_key == 'Y':
year = int(found_dict['Y'])
elif group_key == 'm':
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'])
elif group_key == 'H':
hour = int(found_dict['H'])
elif group_key == 'I':
hour = int(found_dict['I'])
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.
# 12 midnight == 12 AM == hour 0
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.
# 12 noon == 12 PM == hour 12
if hour != 12:
hour += 12
elif group_key == 'M':
minute = int(found_dict['M'])
elif group_key == 'S':
second = int(found_dict['S'])
elif group_key == 'f':
s = found_dict['f']
# Pad to always return microseconds.
s += "0" * (6 - len(s))
fraction = int(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'])
if weekday == 0:
weekday = 6
else:
weekday -= 1
elif group_key == 'j':
julian = int(found_dict['j'])
elif group_key in ('U', 'W'):
week_of_year = int(found_dict[group_key])
if group_key == 'U':
# U starts week on Sunday.
week_of_year_start = 6
else:
# W starts week on Monday.
week_of_year_start = 0
elif group_key == 'Z':
# Since -1 is default value only need to worry about setting tz if
# it can be something other than -1.
found_zone = found_dict['Z'].lower()
for value, tz_values in enumerate(locale_time.timezone):
if found_zone in tz_values:
# Deal with bad locale setup where timezone names are the
# same and yet time.daylight is true; too ambiguous to
# be able to tell what timezone has daylight savings
if (time.tzname[0] == time.tzname[1] and
time.daylight and found_zone not in ("utc", "gmt")):
break
else:
tz = value
break
# If we know the week of the year and what day of that week, we can figure
# out the Julian day of the year.
if julian == -1 and week_of_year != -1 and weekday != -1:
week_starts_Mon = True if week_of_year_start == 0 else False
julian = _strptime._calc_julian_from_U_or_W(year, week_of_year, weekday,
week_starts_Mon)
if complete_with_zeroes:
idxs = ("j", "Y", "mBb", "UW", "dAaw", "HI", "M", "S", "f")
specified = [idxs.index(gk)
for gk in [first(idxs, lambda key_group: k in key_group)
for k in found_dict.keys()]]
rightmost_specified = max(specified) if len(specified) else 0
base = (1900, 1, 1, 1, 0, 0, 0, 0)
values = year, month, week_of_year, day, hour, minute, second, fraction
year, month, week_of_year, day, hour, minute, second, fraction = \
values[:rightmost_specified] + base[rightmost_specified:]
# Cannot pre-calculate datetime_date() since can change in Julian
# calculation and thus could have different value for the day of the week
# calculation.
if julian == -1:
# Need to add 1 to result since first day of the year is 1, not 0.
julian = datetime_date(year, month, day).toordinal() - \
datetime_date(year, 1, 1).toordinal() + 1
else: # Assume that if they bothered to include Julian day it will
# be accurate.
datetime_result = datetime_date.fromordinal(
(julian - 1) + datetime_date(year, 1, 1).toordinal())
year = datetime_result.year
month = datetime_result.month
day = datetime_result.day
if weekday == -1:
weekday = datetime_date(year, month, day).weekday()
return (time.struct_time((year, month, day,
hour, minute, second,
weekday, julian, tz)), fraction)
