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): """ 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_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 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)