def test_mean(self):
mean_data = utils.mean([
31938,
106,
29817,
29992,
])
self.assertEqual(mean_data, 22963.25)
mean_data = utils.mean([
36271,
34577,
30658,
29401,
29655,
])
self.assertEqual(mean_data, 32112.4)
mean_data = utils.mean([
26136,
27895,
31253,
31759,
41026,
])
self.assertEqual(mean_data, 31613.8)
mean_data = utils.mean([])
self.assertEqual(mean_data, 0)
def test_mean(self):
"""
Test mean function
"""
self.assertEqual(utils.mean([]), 0)
self.assertEqual(utils.mean([1, 2, 3, 4, 5]), 3.0)
self.assertEqual(utils.mean([1000, 99999, 999999]), 366999.3333333333)
def test_mean(self):
'''
Test calculate arithmetic mean
'''
self.assertEqual(utils.mean([]), 0)
self.assertEqual(utils.mean([2345, 6789]), 4567)
self.assertEqual(utils.mean([999, 111, 555]), 555)
def test_mean(self):
"""
Test calculating arithmetic mean
"""
self.assertIsInstance(utils.mean([1, 2, 3]), float)
self.assertEqual(utils.mean([1, 2, 3]), 2)
self.assertEqual(utils.mean([-10, 10]), 0)
def test_mean(self):
mean_data = utils.mean([
31938,
106,
29817,
29992,
])
self.assertEqual(mean_data, 22963.25)
mean_data = utils.mean([
36271,
34577,
30658,
29401,
29655,
])
self.assertEqual(mean_data, 32112.4)
mean_data = utils.mean([
26136,
27895,
31253,
31759,
41026,
])
self.assertEqual(mean_data, 31613.8)
mean_data = utils.mean([])
self.assertEqual(mean_data, 0)
def test_mean(self):
"""
Test if mean function works correctly.
"""
self.assertEqual(utils.mean([1, 2, 3, 4]), 2.5)
self.assertEqual(utils.mean([1.11, 2.22, 3.33, 4.1234562]), 2.69586405)
self.assertEqual(utils.mean([]), 0)
def api_mean_start_end(user_id):
"""
Returns avg start and end time of the user.
"""
data = get_data().get(user_id)
if data is None:
log.debug('User %s not found!', user_id)
abort(404)
result = {'start': [], 'end': []}
for val in data.itervalues():
result['start'].append(
seconds_since_midnight(val['start'])
)
result['end'].append(
seconds_since_midnight(val['end'])
)
result = [
seconds_to_hour(mean(result['start'])),
seconds_to_hour(mean(result['end']))
]
return result
def test_mean(self):
"""
Test returning arithmetic mean or zero if empty.
Check if the result is correct.
"""
self.assertEqual(utils.mean([1, 39, 22, 2]), 16)
self.assertEqual(utils.mean([]), 0)
def test_mean(self):
"""
Test mean calculation
"""
self.assertEqual(utils.mean(range(1, 8)), 4)
self.assertAlmostEqual(utils.mean([30.3, 70.2, 1]), 33.8333333)
self.assertAlmostEqual(utils.mean([0.1, 0.2, 0.3]), 0.2)
def api_presence_start_end(user_id):
"""
Returns avg start and end time of the user.
"""
data = get_data().get(user_id)
if data is None:
log.debug('User %s not found!', user_id)
abort(404)
result = {x: {'start': [], 'end': []} for x in xrange(7)}
for date, val in data.iteritems():
result[date.weekday()]['start'].append(
seconds_since_midnight(val['start'])
)
result[date.weekday()]['end'].append(
seconds_since_midnight(val['end'])
)
result = [
(
calendar.day_abbr[weekday],
seconds_to_hour(mean(val['start'])),
seconds_to_hour(mean(val['end']))
)
for weekday, val in result.iteritems()
]
return result
def test_mean(self):
"""
Test calculates arithmetic mean.
"""
self.assertEqual(utils.mean([]), 0)
self.assertEqual(utils.mean([1, 2]), 1.5)
self.assertEqual(utils.mean([1.5, 2.8]), 2.15)
def test_mean(self):
"""Test calculation of arithmetic mean"""
self.assertEqual(0, utils.mean([]))
self.assertEqual(2, utils.mean([1, 2, 3]))
self.assertEqual(0, utils.mean([0, 0, 0]))
self.assertEqual(1.25, utils.mean([0, 1, 2, 2]))
self.assertAlmostEqual(0.1, utils.mean([0, 0.1, 0.2]))
def test_mean(self):
"""
Test calculating mean of list
"""
self.assertEqual(utils.mean([]), 0)
items = [34]
self.assertEqual(utils.mean(items), 34)
def test_mean(self):
"""
Test if mean function works correctly.
"""
self.assertEqual(utils.mean([1, 2, 3, 4]), 2.5)
self.assertEqual(utils.mean([1.11, 2.22, 3.33, 4.1234562]), 2.69586405)
self.assertEqual(utils.mean([]), 0)
def test_mean_incorrect_input(self):
"""
Test returning arithmetic mean or zero if empty.
Incorrect input type.
"""
with self.assertRaises(TypeError):
utils.mean('not a list')
def test_mean(self):
"""
Test mean method.
"""
self.assertEqual(utils.mean([22999, 22969]), 22984)
self.assertEqual(utils.mean([]), 0)
self.assertEqual(utils.mean([1]), 1)
def test_mean(self):
"""
Test arithmetic mean.
"""
result = utils.mean([1, 2, 3, 4, 4.5, 6.7])
self.assertAlmostEqual(result, 3.5333, places=4)
result = utils.mean([])
self.assertEqual(result, 0)
def test_mean(self):
"""
Count mean and assert it provides 3-point accuracy.
"""
self.assertEqual(utils.mean([]), 0)
self.assertAlmostEqual(utils.mean([1, 2]), 1.5, 3)
self.assertAlmostEqual(utils.mean([0]), 0.0, 3)
self.assertAlmostEqual(utils.mean([1, 2, 3, 4, 5]), 3.0, 3)
def test_mean(self):
"""
Test mean function
"""
strange_lst = [3, 4, 5, 6, 7, 8]
empty_lst = []
self.assertEqual(0, utils.mean(empty_lst))
self.assertEqual(utils.mean(strange_lst), 5.5)
def test_mean(self):
"""
Test of utils.mean
"""
self.assertEquals(utils.mean([5, 8, 7, 5, 7, 7]), 6.5)
self.assertEquals(utils.mean([]), 0)
self.assertEquals(utils.mean([8, 8, 8, -8, -16, 0]), 0)
def test_mean(self):
"""
Test calculation of arithmetic mean.
"""
self.assertEqual(2.0, utils.mean([1, 2, 3]))
self.assertEqual(2.6, utils.mean([1.5, 2.5, 3.8]))
self.assertEqual(1.0, utils.mean([0, 2]))
self.assertEqual(0, utils.mean([]))
def test_mean(self):
"""
Test mean function
"""
strange_lst = [3, 4, 5, 6, 7, 8]
empty_lst = []
self.assertEqual(0, utils.mean(empty_lst))
self.assertEqual(utils.mean(strange_lst), 5.5)
def test_mean(self):
"""
Test calculation of arithmetic mean.
"""
self.assertEqual(utils.mean([0]), 0)
self.assertEqual(utils.mean(range(1, 10)), 5.)
self.assertEqual(utils.mean(range(1, 5)), 2.5)
self.assertIsInstance(utils.mean([0]), float)
def test_mean(self):
"""
Test correct mean value.
"""
self.assertEqual(utils.mean([10, 20, 30]), 20)
self.assertAlmostEqual(utils.mean([10.12, 20.12, 30.12]), 20.12)
self.assertAlmostEqual(
utils.mean([10.1234567, 20.1234567, 30.1234567]), 20.1234567)
self.assertEqual(utils.mean([]), 0)
def test_mean(self):
"""
Test calculates arithmetic mean. Returns zero for empty lists.
"""
self.assertEqual(utils.mean([30927, 25197, 29931]), 28685.0)
self.assertEqual(utils.mean([0]), 0.0)
self.assertEqual(utils.mean([1337, .1337]), 668.56685)
self.assertEqual(
utils.mean([911.997, 14536.456456, 123123.5678]), 46190.673752
)
def test_mean(self):
"""
Test calculating arithmetic mean.
"""
data = utils.get_data()
weekdays = utils.group_by_weekday(data[10])
self.assertAlmostEqual(utils.mean(weekdays[0]), 29934)
self.assertEqual(utils.mean(weekdays[7]), 0)
self.assertEqual(utils.mean([]), 0)
self.assertEqual(utils.mean([0]), 0)
def test_mean_time(self):
"""
Test calculating arithmetic mean.
"""
items = [1, 2, 3]
self.assertEqual(utils.mean(items), 2.0)
items = [-1, -2, -3]
self.assertEqual(utils.mean(items), -2.0)
items = []
self.assertEqual(utils.mean(items), 0)
def test_mean(self):
"""
Test if mean is returned corretly
"""
self.assertEqual(utils.mean([0]), 0)
self.assertEqual(utils.mean([0, 0]), 0)
self.assertEqual(utils.mean([300, 400]), 350.0)
sample_data = [0, 30047, 24465, 23705, 0, 0, 0]
self.assertEqual(utils.mean(sample_data), 11173.857142857143)
def test_mean(self):
"""
Test correct mean value.
"""
self.assertEqual(utils.mean([10, 20, 30]), 20)
self.assertAlmostEqual(utils.mean([10.12, 20.12, 30.12]), 20.12)
self.assertAlmostEqual(
utils.mean([10.1234567, 20.1234567, 30.1234567]),
20.1234567
)
self.assertEqual(utils.mean([]), 0)
def test_mean_if_items(self):
"""
Test calculating mean from items.
"""
items = [1, 2, 3, 4, 5]
mean = utils.mean(items)
self.assertIsInstance(mean, float)
self.assertEqual(mean, 3)
items.append(9.7)
mean = utils.mean(items)
self.assertEqual(mean, 4.116666666666666)
def test_mean(self):
"""
Test calculating mean
"""
result = utils.mean([1, 2, 3, 4, 5])
self.assertEqual(result, 3)
result = utils.mean([1, 2, 3, 4])
self.assertEqual(result, 2.5)
result = utils.mean([])
self.assertEqual(result, 0)
def test_mean(self):
"""
Test calculating arithmetic mean.
"""
sample_data = [100, 50, 25, 1, 0]
result = utils.mean(sample_data)
self.assertEqual(result, 35.2)
self.assertIsInstance(result, float)
sample_data = []
result = utils.mean(sample_data)
self.assertEqual(result, 0)
self.assertIsInstance(result, int)
def presence_start_end_view(user_id):
"""
Returns mean arrival and departure time for each weekday.
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = weekday_start_stop_time(data[user_id])
result = [(calendar.day_abbr[weekday], mean(times[0]), mean(times[1]))
for weekday, times in weekdays.items()]
return result
def presence_start_end_view(user_id):
"""Returns mean start and end time of given user"""
data = get_data()
if user_id not in data:
log.debug('User {0} not found!'.format(user_id))
return []
weekdays = group_by_start_end(data[user_id])
result = [
(calendar.day_abbr[weekday], mean(times['start']), mean(times['end']))
for weekday, times in weekdays.items()]
return result
def test_mean(self):
"""
Test second_since_midnight.
"""
self.assertAlmostEqual(
utils.mean([12, 4, 1222, 1, 55, 23, 423, 1]), 217.625
)
self.assertEqual(
utils.mean([]), 0
)
self.assertAlmostEqual(
utils.mean([12, 2, 1, 5, 1]), 4.2
)
def test_mean(self):
"""
Test mean of list elements.
"""
sample_mean = utils.mean([])
self.assertEqual(sample_mean, 0)
sample_mean = utils.mean([6, 3, 0])
self.assertEqual(sample_mean, 3.0)
self.assertIsInstance(sample_mean, float)
sample_mean = utils.mean([5432.1, 1234.42, 876.23])
self.assertEqual(sample_mean, 2514.25)
self.assertIsInstance(sample_mean, float)
sample_mean = utils.mean([5432.1, 1234.42, 876.23])
self.assertNotEqual(sample_mean, 7542.75)
def presence_start_end_view(user_id):
"""
Returns mean presence time of given
user grouped by weekday and start/end hour.
"""
data = get_data()
if user_id not in data:
return 0
weekdays = group_by_start_end(data[user_id])
result = [(calendar.day_abbr[weekday], mean(start_end[0]),
mean(start_end[1]))
for weekday, start_end in enumerate(weekdays)]
return result
def test_mean(self):
"""
Testing if mean function calculates correctly.
"""
self.assertEqual(
utils.mean([3, 4, 5]), 4
)
self.assertEqual(
utils.mean([]), 0
)
self.assertAlmostEqual(
utils.mean([12.7, 20.5, 16.5]),
16.56666666,
)
def presence_start_end_view(user_id=None):
"""
Return mean times of start and and of work for given user.
"""
data = utils.get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
starts = utils.group_times_by_weekday(data[user_id]['times'], 'start')
ends = utils.group_times_by_weekday(data[user_id]['times'], 'end')
result = [(calendar.day_abbr[weekday], utils.mean(starts[weekday]),
utils.mean(ends[weekday])) for weekday in starts
if len(starts[weekday]) > 0]
return result
def test_mean(self):
"""
Test of calculating arithmetic mean
"""
self.assertEqual(
utils.mean([1.3, 2.7, 5]),
3,
)
self.assertAlmostEqual(
utils.mean(
[5.234, -2.34, 1.113, 3.2412, -0.1853, 0.54, 0.797],
),
1.1999857,
)
self.assertEqual(utils.mean([]), 0)
def presence_start_end(user_id):
"""
Returns timelines of average presence at work for given user
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
abort(404)
weekdays = group_timepoints_by_weekday(data[user_id])
weekdays = [(mean(x['start']), mean(x['end'])) for x in weekdays]
result = [(calendar.day_abbr[weekday], tl[0], tl[1])
for weekday, tl in enumerate(weekdays)]
return result
def mean_time_of_start_and_end_work(user_id):
"""
Returns mean time of start and end of work.
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
abort(404)
weekdays = group_by_weekday_by_start_end(data[user_id])
result = [(calendar.day_abbr[weekday], mean(values['start']),
mean(values['end']))
for weekday, values in weekdays.iteritems()]
return result
def presence_start_end_json_view(user_id=None):
"""
Returns mean start & end time of given user grouped by weekday
(mean time when user begins work, mean time when user finish work)
"""
data = utils.get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return {'success': False, 'data': []}
weekdays = utils.group_start_end_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], utils.mean(items['start']),
utils.mean(items['end']))
for weekday, items in enumerate(weekdays)]
return {'success': True, 'data': result}
def presence_start_end_view(user_id):
"""
Returns presence start/end view.
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = start_end_presence(data[user_id])
result = [
(calendar.day_abbr[weekday], mean(time['start']), mean(time['end']))
for weekday, time in weekdays.items()
]
return result
def presence_start_end(user_id):
"""
Returns mean presence time of given user
"""
data = utils.get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = utils.group_by_weekday_in_secs(data[user_id])
result = [(calendar.day_abbr[weekday],
utils.mean(mean_per_day['start']),
utils.mean(mean_per_day['end']))
for weekday, mean_per_day in weekdays.items()]
return result
def presence_start_end_view(user_id):
"""
Returns interval presence time
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = return_id_start_end(data[user_id])
result = [(calendar.day_abbr[key],
mean(value['start']),
mean(value['end']))
for key, value in weekdays.items()]
return result
def presence_start_end_view(user_id=None):
"""
Returns start and end time of given user grouped by weekday.
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = group_by_weekday_start_end(data[user_id])
result = [(
calendar.day_abbr[weekday],
mean(mean_per_day['start']),
mean(mean_per_day['end']),
) for weekday, mean_per_day in weekdays.items()]
return result
def test_mean(self):
"""
Test mean evaluation for lists of intervals
"""
sample_list_of_intervals = [30, 20, 10]
result = utils.mean(sample_list_of_intervals)
self.assertIsInstance(result, float)
self.assertEqual(result, 20)
def presence_start_end_view(user_id):
"""
Returns time of given user grouped by mean start and end job.
"""
data = utils.get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = utils.group_times_by_weekday(data[user_id])
result = [(
calendar.day_abbr[weekday],
utils.mean(times['start']),
utils.mean(times['end']),
) for weekday, times in weekdays.items()]
return result
def presence_start_end_view(user_id):
"""
Returns interval from start to end work.
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
abort(404)
weekdays = group_start_end_weekday(data[user_id])
for day in weekdays:
day['start'] = mean(day['start'])
day['end'] = mean(day['end'])
result = [(calendar.day_abbr[weekday], value['start'], value['end'])
for weekday, value in enumerate(weekdays)]
return result
def presence_start_end_view(user_id):
"""
Returns mean start time and mean end time.
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
abort(404)
week = group_start_end_times_by_weekday(data[user_id])
result = []
for day in week:
starts = mean(week[day]['start'])
ends = mean(week[day]['end'])
result.append([calendar.day_abbr[day], starts, ends])
return result
def presence_start_end_view(user_id):
"""
Returns mean start time and mean end time for given user
grouped by weekday.
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
abort(404)
weekdays = group_by_weekday_start_end(data[user_id])
result = [(
calendar.day_abbr[weekday],
mean(time.get('start', [])),
mean(time.get('end', [])),
) for weekday, time in enumerate(weekdays)]
return result
def mean_time_weekday_view(user_id):
"""Returns mean presence time of given user grouped by weekday."""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
abort(404)
weekdays = group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], mean(intervals))
for weekday, intervals in enumerate(weekdays)]
return result
def test_mean_time_weekday_view(self):
"""
Test json response for user 10.
"""
response = self.client.get('/api/v1/mean_time_weekday/10')
data = json.loads(response.data)
weekdays = utils.group_by_weekday(utils.get_data()[10])
expected_data = [[calendar.day_abbr[weekday],
utils.mean(intervals)]
for weekday, intervals in enumerate(weekdays)]
self.assertEqual(response.status_code, 200)
self.assertEqual(expected_data, data)
def test_mean(self):
"""
Test calculating arithmetic mean.
"""
items = []
result = utils.mean(items)
self.assertEqual(result, 0)
items = [1, 2, 3]
result = utils.mean(items)
self.assertEqual(result, 2.0)
items = [-1, 1]
result = utils.mean(items)
self.assertEqual(result, 0.0)
items = [-3, -2, -1]
result = utils.mean(items)
self.assertEqual(result, -2.0)
items = [1.8, 2.1, 3.7, 4.3]
result = utils.mean(items)
self.assertEqual(result, 2.975)
def mean_time_weekday_json_view(user_id=None):
"""
Returns mean presence time of given user grouped by weekday.
"""
data = utils.get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return {'success': False, 'data': []}
weekdays = utils.group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], utils.mean(intervals))
for weekday, intervals in enumerate(weekdays)]
return {'success': True, 'data': result}
def mean_time_weekday_view(user_id):
"""
Returns mean presence time of given user grouped by weekday.
"""
data = utils.get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = utils.group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], utils.mean(intervals))
for weekday, intervals in weekdays.items()]
return result
def mean_time_month_api_view(user_id):
"""
Return json response for mean time user with given id has come to and from work.
"""
data = get_data()
if user_id not in data:
log.debug('User %s not found', user_id)
abort(404)
months = group_intervals_by_month(data[user_id])
# +1 because month_abbr is shifted by 1 to match January with index 1.
results = []
for month, intervals in enumerate(months):
average_time = convert_seconds_to_time(int(mean(intervals)))
results.append([
calendar.month_abbr[month + 1],
[average_time.hour, average_time.minute, average_time.second]
])
return results
def test_mean(self):
"""
Tests calculating arithmetic mean. Returns zero for empty lists.
"""
self.assertEqual(utils.mean([1, 2, 3, 3]), 2.25)
self.assertEqual(utils.mean([]), 0.0)
def test_mean(self):
"""
Test arithmetic mean method.
"""
self.assertEqual(utils.mean([]), 0)
self.assertEqual(utils.mean([2, 5, 10, 15]), 8)
