def _append_segment(self, d, segment_start, inferred = False):
try:
index = self.segment_starts.index(t(d.hour, d.minute, d.second))
except ValueError:
index = self.segment_starts.index(segment_start) - 1
try:
current_segment = self.segment_starts[index]
except IndexError:
current_segment = self.segment_starts[len(self.segment_starts) - 1]
segment = {
'type': 'basal-rate-segment',
'delivered': self.schedule[current_segment],
'value': self.schedule[current_segment],
'deliveryType': 'scheduled',
'inferred': inferred,
'start': dt(d.year, d.month, d.day, d.hour, d.minute, d.second),
'end': dt(d.year, d.month, d.day, segment_start.hour, segment_start.minute, segment_start.second)
}
if segment_start == t(0,0,0):
segment['end'] = segment['end'] + td(days=1)
# print('Basal segment start', segment['start'].isoformat())
# print('Basal segment end', segment['end'].isoformat())
# print('Basal segment rate', segment['delivered'])
# print()
self.segments.append(segment);
def _get_middle_segments(self):
midnight = t(0,0,0)
index = self.segment_starts.index(self.end_initial)
segment_start = self.end_initial
d = self.endpoints[0]
end = self.endpoints[1]
start_datetime = dt(d.year, d.month, d.day, segment_start.hour, segment_start.minute, segment_start.second)
if segment_start == midnight:
start_datetime = start_datetime + td(days=1)
current_datetime = start_datetime
while current_datetime < end:
try:
next_segment_start = self.segment_starts[index + 1]
index += 1
except IndexError:
next_segment_start = midnight
index = 0
self._append_segment(current_datetime, next_segment_start)
start_datetime = current_datetime
difference = self._get_difference(next_segment_start, t(current_datetime.hour, current_datetime.minute, current_datetime.second))
current_datetime = current_datetime + difference
return start_datetime
def test_empty(self):
start = t(1999, 1, 1)
end = t(1999, 1, 31, 23, 59, 59, 999999)
try:
stat_dao.fill_leaveempty_calls(self.session, start, end)
except Exception:
self.fail('fill_simple_calls failed with no data')
def test_ymdt_named():
DT = dt.Frame(Y=[2021, 1965, 2003, 1901, 1999],
M=[10, 7, 4, 11, 8],
D=[19, 18, 29, 10, 21],
h=[7, 21, 22, 23, 19],
m=[37, 29, 0, 44, 0],
s=[19, 23, 0, 46, 27],
ns=[0, 0, 0, 123456000, 1000])
RES = DT[:,
ymdt(year=f.Y,
month=f.M,
day=f.D,
hour=f.h,
minute=f.m,
second=f.s,
nanosecond=f.ns)]
assert_equals(
RES,
dt.Frame([
t(2021, 10, 19, 7, 37, 19),
t(1965, 7, 18, 21, 29, 23),
t(2003, 4, 29, 22, 0, 0),
t(1901, 11, 10, 23, 44, 46, 123456),
t(1999, 8, 21, 19, 0, 27, 1)
]))
def _append_segment(self, d, segment_start):
try:
index = self.segment_starts.index(t(d.hour, d.minute, d.second))
except ValueError:
index = self.segment_starts.index(segment_start) - 1
try:
current_segment = self.segment_starts[index]
except IndexError:
current_segment = self.segment_starts[len(self.segment_starts) - 1]
start = dt(d.year, d.month, d.day, d.hour, d.minute, d.second)
end = dt(d.year, d.month, d.day, segment_start.hour, segment_start.minute, segment_start.second)
segment = {
'type': 'basal-rate-segment',
'delivered': self.schedule[current_segment],
'value': self.schedule[current_segment],
'deliveryType': 'scheduled',
'start': start,
'end': end,
'duration': end - start
}
if segment_start == t(0,0,0):
segment['end'] = segment['end'] + td(days=1)
self.segments.append(segment);
def _get_middle_segments(self):
midnight = t(0,0,0)
index = self.segment_starts.index(self.end_initial)
segment_start = self.end_initial
d = self.endpoints[0]['deviceTime']
end = self.endpoints[1]['deviceTime']
start_datetime = dt(d.year, d.month, d.day, segment_start.hour, segment_start.minute, segment_start.second)
if segment_start == midnight:
start_datetime = start_datetime + td(days=1)
current_datetime = start_datetime
while current_datetime < end:
try:
next_segment_start = self.segment_starts[index + 1]
index += 1
except IndexError:
next_segment_start = midnight
index = 0
self._append_segment(current_datetime, next_segment_start)
start_datetime = current_datetime
difference = self._get_difference(next_segment_start, t(current_datetime.hour, current_datetime.minute, current_datetime.second))
current_datetime = current_datetime + difference
return start_datetime
def setUp(self):
DAOTestCase.setUp(self)
self.start = t(2012, 07, 01)
self.end = t(2012, 07, 31, 23, 59, 59, 999999)
self.qname1, self.qid1 = self._insert_queue('q1')
self.qname2, self.qid2 = self._insert_queue('q2')
self.aname1, self.aid1 = self._insert_agent('a1')
self.aname2, self.aid2 = self._insert_agent('a2')
def test_with_specific_range(self):
start = t(2020, 1, 1)
end = t(2020, 1, 31, 23, 59, 59, 999999)
stat_dao.fill_simple_calls(self.session, start, end)
result = self.session.query(StatCallOnQueue).all()
assert_that(result, contains(has_properties(status='full')))
def setUp(self):
DAOTestCase.setUp(self)
self.start = t(2012, 7, 1, tzinfo=pytz.UTC)
self.end = t(2012, 7, 31, 23, 59, 59, 999999, tzinfo=pytz.UTC)
self.qname1, self.qid1 = self._insert_queue('q1')
self.qname2, self.qid2 = self._insert_queue('q2')
self.aname1, self.aid1 = self._insert_agent('a1')
self.aname2, self.aid2 = self._insert_agent('a2')
def test_with_specific_range(self):
start = t(2019, 1, 1)
end = t(2020, 1, 31, 23, 59, 59, 999999)
stat_dao.fill_leaveempty_calls(self.session, start, end)
result = self.session.query(StatCallOnQueue).all()
assert_that(result, contains(has_properties(callid=self.callid_found)))
def test_with_specific_timezone(self):
# Asia/Shanghai is +08
start = t(2020, 1, 1, 1, 0, 0, 0, tzinfo=pytz.timezone('Asia/Shanghai'))
end = t(2020, 1, 31, 23, 59, 59, 999999)
stat_dao.fill_leaveempty_calls(self.session, start, end)
result = self.session.query(StatCallOnQueue).all()
assert_that(result, contains(has_properties(callid=self.callid_found)))
def graph_from_timezones_normalized_filtered(self,
min_occurences: int) -> Graph:
raw = {}
for _, stacks in self._data.items():
for _, question in stacks.items():
questionTime = datetime.datetime.fromtimestamp(
question['creation_date'])
for tag in question['tags']:
if tag not in raw:
raw[tag] = {'USSA': 0, 'EUAF': 0, 'ASAU': 0}
if questionTime.time() <= t(hour=8, minute=0, second=0):
raw[tag]['USSA'] += 1
elif questionTime.time() > t(
hour=8, minute=0,
second=0) and questionTime.time() <= t(
hour=16, minute=0, second=0):
raw[tag]['EUAF'] += 1
else:
raw[tag]['ASAU'] += 1
prcnt = {
tag: {
tz: val * 100 // sum(tzs.values())
for tz, val in tzs.items() if val > 0
}
for tag, tzs in raw.items() if sum(tzs.values()) > min_occurences
}
graph = Graph()
for tag, timezones in prcnt.items():
for timezone, weight in timezones.items():
graph.add_edge(tag, timezone, weight=weight)
print('top 5 each')
top_ussa = []
top_euaf = []
top_asau = []
for tg, tzs in prcnt.items():
top_ussa.append((tg, tzs['USSA'], tzs))
top_euaf.append((tg, tzs['EUAF'], tzs))
top_asau.append((tg, tzs['ASAU'], tzs))
top_ussa.sort(key=lambda x: x[1], reverse=True)
top_euaf.sort(key=lambda x: x[1], reverse=True)
top_asau.sort(key=lambda x: x[1], reverse=True)
print('top ussa')
for i in top_ussa[:5]:
print(i)
print('top euaf')
for i in top_euaf[:5]:
print(i)
print('top asau')
for i in top_asau[:5]:
print(i)
return graph
def setUp(self):
DAOTestCase.setUp(self)
if not self._fn_created:
self._create_functions()
self.start = t(2012, 07, 01)
self.end = t(2012, 07, 31, 23, 59, 59, 999999)
self.qname1, self.qid1 = self._insert_queue('q1')
self.qname2, self.qid2 = self._insert_queue('q2')
self.aname1, self.aid1 = self._insert_agent('a1')
self.aname2, self.aid2 = self._insert_agent('a2')
def test_that_incomplete_calls_are_not_added(self):
self.add_me_all([self.enterqueue_event, self.connect_event])
stat_dao.fill_answered_calls(self.session, t(2014, 7, 3, 10, 0, 0), t(2014, 7, 3, 10, 59, 59, 999999))
count = self.session.query(
func.count(StatCallOnQueue.callid)
).filter(StatCallOnQueue.callid == self.callid).scalar()
assert_that(count, equal_to(0))
def test_day_of_week_with_time64():
DT = dt.Frame([
t(2001, 3, 15, 0, 0, 0),
t(2017, 11, 1, 23, 59, 59, 999999), None,
t(1970, 1, 1, 0, 0, 0, 1),
t(1969, 12, 31, 23, 59, 59, 999999),
t(1900, 12, 13, 0, 0, 0)
])
RES = DT[:, day_of_week(f[:])]
assert_equals(RES, dt.Frame([4, 3, None, 4, 3, 4]))
def test_that_incomplete_calls_are_not_added(self):
self.add_me_all([self.enterqueue_event, self.connect_event])
stat_dao.fill_answered_calls(self.session, t(2014, 7, 3, 10, 0, 0), t(2014, 7, 3, 10, 59, 59, 999999))
count = self.session.query(
func.count(StatCallOnQueue.callid)
).filter(StatCallOnQueue.callid == self.callid).scalar()
assert_that(count, equal_to(0))
def test_ymdt_nones():
DT = dt.Frame(A=[1, 2, 3, None, None, 4],
B=[1, 2, None, 3, None, 4],
C=[1, None, 2, 3, None, 4])
RES = DT[:, ymdt(2001, f.B, f.C, f.A, f.B, f.C)]
assert_equals(
RES,
dt.Frame([
t(2001, 1, 1, 1, 1, 1), None, None, None, None,
t(2001, 4, 4, 4, 4, 4)
]))
def __init__(self, **vars):
for k, v in vars.iteritems():
if k == "access_time" :
self.access_date = datetime(v.year, v.month, v.day, 0, 0, 0, 0)
self.access_time = t(v.hour, v.minute, v.second, v.microsecond)
elif k == "modified_time" :
self.modified_date = datetime(v.year, v.month, v.day, 0, 0, 0, 0)
self.modified_time = t(v.hour, v.minute, v.second, v.microsecond)
else:
setattr(self, k, v)
self.parsedurl = URL(self.url)
def _get_initial_segment(self):
d = self.endpoints[0]
beginning = t(d.hour, d.minute, d.second)
for i, start in enumerate(self.segment_starts):
if beginning < start:
self._append_segment(d, start)
return start
else:
self._append_segment(d, t(0, 0, 0))
return t(0, 0, 0)
def _get_initial_segment(self):
d = self.endpoints[0]['deviceTime']
beginning = t(d.hour, d.minute, d.second)
for i, start in enumerate(self.segment_starts):
if beginning < start:
self._append_segment(d, start, True)
return start
else:
self._append_segment(d, t(0,0,0), True)
return t(0,0,0)
def update():
print("Lets get some stocks!")
try:
while is_time_between(t(9, 30), t(16, 0)) is True:
for i in range(1):
update_stocks_dict(stocks)
print("\nSleeping zzz...")
time.sleep(20)
# time.sleep is in seconds. 300 = 5min, 600 = 10 min.
#If the trading day ends while it is asleep, it must finish the sleep period
#prior to terminating the script.
print("The trading day has ended.")
except KeyboardInterrupt:
print('\nProcess stopped by user.')
def verify(module):
verify_no_prohibited_calls(module.__file__)
assert hasattr(module,
wanted_name), f"no `{wanted_name}` defined in {module}"
r = getattr(module, wanted_name)
assert isinstance(r, Callable), f"`{wanted_name}` is not callable"
from datetime import date as d, timedelta as t
today = d.today()
tomorrow = today + t(days=1)
next_week = today + t(days=7)
assert tomorrow in r(today, next_week)
assert tuple(r(today, next_week)) == (
today,
today + t(days=1),
today + t(days=2),
today + t(days=3),
today + t(days=4),
today + t(days=5),
today + t(days=6),
)
def __init__(self, schedule, boluses, carbs):
self.boluses = boluses
self.carbs = carbs
self.endpoints = self._get_endpoints()
if schedule:
self.schedule = schedule
else:
self.schedule = {
t(0,0,0): 0.8,
t(2,0,0): 0.65,
t(4,0,0): 0.75,
t(5,0,0): 0.85,
t(6,0,0): 1.00,
t(9,0,0): 0.8,
t(15,0,0): 0.9,
t(20,0,0): 0.8
}
self.segment_starts = sorted([time for time in self.schedule.keys()])
self.segments = []
self.end_initial = self._get_initial_segment()
self.end_middle = self._get_middle_segments()
self._get_final_segment()
def fix_duration(segment):
dur = int(segment['duration'].total_seconds()*1000)
if dur < 0:
segment['duration'] = td(milliseconds=(86400000 + dur))
else:
segment['duration'] = td(milliseconds=dur)
return segment
self.segments = [fix_duration(s) for s in self.segments]
self._make_temp_segments()
def serialize(segment):
segment['normalEnd'] = (segment['deviceTime'] + segment['duration']).isoformat() + '.000Z'
segment['deviceTime'] = segment['deviceTime'].isoformat()
segment['duration'] = int(segment['duration'].total_seconds()*1000)
segment['id'] = str(uuid.uuid4())
try:
serialize(segment['suppressed'])
except KeyError:
pass
try:
del segment['used']
except KeyError:
pass
return segment
self.json = [serialize(s) for s in self.segments]
def test_year_month_day_with_time64():
DT = dt.Frame([
t(2001, 3, 15, 0, 0, 0),
t(2017, 11, 1, 23, 59, 59, 999999), None,
t(1970, 1, 1, 0, 0, 0, 1),
t(1969, 12, 31, 23, 59, 59, 999999),
t(1900, 12, 13, 0, 0, 0)
])
RES = DT[:, {"year": year(f[0]), "month": month(f[0]), "day": day(f[0])}]
assert_equals(
RES,
dt.Frame(year=[2001, 2017, None, 1970, 1969, 1900],
month=[3, 11, None, 1, 12, 12],
day=[15, 1, None, 1, 31, 13]))
def test_ymdt_with_different_types():
DT = dt.Frame(A=[2010, 2011, 2012] / dt.int32,
B=[3, 5, 7] / dt.int8,
C=[4, 1, 1] / dt.int64,
D=[12, 10, 3] / dt.int16,
E=[30, 50, 25] / dt.int32,
F=[0, 0, 0] / dt.int8)
RES = DT[:, ymdt(f.A, f.B, f.C, f.D, f.E, f.F)]
assert_equals(
RES,
dt.Frame([
t(2010, 3, 4, 12, 30, 0),
t(2011, 5, 1, 10, 50, 0),
t(2012, 7, 1, 3, 25, 0)
]))
def test_ymdt_with_date():
DT = dt.Frame(date=[d(2001, 3, 15),
d(2017, 11, 23),
d(1930, 5, 14), None],
hour=[12, 19, 2, 7],
min=[30, 40, 50, 20])
RES = DT[:,
ymdt(date=f.date, hour=f.hour, minute=f.min, second=f.min // 2)]
assert_equals(
RES,
dt.Frame([
t(2001, 3, 15, 12, 30, 15),
t(2017, 11, 23, 19, 40, 20),
t(1930, 5, 14, 2, 50, 25), None
]))
def formatSchedule(meetings):
"""
Reformat the way that a "time" is reported
:param avails: list of tuples. Each tuple is an available meeting.
:return c: list of tuples. Each tuple is an available meeting. The times are
now reported as a datetime.time object, rather than a minute.
"""
formatted_meetings = []
for meeting in meetings:
formatted_meetings.append(
(t(meeting[0]//60, meeting[0]%60), t(meeting[1]//60, meeting[1]%60))
)
return formatted_meetings
def test_hour_minute_second_normal():
DT = dt.Frame(T=[t(2001, 5, 17, 11, 24, 50),
t(2011, 11, 30, 17, 1, 29, 7623),
None,
t(2021, 8, 19, 5, 55, 34, 98078),
t(1960, 2, 11, 14, 21, 7, 123456)])
RES = DT[:, {"hour": hour(f.T),
"minute": minute(f.T),
"second": second(f.T),
"nanosecond": nanosecond(f.T)}]
assert_equals(RES,
dt.Frame(hour=[11, 17, None, 5, 14],
minute=[24, 1, None, 55, 21],
second=[50, 29, None, 34, 7],
nanosecond=[0, 7623000, None, 98078000, 123456000]))
def peakTime():
"""
Returns the peak time of web browser usage. Similar to the heatmap, although doesn't
do for each day of the week - sums up each hour and returns the highest.
"""
step = 1
init = datetime(1, 1, 1)
start_time = init.time()
until_time = None
highest = 0
timeperiod = None
while(start_time < t(24-step,0,0)):
start_time = init.time()
until_time = (init + timedelta(hours=step) - timedelta(milliseconds=1)).time()
q = session.query(Entry).filter(Entry.access_time >= start_time)\
.filter(Entry.access_time <= until_time).count()
if q > highest:
highest = q
timeperiod = start_time.strftime('%H:%M - ') + until_time.strftime('%H:%M')
init = init + timedelta(hours=step)
return timeperiod
def string_outofdate(obj, now=None):
if not now:
now = datetime.now(tzlocal())
if obj['timestamp'] + t(minutes=24 * 60) < now:
return (fg(3) + 'Warning: timestamp is out of date by ' +
tdtime(now - obj['timestamp']) + RESET)
return None
def get_route_timetable(self,
route_id,
route_number,
direction,
date="",
station_id=0):
if date == "":
date = d.today().strftime("%Y-%m-%d")
params = {
"sid": self.sid,
"mr_id": route_id,
"data": date,
"rl_racetype": direction,
"rc_kkp": "",
"st_id": station_id
}
timetable = self.__create_post("getRaspisanie", params)
timetable = self.__clear_keys(timetable)
for idx in range(len(timetable["stopList"])):
hours = timetable["stopList"][idx].pop("hours")
timetable["stopList"][idx]["times"] = []
for hour in hours:
for minute in hour["minutes"]:
timetable["stopList"][idx]["times"].append(
t(int(hour["hour"] if hour["hour"] < 24 else 0),
int(minute["minute"])))
return timetable
def _append_segment(self, d, segment_start):
try:
index = self.segment_starts.index(t(d.hour, d.minute, d.second))
except ValueError:
index = self.segment_starts.index(segment_start) - 1
try:
current_segment = self.segment_starts[index]
except IndexError:
current_segment = self.segment_starts[len(self.segment_starts) - 1]
start = dt(d.year, d.month, d.day, d.hour, d.minute, d.second)
end = dt(d.year, d.month, d.day, segment_start.hour,
segment_start.minute, segment_start.second)
segment = {
'type': 'basal',
'rate': self.schedule[current_segment],
'deliveryType': 'scheduled',
'deviceTime': start,
'duration': end - start
}
self.segments.append(segment)
def _get_final_segment(self):
# this is hack since I didn't do a great job on the while loop in _get_middle_segments
self.segments.pop()
d = self.endpoints[1]
self._append_segment(self.end_middle, t(d.hour, d.minute, d.second))
def _get_final_segment(self):
# this is hack since I didn't do a great job on the while loop in _get_middle_segments
self.segments.pop()
d = self.endpoints[1]['deviceTime']
self._append_segment(self.end_middle, t(d.hour, d.minute, d.second), True)
def setUp(self):
DAOTestCase.setUp(self)
self._create_functions()
self.callid = '1404377805.6457'
event = QueueLog(
time=t(2020, 1, 1, 0, 0, 0, tzinfo=pytz.UTC),
callid=self.callid,
queuename='found_queue',
event='FULL',
)
self.add_me(event)
event = QueueLog(
time=t(2020, 2, 1, tzinfo=pytz.UTC),
callid=self.callid,
queuename='ignored_queue',
event='CLOSED',
)
self.add_me(event)
def test_ymdt_unnamed():
DT = dt.Frame(Y=[2001, 2003, 2005, 2020, 1960],
M=[1, 5, 4, 11, 8],
D=[12, 18, 30, 1, 14],
h=[7, 14, 22, 23, 12],
m=[15, 30, 0, 59, 0],
s=[12, 23, 0, 59, 27],
ns=[0, 0, 0, 999999000, 123000])
RES = DT[:, ymdt(f.Y, f.M, f.D, f.h, f.m, f.s, f.ns)]
assert_equals(
RES,
dt.Frame([
t(2001, 1, 12, 7, 15, 12),
t(2003, 5, 18, 14, 30, 23),
t(2005, 4, 30, 22, 0, 0),
t(2020, 11, 1, 23, 59, 59, 999999),
t(1960, 8, 14, 12, 0, 27, 123)
]))
def date_header(i):
thisdate = weekstart + t(days=i)
datestr = dtime(thisdate)
dcolor = LGRAY
if thisdate == agendamaker.now.date():
datestr = f'> {datestr} <'
dcolor = WBOLD
datestr = '{:^{}}'.format(datestr, inner_width)
return dcolor + datestr + RESET
def graph_from_timezones(self) -> Graph:
graph = Graph()
# TIMEZONES: USSA: 0-=<8, EUAF:>8-<=16, ASAU:>16-<=23:59
for _, stacks in self._data.items():
for _, question in stacks.items():
tags = question['tags']
questionTime = datetime.datetime.fromtimestamp(
question['creation_date'])
for tag in tags:
if questionTime.time() <= t(hour=8, minute=0, second=0):
graph.add_edge('USSA', tag)
elif questionTime.time() > t(
hour=8, minute=0,
second=0) and questionTime.time() <= t(
hour=16, minute=0, second=0):
graph.add_edge('EUAF', tag)
else:
graph.add_edge('ASAU', tag)
return graph
def test_that_completed_calls_cannot_be_added_twice(self):
# Given the same time boundaries, a call should be added and deleted to avoid duplicate calls
# this test case shows an example with a call starting at 10 and ending at 11 that will only
# be generated at 11 but that will not be deleted at 11
begin, end = t(2014, 7, 3, 11, 0, 0), t(2014, 7, 3, 11, 59, 59, 999999)
self.add_me_all([self.enterqueue_event, self.connect_event, self.complete_agent_event])
stat_dao.fill_answered_calls(self.session, begin, end)
callids = stat_call_on_queue_dao.find_all_callid_between_date(self.session, begin, end)
stat_call_on_queue_dao.remove_callids(self.session, callids)
stat_dao.fill_answered_calls(self.session, begin, end)
count = self.session.query(
func.count(StatCallOnQueue.callid)
).filter(StatCallOnQueue.callid == self.callid).scalar()
assert_that(count, equal_to(1))
def convertTimes(times):
"""
Given a list of times stored as a fraction e.g. 15.5 is 3:30pm, returns a list
of Python times.
"""
results = []
for time in times:
seconds = round((time - int(time)) * 3600)
results.append(t(int(time),int(seconds/60), int(seconds - int(seconds/60) * 60)))
return results
def test_that_completed_calls_cannot_be_added_twice(self):
# Given the same time boundaries, a call should be added and deleted to avoid duplicate calls
# this test case shows an example with a call starting at 10 and ending at 11 that will only
# be generated at 11 but that will not be deleted at 11
begin, end = t(2014, 7, 3, 11, 0, 0), t(2014, 7, 3, 11, 59, 59, 999999)
self.add_me_all([self.enterqueue_event, self.connect_event, self.complete_agent_event])
stat_dao.fill_answered_calls(self.session, begin, end)
callids = stat_call_on_queue_dao.find_all_callid_between_date(self.session, begin, end)
stat_call_on_queue_dao.remove_callids(self.session, callids)
stat_dao.fill_answered_calls(self.session, begin, end)
count = self.session.query(
func.count(StatCallOnQueue.callid)
).filter(StatCallOnQueue.callid == self.callid).scalar()
assert_that(count, equal_to(1))
def __init__(self, cluster_dict, force, backtime, db, cur): self.stop = d.utcnow() - t(hours=backtime) self.alpha_store = dict() self.all_nums = dict() self.cluster_list = cluster_dict['cluster'] self.nid = cluster_dict['nid'] self.all_paths = cluster_dict['all_paths'] self.db = db self.cur = cur self.force = force self.backtime = backtime
def _get_difference(self, t1, t2):
d = dt.now() - td(days=30)
dt1 = dt(d.year, d.month, d.day, t1.hour, t1.minute, t1.second)
dt2 = dt(d.year, d.month, d.day, t2.hour, t2.minute, t2.second)
if t1 == t(0,0,0):
dt1 = dt1 + td(days=1)
return dt1 - dt2
def __init__(self, schedule, boluses, carbs):
self.boluses = boluses
self.carbs = carbs
self.endpoints = self._get_endpoints()
if schedule:
self.schedule = schedule
else:
self.schedule = {
t(0,0,0): 0.8,
t(2,0,0): 0.65,
t(4,0,0): 0.75,
t(5,0,0): 0.85,
t(6,0,0): 1.00,
t(9,0,0): 0.8,
t(15,0,0): 0.9,
t(20,0,0): 0.8
}
self.segment_starts = sorted([time for time in self.schedule.keys()])
self.segments = []
self.temp_segments = []
self.end_initial = self._get_initial_segment()
self.end_middle = self._get_middle_segments()
self._get_final_segment()
self.generate_temp_basals()
# more hackery because of my bad while loops /o\
self.temp_segments.pop()
self.json = [s for s in self.segments] + [s for s in self.temp_segments]
for segment in self.json:
segment['start'] = segment['start'].isoformat()
segment['end'] = segment['end'].isoformat()
segment['duration'] = abs(int(segment['duration'].total_seconds()*1000))
segment['id'] = str(uuid.uuid4())
def generateHeatMap():
"""
Returns heatmap things for the overview: the table headers, the heatmap
table and the highest and lowest values (used to calculate heatmap colour).
"""
headers = ['Mon', 'Tue','Wed','Thu','Fri','Sat','Sun']
rows = []
step = 1 # number of hours each row in table represents
init = datetime(1, 1, 1)
start_time = init.time()
until_time = None
highest = 0
lowest = 0
while(start_time < t((24-step),0,0)):
start_time = init.time()
until_time = (init + timedelta(hours=step) - timedelta(milliseconds=1)).time()
title = start_time.strftime('%H:%M - ') + until_time.strftime('%H:%M')
values = []
for weekday in [1,2,3,4,5,6,0]: # '%w' gives weekdays starting on sunday
q = session.query(Entry)\
.filter(func.strftime('%w', Entry.access_date) == str(weekday))\
.filter(Entry.access_time >= start_time)\
.filter(Entry.access_time <= until_time).count()
if q > highest:
highest = q
if q < lowest:
lowest = q
values.append(q)
rows.append((title, values))
init = init + timedelta(hours=step)
return headers, rows, highest, lowest
def runPath(self):
"""runs it all for all campaigns in cluster by opt in path"""
for path in self.all_paths:
tracker_date = d.utcnow()
print (path['campaign_id'], path['opt_in_id'])
temp_isLive = self.isLive(path['campaign_id'], path['opt_in_id'])
live = temp_isLive[0]
current_page = temp_isLive[1]
active = path['campaign_status']
if live == True or self.force == True:
web_alpha = self.isWebAlpha(path['campaign_id'], path['opt_in_id'])
last_page = self.binarySearch(current_page, path['campaign_id'], path['opt_in_id'])
page_param = last_page + 1
p_ret = 100
last_date = self.getSubs(page_param, p_ret, path['campaign_id'], path['opt_in_id'], web_alpha)
#double check last date by going one page down
if last_date == d(1970, 1, 1, 0, 0):
print ('double checking...')
dbl_chk_page = page_param - 1
last_date = self.getSubs(dbl_chk_page, p_ret, path['campaign_id'], path['opt_in_id'], web_alpha)
print (last_date)
if last_date < (d.utcnow() - t(weeks=4)) and self.force != True:
print ('not live anymore', path['campaign_id'], path['opt_in_id'])
q_notlive = """insert into user_processing.mobile_campaign_component (campaign_id, opt_in_id, last_date, last_page, active, live)
VALUES ({0},{1},'{2}',{3},'{4}','False') ON DUPLICATE KEY UPDATE last_date='{2}', last_page={3}, active='{4}', live='False'""".format(path['campaign_id'], path['opt_in_id'], d.strftime(last_date, '%Y-%m-%d %H:%M:%S'), last_page, path['campaign_status'])
self.cur.execute(q_notlive)
self.db.commit()
else:
ensure_count = 2
while tracker_date > self.stop and int(page_param) > 0:
ensure_count -= 1
#print path['campaign_id'], path['opt_in_id'], page_param, tracker_date
dt = self.getSubs(page_param, p_ret, path['campaign_id'], path['opt_in_id'], web_alpha)
tracker_date = dt
page_param = page_param - 1
def _append_segment(self, d, segment_start):
try:
index = self.segment_starts.index(t(d.hour, d.minute, d.second))
except ValueError:
index = self.segment_starts.index(segment_start) - 1
try:
current_segment = self.segment_starts[index]
except IndexError:
current_segment = self.segment_starts[len(self.segment_starts) - 1]
start = dt(d.year, d.month, d.day, d.hour, d.minute, d.second)
end = dt(d.year, d.month, d.day, segment_start.hour, segment_start.minute, segment_start.second)
segment = {
'type': 'basal',
'rate': self.schedule[current_segment],
'deliveryType': 'scheduled',
'deviceTime': start,
'duration': end - start
}
self.segments.append(segment);
INSERT IGNORE INTO users_and_activities.web_users
(uid, first_name, last_name, created, email, street1, city, state, zip,
birthdate, mobile, gender, race, income_level)
VALUES ({})
"""
conn_f = jc_user_process.conn()
db = conn_f[0]
cur = conn_f[1]
#get a place to start for mobile users.
q = "select round(count(*)/25) as start from users_and_activities.mobile_users"
cur.execute(q)
out = cur.fetchall()
#what datetime to go back until
stop = d.utcnow() - t(hours=int(sys.argv[1]))
un = config.mc_user
pw = config.mc_pw
#all profiles
url_1 = "https://secure.mcommons.com/api/profiles"
url_1_payload = { 'page':'3652'}
def insert_to_db_mobile(obj, db, cur):
values = []
for k in MOBILE_KEYS:
try:
obj[k] = obj[k].encode('utf-8', 'ignore')
except:
pass
if obj[k] is None or obj[k] == '':
obj = DateRange(dt(2000, 1, 5), dt(2000, 1, 10))
other = DateRange(dt(2000, 1, 5), dt(2000, 1, 10))
assert obj == other
def test_hash_is_consistent():
obj = DateRange(dt(2000, 1, 5), dt(2000, 1, 10))
other = DateRange(dt(2000, 1, 5), dt(2000, 1, 10))
assert hash(obj) == hash(other)
@pytest.mark.parametrize(
'start, end, other_start, other_end',
[
# the other date range just clips the start
(t(12, 10, 0), t(13, 10, 0), t(12, 0, 0), t(12, 5, 0)),
# the other date range just clips the end
(t(12, 10, 0), t(13, 10, 0), t(13, 15, 0), t(13, 20, 0)),
]
)
def test_date_ranges_near(start, end, other_start, other_end):
date = d(2000, 1, 5)
obj = DateRange(dt.combine(date, start), dt.combine(date, end))
other = DateRange(dt.combine(date, other_start), dt.combine(date, other_end))
obj.near_time = td(seconds=300)
assert obj.near(other)
@pytest.mark.parametrize(
'start, end, other_start, other_end',
[
def parse(self,item,i):
if 0 < i < 23 and i != 4:
try:
return float(item)
except ValueError:
pass
return item
def getIndex(self,day):
return (day.day-1)*24 + day.hour
def getDateTime(self,day):
"""Returns an hours data for a given datetime. Day must be a datetime object"""
return self.loadfile(day)[self.getIndex(day)]
def wrange(self,start,end,dt=datetime.timedelta(seconds=3600)):
"""Returns an iterator from start to end using step dt. start and end must
be datetime objects while dt is a timedelta"""
cur = start
curday = datetime.datetime(1,1,1)
while cur < end:
yield self.getDateTime(cur)
cur += dt
if __name__ == '__main__':
from datetime import datetime as t, timedelta as dt
d = wdatabase(5097,root="data")
for x in d.wrange(t(1953,1,1),t(1954,1,1),dt(days=1)):
print "%(date)15s: %(temp)6.2fC / %(weather)s"%x
