def parse_datetime(dtstr, default_timezone=TIMEZONE):
"""
Parse an ISO8601 datetime string.
The datetime may be delimited by ' ' or 'T'.
If no timezone is included, the ``default_timezone`` will be applied
:param dtstr: An ISO8601 formatted datetime string
:param default_timezone: A default timezone to apply if missing.
:rtype: datetime.datetime
:return: A timezone-aware datetime objet.
"""
# Allow use of space as separator
try:
if 'T' not in dtstr:
date = aniso8601.parse_datetime(dtstr, delimiter=' ')
else:
date = aniso8601.parse_datetime(dtstr)
except ValueError as e:
# The aniso8601 errors are not always great
raise ValueError("invalid iso8601 date (%s)" % (e,))
if not date.tzinfo:
# No timezone given, assume default_timezone
date = apply_timezone(date, tz=default_timezone)
return date
def get_latest_lease_maintenance_activity(self, cursor):
"""
Get a description of the most recently completed lease maintenance
activity.
:return LeaseMaintenanceActivity|None: If any lease maintenance has
completed, an object describing its results. Otherwise, None.
"""
cursor.execute(
"""
SELECT [started], [count], [finished]
FROM [lease-maintenance-spending]
WHERE [finished] IS NOT NULL
ORDER BY [finished] DESC
LIMIT 1
""", )
activity = cursor.fetchall()
if len(activity) == 0:
return None
[(started, count, finished)] = activity
return LeaseMaintenanceActivity(
parse_datetime(started, delimiter=u" "),
count,
parse_datetime(finished, delimiter=u" "),
)
def assertion_timestamp_checks(state, task_meta, **options):
try:
node_id = task_meta['node_id']
assertion = get_node_by_id(state, node_id)
issued_on = aniso8601.parse_datetime(assertion['issuedOn'])
except (IndexError, KeyError, ValueError,):
raise TaskPrerequisitesError(task_meta)
now = datetime.now(utc)
if issued_on > now:
return task_result(
False, "Assertion {} has issue date {} in the future.".format(node_id, issued_on))
if assertion.get('expires'):
expires = aniso8601.parse_datetime(assertion['expires'])
if expires < issued_on:
return task_result(
False, "Assertion {} expiration is prior to issue date.".format(node_id))
if expires < now :
return task_result(
False, "Assertion {} expired on {}".format(node_id, assertion['expires'])
)
return task_result(
True, "Assertion {} was issued and has not expired.".format(node_id))
def get_application_periods_by_periods(json_application_periods):
result = []
for app_periods in json_application_periods:
period = (parse_datetime(app_periods['begin']).replace(tzinfo=None),
parse_datetime(app_periods['end']).replace(tzinfo=None))
result.append(period)
return result
def build_api_model() -> Model:
"""
Returns a Flask-RESTX Api Model based on the sample dict returned by the trained model wrapper.
This will be used to validate input and automatically generate the Swagger prototype.
"""
fields_classes_map: Dict = {
"str": fields.String,
"int": fields.Integer,
"float": fields.Float,
"bool": fields.Boolean,
"datetime": fields.DateTime,
"date": fields.Date,
}
model_dict: Dict = {}
model_sample: Dict = trained_model_wrapper.sample()
if model_sample:
for key, value in model_sample.items():
fields_class: fields.Raw = fields_classes_map.get(
type(value).__name__, fields.String)
if type(value).__name__ == "str":
try:
parse_date(value)
fields_class = fields.Date
except ValueError:
pass
try:
parse_datetime(value)
fields_class = fields.DateTime
except ValueError:
pass
model_dict[key] = fields_class(example=value,
readonly=True,
required=True)
return api.model("input_vector", model_dict)
def parse_iec_xml(file_path):
"""Parses iec xml to Pandas DataFrame, meta on the same row wit valu and start/end time
columns = ["position", "timestamp_start_utc", "timestamp_end_utc", "value", "business_type", "from_domain", "to_domain", "line"]"""
tree = etree.parse(file_path)
periods = tree.findall('.//{*}Period')
data_list = []
for period in periods:
business_type = get_text(period, '../{*}businessType')
from_domain = get_text(period, '../{*}in_Domain.mRID')
to_domain = get_text(period, '../{*}out_Domain.mRID')
line = get_text(period, '../{*}connectingLine_RegisteredResource.mRID')
curve_type = get_text(period, '../{*}curveType')
resolution = aniso8601.parse_duration(
period.find('.//{*}resolution').text, relative=True)
start_time = aniso8601.parse_datetime(period.find('.//{*}start').text)
end_time = aniso8601.parse_datetime(period.find('.//{*}end').text)
points = period.findall('.//{*}Point')
for n, point in enumerate(points):
position = int(eval(point.find("{*}position").text))
value = float(eval(point.find("{*}quantity").text))
timestamp_start = (start_time + resolution *
(position - 1)).replace(tzinfo=None)
if curve_type == "A03":
# This curvetype expect values to be valid until next change or until the end of period
if n + 2 <= len(points):
next_position = int(
eval(points[n + 1].find("{*}position").text))
timestamp_end = (start_time + resolution *
(next_position - 1)).replace(tzinfo=None)
else:
timestamp_end = end_time.replace(tzinfo=None)
else:
# Else the value is on only valid during specified resolution
timestamp_end = timestamp_start + resolution
data_list.append((position, timestamp_start, timestamp_end, value,
business_type, from_domain, to_domain, line))
#dataframe.ix[timestamp_start.replace(tzinfo=None), "DATA"] = value
data_frame = pandas.DataFrame(data_list,
columns=[
"position", "timestamp_start_utc",
"timestamp_end_utc", "value",
"business_type", "from_domain",
"to_domain", "line"
])
#print data_frame #DEBUG
return data_frame
def post(self, id):
update = request.get_json()
if 'id' in update:
return {'error': 'Updating id is not allowed'}, \
HTTPStatus.BAD_REQUEST
bookmark = db.Bookmark.query \
.filter_by(id=id, user=current_user.id) \
.first()
if bookmark is None:
return {'error': 'Not found'}, HTTPStatus.NOT_FOUND
if 'url' in update:
bookmark.url = urldefrag(update['url']).url
if 'title' in update:
bookmark.title = update['title']
if 'timestamp' in update:
bookmark.timestamp = aniso8601.parse_datetime(update['timestamp'])
if 'read' in update:
if update['read']:
bookmark.read = aniso8601.parse_datetime(update['read'])
else:
bookmark.read = None
if 'tags' in update:
bookmark.tags = update['tags']
db.db.session.add(bookmark)
db.db.session.commit()
return bookmark.to_dict(), HTTPStatus.OK
def test_pattern_with_one_period_in_result():
start_date = parse_datetime("2015-02-01T06:52:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-02-01T23:52:00Z").replace(tzinfo=None)
weekly_pattern = "1111111"
time_slots = [{"begin": "07:45", "end": "09:30"}]
app_periods = get_application_periods_by_pattern(start_date, end_date, weekly_pattern, time_slots, 'Europe/Paris')
eq_(len(app_periods), 1)
def get_application_periods_by_periods(json_application_periods):
result = []
for app_periods in json_application_periods:
period = (
parse_datetime(app_periods['begin']).replace(tzinfo=None),
parse_datetime(app_periods['end']).replace(tzinfo=None)
)
result.append(period)
return result
def test_pattern_with_one_period_in_result():
start_date = parse_datetime("2015-02-01T06:52:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-02-01T23:52:00Z").replace(tzinfo=None)
weekly_pattern = "1111111"
time_slots = [{"begin": "07:45", "end": "09:30"}]
app_periods = get_application_periods_by_pattern(start_date, end_date,
weekly_pattern,
time_slots,
'Europe/Paris')
eq_(len(app_periods), 1)
def test_pattern_midnight_change_one_day():
date_format = "%Y-%m-%dT%H:%M:%SZ"
start_date = parse_datetime("2015-09-21T00:00:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-09-21T00:00:00Z").replace(tzinfo=None)
weekly_pattern = "1111111"
time_slots = [{"begin": "18:00", "end": "03:00"}]
app_periods = get_application_periods_by_pattern(start_date, end_date, weekly_pattern, time_slots, 'Europe/Paris')
eq_(len(app_periods), 1)
eq_(app_periods[0][0].strftime(date_format), "2015-09-21T16:00:00Z")
eq_(app_periods[0][1].strftime(date_format), "2015-09-22T01:00:00Z")
def test_pattern_midnight_change_to_winter_2_oclock():
date_format = "%Y-%m-%dT%H:%M:%SZ"
start_date = parse_datetime("2015-10-24T00:00:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-10-24T00:00:00Z").replace(tzinfo=None)
weekly_pattern = "1111111"
time_slots = [{"begin": "22:00", "end": "02:00"}]
app_periods = get_application_periods_by_pattern(start_date, end_date, weekly_pattern, time_slots, 'Europe/Paris')
eq_(len(app_periods), 1)
#Difference of one hour for begin and two hours for end between UTC and Europe/Paris
eq_(app_periods[0][0].strftime(date_format), "2015-10-24T20:00:00Z")
eq_(app_periods[0][1].strftime(date_format), "2015-10-25T01:00:00Z")
def parse_date(dtstr):
# Allow use of space as separator
if 'T' not in dtstr:
date = aniso8601.parse_datetime(dtstr, delimiter=' ')
else:
date = aniso8601.parse_datetime(dtstr)
if not date.tzinfo:
# No timezone, assume UTC?
date = apply_timezone(date, tz=pytz.UTC)
return date
def _validate_datetime(value):
try:
# aniso at least needs to think it can get a datetime from value
aniso8601.parse_datetime(value)
except Exception as e:
return False
# we also require tzinfo specification on our datetime strings
# NOTE -- does not catch minus-sign (non-ascii char) tzinfo delimiter
return (isinstance(value, six.string_types) and
(value[-1:]=='Z' or
bool(re.match(r'.*[+-](?:\d{4}|\d{2}|\d{2}:\d{2})$', value))))
def test_pattern_with_multi_periods_in_result():
date_format = "%Y-%m-%dT%H:%M:%SZ"
start_date = parse_datetime("2015-02-02T06:52:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-02-15T23:52:00Z").replace(tzinfo=None)
weekly_pattern = "1111111"
time_slots = [{"begin": "07:45", "end": "09:30"}]
app_periods = get_application_periods_by_pattern(start_date, end_date, weekly_pattern, time_slots, 'Europe/Paris')
eq_(len(app_periods), 14)
eq_(app_periods[0][0].strftime(date_format), "2015-02-02T06:45:00Z")
eq_(app_periods[0][1].strftime(date_format), "2015-02-02T08:30:00Z")
eq_(app_periods[13][0].strftime(date_format), "2015-02-15T06:45:00Z")
eq_(app_periods[13][1].strftime(date_format), "2015-02-15T08:30:00Z")
def state_from_row(state, row):
if state == u"pending":
return Pending(counter=row[3])
if state == u"double-spend":
return DoubleSpend(parse_datetime(row[0], delimiter=u" "), )
if state == u"redeemed":
return Redeemed(
parse_datetime(row[0], delimiter=u" "),
row[1],
row[2],
)
raise ValueError("Unknown voucher state {}".format(state))
def push_deneigement_8hr():
"""
Push messages to users when the snow removal period for their checkin location is exactly eight hours away
"""
CONFIG = create_app().config
db = PostgresWrapper(
"host='{PG_HOST}' port={PG_PORT} dbname={PG_DATABASE} "
"user={PG_USERNAME} password={PG_PASSWORD} ".format(**CONFIG))
# grab the appropriate checkins to send pushes to by slot ID
start = (datetime.datetime.utcnow().replace(tzinfo=pytz.utc).astimezone(
pytz.timezone('US/Eastern')) + datetime.timedelta(hours=8))
finish = start - datetime.timedelta(minutes=5)
res = db.query("""
SELECT DISTINCT x.start, u.lang, u.sns_id
FROM temporary_restrictions x
JOIN checkins c ON c.slot_id = ANY(x.slot_ids)
JOIN users u ON c.user_id = u.id
WHERE (x.meta = '2' OR x.meta = '3') AND x.active = true AND x.type = 'snow'
AND x.start > '{}' AND x.start < '{}'
AND c.active = true AND c.checkout_time IS NULL
AND u.push_on_temp = true AND u.sns_id IS NOT NULL
AND c.checkin_time > (NOW() - INTERVAL '14 DAYS')
""".format(finish.strftime('%Y-%m-%d %H:%M:%S'),
start.strftime('%Y-%m-%d %H:%M:%S')))
# group device IDs by start time, then send messages
lang_en, lang_fr = filter(lambda x: x[1] == 'en',
res), filter(lambda x: x[1] == 'fr', res)
data = {
"en": {x: []
for x in set([z[0].isoformat() for z in lang_en])},
"fr": {x: []
for x in set([z[0].isoformat() for z in lang_fr])}
}
for x in lang_en:
data["en"][x[0].isoformat()].append(x[2])
for x in lang_fr:
data["fr"][x[0].isoformat()].append(x[2])
for x in data["en"].keys():
dt = format_datetime(aniso8601.parse_datetime(x), u"h:mm a")
notifications.schedule_notifications(
data["en"][x],
u"❄️ Attention, snow removal starts in 8 hours, at {}!".format(dt))
for x in data["fr"].keys():
dt = format_datetime(aniso8601.parse_datetime(x),
u"H'h'mm",
locale='fr_FR')
notifications.schedule_notifications(
data["fr"][x],
u"❄️ Attention, le déneigement commence dans 8h, à {} !".format(
dt))
def push_deneigement_scheduled():
"""
Push messages to users when snow removal is initially scheduled for their checkin location.
"""
CONFIG = create_app().config
db = PostgresWrapper(
"host='{PG_HOST}' port={PG_PORT} dbname={PG_DATABASE} "
"user={PG_USERNAME} password={PG_PASSWORD} ".format(**CONFIG))
# grab the appropriate checkins to send pushes to by slot ID
start = datetime.datetime.now()
finish = start - datetime.timedelta(minutes=5)
res = db.query("""
SELECT DISTINCT x.start, u.lang, u.sns_id
FROM temporary_restrictions x
JOIN checkins c ON c.slot_id = ANY(x.slot_ids)
JOIN users u ON c.user_id = u.id
WHERE (x.meta = '2' OR x.meta = '3') AND x.active = true AND x.type = 'snow'
AND x.modified > '{}' AND x.modified < '{}'
AND c.active = true AND c.checkout_time IS NULL
AND u.push_on_temp = true AND u.sns_id IS NOT NULL
AND c.checkin_time > (NOW() - INTERVAL '14 DAYS')
""".format(finish.strftime('%Y-%m-%d %H:%M:%S'),
start.strftime('%Y-%m-%d %H:%M:%S')))
# group device IDs by start time, then send messages
lang_en, lang_fr = filter(lambda x: x[1] == 'en',
res), filter(lambda x: x[1] == 'fr', res)
data = {
"en": {x: []
for x in set([z[0].isoformat() for z in lang_en])},
"fr": {x: []
for x in set([z[0].isoformat() for z in lang_fr])}
}
for x in lang_en:
data["en"][x[0].isoformat()].append(x[2])
for x in lang_fr:
data["fr"][x[0].isoformat()].append(x[2])
for x in data["en"].keys():
dt = format_datetime(aniso8601.parse_datetime(x),
u"h:mm a 'on' EEEE d MMM")
notifications.schedule_notifications(
data["en"][x],
"❄️ Snow removal scheduled! Move your car before {}".format(dt))
for x in data["fr"].keys():
dt = format_datetime(aniso8601.parse_datetime(x),
u"H'h'mm', 'EEEE 'le 'd MMM",
locale='fr_FR')
notifications.schedule_notifications(
data["fr"][x],
"❄️ Déneigement annoncé ! Déplacez votre véhicule avant {}".format(
dt))
def post(self):
r = request.get_json()
if not r:
return {'error': 'payload is mandatory'}, HTTPStatus.BAD_REQUEST
if isinstance(r, dict):
r = [r]
bookmarks = []
now = datetime.datetime.utcnow().isoformat()
for entity in r:
if 'url' not in entity:
return {'error': 'url field is mandatory'}, \
HTTPStatus.BAD_REQUEST
url = urldefrag(entity['url']).url
if entity.get('read'):
read = aniso8601.parse_datetime(entity.get('read'))
else:
read = None
if entity.get('title'):
title = entity.get('title')
else:
title = entity.get('url')
tags = entity.get('tags')
notes = entity.get('notes')
bookmark = db.Bookmark(
user=current_user.id,
url=url,
title=title,
timestamp=aniso8601.parse_datetime(
entity.get('timestamp', now)),
read=read,
tags=tags,
notes=notes)
db.db.session.add(bookmark)
db.db.session.commit()
bookmarks.append(bookmark)
q.enqueue(article.fetch_article, bookmark.id, url)
res = list(map(lambda x: x.to_dict(), bookmarks))
return res[0] if len(res) == 1 else res, HTTPStatus.CREATED
def parse_to_datetime(dtstr):
"""Converts a value from str to datetime if it matches a pattern
The string must be on the formatted as a date or datetime. Does not
localize the resulting datetime object.
"""
try:
if 'T' not in dtstr:
return aniso8601.parse_datetime(dtstr, delimiter=' ')
else:
return aniso8601.parse_datetime(dtstr)
except ValueError:
return datetime.datetime.strptime(dtstr, '%Y-%m-%d')
def test_pattern_midnight_change_one_day_one_oclock():
date_format = "%Y-%m-%dT%H:%M:%SZ"
start_date = parse_datetime("2015-09-21T00:00:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-09-21T00:00:00Z").replace(tzinfo=None)
weekly_pattern = "1111111"
time_slots = [{"begin": "18:00", "end": "01:00"}]
app_periods = get_application_periods_by_pattern(start_date, end_date,
weekly_pattern,
time_slots,
'Europe/Paris')
eq_(len(app_periods), 1)
eq_(app_periods[0][0].strftime(date_format), "2015-09-21T16:00:00Z")
eq_(app_periods[0][1].strftime(date_format), "2015-09-21T23:00:00Z")
def post(self, id):
update = request.get_json()
if 'id' in update:
return {'error': 'Updating id is not allowed'}, \
HTTPStatus.BAD_REQUEST
bookmark = db.Bookmark.query \
.filter_by(id=id, user=current_user.id) \
.first()
if bookmark is None:
return {'error': 'Not found'}, HTTPStatus.NOT_FOUND
if 'url' in update:
bookmark.url = filter_url(update['url'])
if 'title' in update:
bookmark.title = update['title']
if 'timestamp' in update:
bookmark.timestamp = aniso8601.parse_datetime(update['timestamp'])
if 'read' in update:
if update['read']:
bookmark.read = aniso8601.parse_datetime(update['read'])
else:
bookmark.read = None
if 'meta' in update:
bookmark.meta = update['meta'] if update['meta'] else None
if 'tags' in update:
bookmark.tags = update['tags']
if 'parent' in update:
parent_id = update['parent']
if parent_id is not None:
parent = db.Bookmark.query \
.filter_by(id=parent_id,
user=current_user.id) \
.first()
if parent is None:
return {'error': 'parent does not exist'}, \
HTTPStatus.BAD_REQUEST
if is_child(bookmark, parent):
return {'error': 'bookmark loops are not allowed'}, \
HTTPStatus.BAD_REQUEST
bookmark.parent_id = parent_id
db.db.session.add(bookmark)
db.db.session.commit()
return bookmark.to_dict(), HTTPStatus.OK
def test_pattern_midnight_change_to_summer():
date_format = "%Y-%m-%dT%H:%M:%SZ"
start_date = parse_datetime("2016-03-26T00:00:00Z").replace(tzinfo=None)
end_date = parse_datetime("2016-03-27T00:00:00Z").replace(tzinfo=None)
weekly_pattern = "1111111"
time_slots = [{"begin": "22:00", "end": "02:00"}]
app_periods = get_application_periods_by_pattern(start_date, end_date, weekly_pattern, time_slots, 'Europe/Paris')
eq_(len(app_periods), 2)
#Difference of two hours between UTC and Europe/Paris
eq_(app_periods[0][0].strftime(date_format), "2016-03-26T21:00:00Z")
eq_(app_periods[0][1].strftime(date_format), "2016-03-27T01:00:00Z")
#Difference of one hour between UTC and Europe/Paris
eq_(app_periods[1][0].strftime(date_format), "2016-03-27T20:00:00Z")
eq_(app_periods[1][1].strftime(date_format), "2016-03-28T00:00:00Z")
def test_pattern_midnight_change_to_winter_2_oclock():
date_format = "%Y-%m-%dT%H:%M:%SZ"
start_date = parse_datetime("2015-10-24T00:00:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-10-24T00:00:00Z").replace(tzinfo=None)
weekly_pattern = "1111111"
time_slots = [{"begin": "22:00", "end": "02:00"}]
app_periods = get_application_periods_by_pattern(start_date, end_date,
weekly_pattern,
time_slots,
'Europe/Paris')
eq_(len(app_periods), 1)
#Difference of one hour for begin and two hours for end between UTC and Europe/Paris
eq_(app_periods[0][0].strftime(date_format), "2015-10-24T20:00:00Z")
eq_(app_periods[0][1].strftime(date_format), "2015-10-25T01:00:00Z")
def test_solve_event():
assert event_domain.solve_event(
event_id='538745942',
affectation=1,
analyst_email='*****@*****.**',
date=parse_datetime('2019-12-09T05:00:00.000Z'))
event = event_domain.get_event('538745942')
assert event['historic_state'][-1]['state'] == 'SOLVED'
with pytest.raises(EventAlreadyClosed):
assert event_domain.solve_event(
event_id='538745942',
affectation=1,
analyst_email='*****@*****.**',
date=parse_datetime('2019-12-09T05:00:00.000Z'))
def test_get_utc_datetime_with_dst_transition_in_between_valid():
with chaos.app.app_context():
date_format = "%Y-%m-%dT%H:%M:%SZ"
#Before DST of end March difference is one hour
str_date_time = "2015-03-28T13:15:00Z"
date_time = parse_datetime(str_date_time).replace(tzinfo=None)
utc_date_time = chaos.utils.get_utc_datetime_by_zone(date_time, 'Europe/Paris')
eq_(utc_date_time.strftime(date_format), "2015-03-28T12:15:00Z")
#DST began on Sun 29-Mar-2015 at 02:00:00 A.M. when local clocks were set forward 1 hour
#After DST of end March difference is two hours
str_date_time = "2015-03-29T13:15:00Z"
date_time = parse_datetime(str_date_time).replace(tzinfo=None)
utc_date_time = chaos.utils.get_utc_datetime_by_zone(date_time, 'Europe/Paris')
eq_(utc_date_time.strftime(date_format), "2015-03-29T11:15:00Z")
def get_shares(self, **kwargs):
if kwargs.get("id"):
data = self.conn._get("/shared_files/{0}".format(kwargs["id"]),
params=kwargs)
else:
data = self.conn._get("/shared_files", params=kwargs)
if data.get("shared_file") and data["shared_file"]["expires_at"] \
and data["shared_file"]["expires_at"] != 0:
ex = data["shared_file"]["expires_at"]
data["shared_file"]["expires_at"] = aniso8601.parse_datetime(ex)
elif data.get("shared_files"):
for x in data.get("shared_files"):
if x["expires_at"] and x["expires_at"] != 0:
x["expires_at"] = aniso8601.parse_datetime(x["expires_at"])
return data.get("shared_file") or data.get("shared_files")
def test_pattern_midnight_change_several_days_with_last_day_valid_():
date_format = "%Y-%m-%dT%H:%M:%SZ"
start_date = parse_datetime("2015-09-22T00:00:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-09-24T00:00:00Z").replace(tzinfo=None)
weekly_pattern = "1110111"
time_slots = [{"begin": "18:00", "end": "03:00"}]
app_periods = get_application_periods_by_pattern(start_date, end_date,
weekly_pattern,
time_slots,
'Europe/Paris')
eq_(len(app_periods), 2)
eq_(app_periods[0][0].strftime(date_format), "2015-09-22T16:00:00Z")
eq_(app_periods[0][1].strftime(date_format), "2015-09-23T01:00:00Z")
eq_(app_periods[1][0].strftime(date_format), "2015-09-23T16:00:00Z")
eq_(app_periods[1][1].strftime(date_format), "2015-09-24T01:00:00Z")
def test_pattern_with_multi_periods_in_result():
date_format = "%Y-%m-%dT%H:%M:%SZ"
start_date = parse_datetime("2015-02-02T06:52:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-02-15T23:52:00Z").replace(tzinfo=None)
weekly_pattern = "1111111"
time_slots = [{"begin": "07:45", "end": "09:30"}]
app_periods = get_application_periods_by_pattern(start_date, end_date,
weekly_pattern,
time_slots,
'Europe/Paris')
eq_(len(app_periods), 14)
eq_(app_periods[0][0].strftime(date_format), "2015-02-02T06:45:00Z")
eq_(app_periods[0][1].strftime(date_format), "2015-02-02T08:30:00Z")
eq_(app_periods[13][0].strftime(date_format), "2015-02-15T06:45:00Z")
eq_(app_periods[13][1].strftime(date_format), "2015-02-15T08:30:00Z")
def get_shares(self, **kwargs):
if kwargs.get("id"):
data = self.conn._get("/shared_files/{0}".format(kwargs["id"]),
params=kwargs)
else:
data = self.conn._get("/shared_files", params=kwargs)
if data.get("shared_file") and data["shared_file"]["expires_at"] \
and data["shared_file"]["expires_at"] != 0:
ex = data["shared_file"]["expires_at"]
data["shared_file"]["expires_at"] = aniso8601.parse_datetime(ex)
elif data.get("shared_files"):
for x in data.get("shared_files"):
if x["expires_at"] and x["expires_at"] != 0:
x["expires_at"] = aniso8601.parse_datetime(x["expires_at"])
return data.get("shared_file") or data.get("shared_files")
def deserialize(self, payload):
value = payload.get(self.name, None)
if value is None and self.required:
raise ValueError('expected field %s to be present in payload' %
(self.name))
elif value is not None and not isinstance(value, string_types):
raise TypeError('expected field %s to be a string, but it is '
'%r: %r' % (self.name, type(value), value))
if value is None:
return None
value = aniso8601.parse_datetime(value)
if value.tzinfo is not None:
utc_offset = value.tzinfo.utcoffset(value)
dst = value.tzinfo.dst(value)
if (utc_offset is not None and
utc_offset != datetime.timedelta(seconds=0)) or \
(dst is not None and
dst != datetime.timedelta(seconds=0)):
raise ValueError('expected date/time to be UTC based')
value = value.replace(tzinfo=None)
return value
def _make_datetime(value):
"""Helper function for `make_datetime()`.
Tries to convert the given value to a
:class:`datetime.datetime`. But, unlike make_datetime(), if no
timezone is given, makes a naive `datetime.datetime`.
Strings will be parsed as ISO 8601 timestamps.
If a number is provided, it will be interpreted as a UNIX
timestamp, which by definition is UTC.
If a `dict` is provided, does `datetime.datetime(**value)`.
If a `tuple` or a `list` is provided, does
`datetime.datetime(*value)`. Uses the timezone in the tuple or
list if provided.
:param value: something to convert
:type value: str | unicode | float | int | :class:`datetime.datetime` | dict | list | tuple
:return: the value after conversion
:rtype: :class:`datetime.datetime`
:raises: ValueError | TypeError
"""
if isinstance(value, str):
try:
return aniso8601.parse_datetime(value)
except Exception as e:
raise ValueError(
f"Conversion to datetime.datetime failed. Could not "
f"parse the given string as an ISO 8601 timestamp: "
f"{repr(value)}\n\n"
f"{repr(e)}")
try:
if isinstance(value, datetime.datetime):
return value
elif isinstance(value, dict):
tzinfo = value.pop('tzinfo', None)
if tzinfo:
return tzinfo.localize(datetime.datetime(**value))
else:
return datetime.datetime(**value)
# struct_time does not preserve millisecond accuracy per
# TinCan spec, so this is disabled to discourage its use.
# elif isinstance(value, struct_time):
# posix = mktime(value)
# return datetime.datetime.utcfromtimestamp(posix).replace(tzinfo=utc)
elif isinstance(value, (tuple, list)):
return tuple_to_datetime(value)
else:
return datetime.datetime.utcfromtimestamp(value).replace(
tzinfo=utc)
except Exception as e:
msg = (
f"Could not convert the given value of type '{value.__class__.__name__}' to a "
f"datetime.datetime: {repr(value)}\n\n"
f"{repr(e)}")
raise TypeError(msg) if isinstance(e, TypeError) else ValueError(msg)
def deserialize(self, payload):
value = payload.get(self.name, None)
if value is None and self.required:
raise ValueError('expected field %s to be present in payload' %
(self.name))
elif value is not None and not isinstance(value, string_types):
raise TypeError('expected field %s to be a string, but it is '
'%r: %r' % (self.name, type(value), value))
if value is None:
return None
value = aniso8601.parse_datetime(value)
if value.tzinfo is not None:
utc_offset = value.tzinfo.utcoffset(value)
dst = value.tzinfo.dst(value)
if (utc_offset is not None and
utc_offset != datetime.timedelta(seconds=0)) or \
(dst is not None and
dst != datetime.timedelta(seconds=0)):
raise ValueError('expected date/time to be UTC based')
value = value.replace(tzinfo=None)
return value
def test_update_with_ts(self):
id = clientid
self.session.get_client_by_id.return_value = deepcopy(retrieved_gk_client)
self.session.insert_client = mock.MagicMock()
attrs = {'created': '2000-01-01T00:00:00+01:00'}
res = self.controller.update(id, attrs, retrieved_user, [])
assert res['created'] == parse_datetime(date_created)
def test_get_utc_datetime_valid():
with chaos.app.app_context():
date_format = "%Y-%m-%dT%H:%M:%SZ"
str_date_time = "2015-04-10T13:15:00Z"
date_time = parse_datetime(str_date_time).replace(tzinfo=None)
utc_date_time = chaos.utils.get_utc_datetime_by_zone(date_time, 'Europe/Paris')
eq_(utc_date_time.strftime(date_format), "2015-04-10T11:15:00Z")
def from_row(cls, row):
def state_from_row(state, row):
if state == u"pending":
return Pending(counter=row[3])
if state == u"double-spend":
return DoubleSpend(parse_datetime(row[0], delimiter=u" "), )
if state == u"redeemed":
return Redeemed(
parse_datetime(row[0], delimiter=u" "),
row[1],
row[2],
)
raise ValueError("Unknown voucher state {}".format(state))
number, created, expected_tokens, state = row[:4]
return cls(
number=number,
expected_tokens=expected_tokens,
# All Python datetime-based date/time libraries fail to handle
# leap seconds. This parse call might raise an exception of the
# value represents a leap second. However, since we also use
# Python to generate the data in the first place, it should never
# represent a leap second... I hope.
created=parse_datetime(created, delimiter=u" "),
state=state_from_row(state, row[4:]),
)
def test_pattern_midnight_change_several_days_with_last_day_valid():
date_format = "%Y-%m-%dT%H:%M:%SZ"
start_date = parse_datetime("2015-09-21T00:00:00Z").replace(tzinfo=None)
end_date = parse_datetime("2015-09-26T00:00:00Z").replace(tzinfo=None)
weekly_pattern = "1101010"
time_slots = [{"begin": "18:00", "end": "03:00"}]
app_periods = get_application_periods_by_pattern(start_date, end_date, weekly_pattern, time_slots, 'Europe/Paris')
eq_(len(app_periods), 4)
eq_(app_periods[0][0].strftime(date_format), "2015-09-21T16:00:00Z")
eq_(app_periods[0][1].strftime(date_format), "2015-09-22T01:00:00Z")
eq_(app_periods[1][0].strftime(date_format), "2015-09-22T16:00:00Z")
eq_(app_periods[1][1].strftime(date_format), "2015-09-23T01:00:00Z")
eq_(app_periods[2][0].strftime(date_format), "2015-09-24T16:00:00Z")
eq_(app_periods[2][1].strftime(date_format), "2015-09-25T01:00:00Z")
eq_(app_periods[3][0].strftime(date_format), "2015-09-26T16:00:00Z")
eq_(app_periods[3][1].strftime(date_format), "2015-09-27T01:00:00Z")
def _parse_datetime(value):
try:
return aniso8601.parse_datetime(value)
except ValueError:
return aniso8601.parse_date(value)
return None
def _get_passages(self, xml, route_point):
ns = {'siri': 'http://www.siri.org.uk/siri'}
try:
root = et.fromstring(xml)
except et.ParseError as e:
logging.getLogger(__name__).exception("invalid xml")
raise RealtimeProxyError('invalid xml')
stop = route_point.fetch_stop_id(self.object_id_tag)
line = route_point.fetch_line_id(self.object_id_tag)
route = route_point.fetch_route_id(self.object_id_tag)
next_passages = []
for visit in root.findall('.//siri:MonitoredStopVisit', ns):
cur_stop = visit.find('.//siri:StopPointRef', ns).text
if stop != cur_stop:
continue
cur_line = visit.find('.//siri:LineRef', ns).text
if line != cur_line:
continue
cur_route = visit.find('.//siri:DirectionName', ns).text
if route != cur_route:
continue
cur_destination = visit.find('.//siri:DestinationName', ns).text
cur_dt = visit.find('.//siri:ExpectedDepartureTime', ns).text
cur_dt = aniso8601.parse_datetime(cur_dt)
next_passages.append(RealTimePassage(cur_dt, cur_destination))
return next_passages
def recache_repo(cacheing_session, cache, name):
api_r = cacheing_session.get("https://api.github.com/repos/{0}/{1}/commits".format(*name.split("/", 1)))
try:
raw = api_r.json()
except ValueError:
print("warning: GitHub API returned invalid JSON for {0}.".format(name))
return []
pool = set(a["sha1"] for a in cache if a["name"] == name)
for co in raw[0:30]:
if co["sha"] in pool:
continue
repo_baseurl = "https://github.com/{0}".format(name)
DEFAULT_AUTHOR = {
"html_url": "",
"avatar_url": "assets/images/unknown_author.png",
"login": co["commit"]["author"]["name"]
}
if not co["author"]:
co["author"] = DEFAULT_AUTHOR
if not co["committer"]:
co["committer"] = DEFAULT_AUTHOR
dt = aniso8601.parse_datetime(co["commit"]["author"]["date"]).replace(tzinfo=None)
cache.append({
"sha1": co["sha"],
"author-page": co["author"]["html_url"],
"avatar-url": co["author"]["avatar_url"],
"author-name": co["author"]["login"],
"github": repo_baseurl,
"name": name,
"author-date": co["commit"]["author"]["date"],
"commit-message": co["commit"]["message"],
"committer-is-author": co["author"]["login"] == co["committer"]["login"],
"committer-name": co["committer"]["login"],
"_nsam-sortkey": time.mktime(dt.timetuple()) if sys.version_info.major == 3 else (dt - datetime.datetime(1970, 1, 1)).total_seconds()
})
def _get_passages(self, tree, ns, route_point):
stop = route_point.fetch_stop_id(self.object_id_tag)
line = route_point.fetch_line_id(self.object_id_tag)
route = route_point.fetch_route_id(self.object_id_tag)
next_passages = []
for visit in tree.findall('.//siri:MonitoredStopVisit', ns):
cur_stop = visit.find('.//siri:StopPointRef', ns).text
if stop != cur_stop:
continue
cur_line = visit.find('.//siri:LineRef', ns).text
if line != cur_line:
continue
cur_route = visit.find('.//siri:DirectionName', ns).text
if route != cur_route:
continue
# TODO? we should ignore MonitoredCall with a DepartureStatus set to "Cancelled"
cur_destination = visit.find('.//siri:DestinationName', ns).text
cur_dt = visit.find('.//siri:ExpectedDepartureTime', ns).text
# TODO? fallback on siri:AimedDepartureTime if there is no ExpectedDepartureTime
# In that case we may want to set realtime to False
cur_dt = aniso8601.parse_datetime(cur_dt)
next_passages.append(RealTimePassage(cur_dt, cur_destination))
return next_passages
def test_timestamp_parsing():
parser = LogParser()
parser.read(StringIO(INITIAL_GAME))
parser.flush()
assert parser.games[0].packets[0].ts == time(2, 59, 14, 608862)
# Test with an initial datetime
parser2 = LogParser()
parser2._current_date = datetime(2015, 1, 1)
parser2.read(StringIO(INITIAL_GAME))
parser2.flush()
assert parser2.games[0].packets[0].ts == datetime(2015, 1, 1, 2, 59, 14,
608862)
# Same test, with timezone
parser2 = LogParser()
parser2._current_date = parse_datetime("2015-01-01T02:58:00+0200")
parser2.read(StringIO(INITIAL_GAME))
parser2.flush()
ts = parser2.games[0].packets[0].ts
assert ts.year == 2015
assert ts.hour == 2
assert ts.second == 14
assert ts.tzinfo
assert ts.utcoffset() == timedelta(hours=2)
def apply_edition_date(title, submitted_at):
dt = aniso8601.parse_datetime(submitted_at)
title['edition_date'] = dt.strftime('%Y-%m-%d')
title['last_application'] = submitted_at
return title
def episodes(self, show_id):
r = requests.get(self._url_episodes.format(show_id=show_id))
if r.status_code != 200:
return
data = r.json()
episodes = []
i = 0
for episode in data:
if episode['season'] == 0:
continue
if episode['number'] == 0:
continue
i += 1
if episode['airstamp']:
episode['airstamp'] = aniso8601.parse_datetime(episode['airstamp'])
if episode['airstamp'].tzinfo:
episode['airstamp'] = episode['airstamp'].astimezone(tz.tzutc())
episodes.append({
'number': i,
'title': episode['name'],
'season': episode['season'],
'episode': episode['number'],
'air_date': episode['airstamp'].date().isoformat() if episode['airstamp'] else None,
'air_time': episode['airstamp'].time().isoformat() if episode['airstamp'] else None,
'description': None if not episode['summary'] else {
'text': re.sub('<[^>]*>', '', episode['summary']),
'title': 'TVmaze',
'url': episode['url'],
},
})
return episodes
def _alexa_request(self, verify=True):
raw_body = flask_request.data
alexa_request_payload = json.loads(raw_body)
if verify:
cert_url = flask_request.headers['Signaturecertchainurl']
signature = flask_request.headers['Signature']
# load certificate - this verifies a the certificate url and format under the hood
cert = verifier.load_certificate(cert_url)
# verify signature
verifier.verify_signature(cert, signature, raw_body)
# verify timestamp
timestamp = aniso8601.parse_datetime(alexa_request_payload['request']['timestamp'])
if not current_app.debug or self.ask_verify_timestamp_debug:
verifier.verify_timestamp(timestamp)
# verify application id
try:
application_id = alexa_request_payload['session']['application']['applicationId']
except KeyError:
application_id = alexa_request_payload['context'][
'System']['application']['applicationId']
if self.ask_application_id is not None:
verifier.verify_application_id(application_id, self.ask_application_id)
return alexa_request_payload
def get_filename_from_metadata(meta_data,
file_type="xml",
filename_mask=default_filename_mask):
"""Convert metadata to filename by using filename mask and file type"""
# Separators
file_type_separator = "."
meta_separator = "_"
entity_and_area_separator = "-"
# Remove Model. form dictionary as python string format can't use . in variable name
meta_data = {key.split(".")[1]: meta_data[key] for key in meta_data}
# DateTime fields from text to DateTime
DateTime_fields = ["scenarioTime", 'created']
for field in DateTime_fields:
meta_data[field] = aniso8601.parse_datetime(meta_data[field])
# Integers to integers
meta_data["version"] = int(meta_data["version"])
# Add metadata to file name string
file_name = filename_mask.format(**meta_data)
# Add file type to file name string
file_name = file_type_separator.join([file_name, file_type])
return file_name
def test_get_utc_datetime_with_dst_transition_in_between_valid():
with chaos.app.app_context():
date_format = "%Y-%m-%dT%H:%M:%SZ"
#Before DST of end March difference is one hour
str_date_time = "2015-03-28T13:15:00Z"
date_time = parse_datetime(str_date_time).replace(tzinfo=None)
utc_date_time = chaos.utils.get_utc_datetime_by_zone(
date_time, 'Europe/Paris')
eq_(utc_date_time.strftime(date_format), "2015-03-28T12:15:00Z")
#DST began on Sun 29-Mar-2015 at 02:00:00 A.M. when local clocks were set forward 1 hour
#After DST of end March difference is two hours
str_date_time = "2015-03-29T13:15:00Z"
date_time = parse_datetime(str_date_time).replace(tzinfo=None)
utc_date_time = chaos.utils.get_utc_datetime_by_zone(
date_time, 'Europe/Paris')
eq_(utc_date_time.strftime(date_format), "2015-03-29T11:15:00Z")
def test_timestamp_parsing():
parser = LogParser()
parser.read(StringIO(INITIAL_GAME))
parser.flush()
assert parser.games[0].packets[0].ts == time(2, 59, 14, 608862)
# Test with an initial datetime
parser2 = LogParser()
parser2._current_date = datetime(2015, 1, 1)
parser2.read(StringIO(INITIAL_GAME))
parser2.flush()
assert parser2.games[0].packets[0].ts == datetime(2015, 1, 1, 2, 59, 14, 608862)
# Same test, with timezone
parser2 = LogParser()
parser2._current_date = parse_datetime("2015-01-01T02:58:00+0200")
parser2.read(StringIO(INITIAL_GAME))
parser2.flush()
ts = parser2.games[0].packets[0].ts
assert ts.year == 2015
assert ts.hour == 2
assert ts.second == 14
assert ts.tzinfo
assert ts.utcoffset() == timedelta(hours=2)
def __call__(self, item, field, value):
if value:
setattr(
item,
self.attribute,
parse_datetime(value).replace(tzinfo=None)
)
else:
setattr(item, self.attribute, None)
def _to_python(self):
'''A :class:`datetime.datetime` object is returned.'''
# don't parse data that is already native
if isinstance(self.data, datetime.datetime):
return self.data
elif self.format is None:
# parse as iso8601
return aniso8601.parse_datetime(self.data)
else:
return datetime.datetime.strptime(self.data, self.format)
def datetime_from_ISO_string(ISO_string):
"""
An utility function to convert ISO 8601 formatted datetime string to pythonic datetime object.
Input: The ISO formatted string
Output: The pythonic datetime object, None is there is some error in conversion.
"""
try:
return aniso8601.parse_datetime(ISO_string)
except:
return None
def get_authorities(self, **kwargs):
"""
Get certificate authority metadata.
:param str id: (optional) if provided, filter by this cert ID
:returns: list of CertificateAuthority dicts
"""
if kwargs.get("id"):
data = self.conn._get("/authorities/{0}".format(kwargs["id"]),
params=kwargs)
else:
data = self.conn._get("/authorities", params=kwargs)
if data.get("authority"):
ex = data["authority"]["expiry"]
data["authority"]["expiry"] = aniso8601.parse_datetime(ex)
elif data.get("authorities"):
for x in data.get("authorities"):
x["expiry"] = aniso8601.parse_datetime(x["expiry"])
return data.get("authority") or data.get("authorities")
def test_validate_upload_date(): """ Verifies the upload date / match start validation algorithm. The match start is never supposed to be any later than the upload date, so if it is, the match start is set to the upload date -- but the timezone remains untouched. """ from aniso8601 import parse_datetime from hsreplaynet.games.processing import get_valid_match_start values = (( # MS greater than UD, same timezone, expecting UD "2016-01-01T10:00:00Z", # Match start "2016-01-01T01:01:01Z", # Upload date "2016-01-01T01:01:01Z", # Expected result ), ( # MS lesser than UD, expecting MS "2016-01-01T10:00:00+0200", "2016-01-01T10:00:00+0100", "2016-01-01T10:00:00+0200" ), ( # MS greater than UD, different timezone, expecting modified UD "2016-01-01T10:00:00+0300", "2016-01-01T10:00:00+0400", "2016-01-01T09:00:00+0300" ), ( # MS greater than UD, different timezone, expecting modified UD "2018-01-01T10:00:00-0500", "2016-01-01T10:00:00+0500", "2016-01-01T00:00:00-0500" )) for match_start, upload_date, expected in values: match_start = parse_datetime(match_start) upload_date = parse_datetime(upload_date) expected = parse_datetime(expected) ret = get_valid_match_start(match_start, upload_date) # assert expected.tzinfo == match_start.tzinfo assert ret.tzinfo == match_start.tzinfo assert ret == expected
def parse_datetime_iso8601(datetime):
"""Parse a string in ISO8601 format."""
if not datetime:
return None
try:
dt = parse_datetime(datetime)
except ValueError:
return None
else:
return dt
def _parse_interval(value):
"""Do some nasty try/except voodoo to get some sort of datetime
object(s) out of the string.
"""
try:
return sorted(aniso8601.parse_interval(value))
except ValueError:
try:
return aniso8601.parse_datetime(value), None
except ValueError:
return aniso8601.parse_date(value), None
def clean(self, data):
date_string = super(DateTimeField, self).clean(data)
try:
value = aniso8601.parse_datetime(date_string)
except (ValueError, NotImplementedError):
raise self.error('invalid_format')
if self.timezone_required and value.tzinfo is None:
raise self.error('no_timezone')
return value
def datetime_from_iso8601(datetime_str):
"""Turns an ISO8601 formatted date into a datetime object.
Example::
inputs.datetime_from_iso8601("2012-01-01T23:30:00+02:00")
:param datetime_str: The ISO8601-complying string to transform
:type datetime_str: str
:return: A datetime
"""
return aniso8601.parse_datetime(datetime_str)
def orders():
orders = CoinbaseWallet.get_json_data('orders')['orders']
orders_list = []
for x in orders:
x = x['order']
coins = int(x['total_btc']['cents'])/100000000.0
dt = parse_datetime(x['created_at']).utctimetuple()
ds = strftime("%a, %d %b %Y", dt)
ts = strftime("%H:%M:%S", dt)
if x['status'] == 'completed':
orders_list.append([x['id'], coins, ds, ts])
return orders_list
def parse_as_iso(string):
try:
return aniso8601.parse_datetime(string)
except Exception:
try:
return aniso8601.parse_date(string)
except Exception as err:
printf(
'Can\'t interpret "{}" as an ISO-8601 time: {}',
string, err,
file=sys.stderr,
)
sys.exit(1)
def get(self, **kwargs):
"""
Get backup metadata.
:param str id: (optional) if provided, filter by this backup ID
:param str time: (optional) if provided w/ID, filter by backup time
:returns: list of Backup dicts
"""
if kwargs.get("id") and kwargs.get("time"):
full_id = kwargs["id"] + "/" + kwargs["time"]
data = self.conn._get("/backups/{0}".format(full_id))
elif kwargs.get("id"):
data = self.conn._get("/backups/{0}".format(kwargs["id"]))
else:
data = self.conn._get("/backups")
if data.get("backup"):
t = data["backup"]["time"]
data["backup"]["time"] = aniso8601.parse_datetime(t)
elif data.get("backups"):
for x in data.get("backups"):
x["time"] = aniso8601.parse_datetime(x["time"])
return data.get("backup") or data.get("backups")
