def test_roundtime(self):
"""
A testing function for rounTimeArray
"""
obj_test1 = data_import.ImportData('./smallData/cgm_small.csv')
output = data_import.roundTimeArray(obj_test1, 30, linear=True)
for (time, val) in output:
self.assertEqual(time.minute, 0)
self.assertEqual(val, (131 + 138 + 144) / 3)
break
output = data_import.roundTimeArray(obj_test1, 30, linear=False)
for (time, val) in output:
self.assertEqual(time.minute, 0)
self.assertEqual(val, (131 + 138 + 144) / 3)
break
obj_test2 = data_import.ImportData('./smallData/activity_small.csv')
output = data_import.roundTimeArray(obj_test2, 40, linear=True)
for (time, val) in output:
self.assertEqual(time.minute, 0)
self.assertEqual(val, (3 + 7 + 76 + 6 + 7))
break
output = data_import.roundTimeArray(obj_test2, 40, linear=False)
for (time, val) in output:
self.assertEqual(time.minute, 0)
self.assertEqual(val, (3 + 7 + 76 + 6 + 7))
break
def test_linear_search_roundtime(self):
# Linear search of the rounded table should return 2 entries for the first one
r = data_import.ImportData('./smallData/activity_small.csv')
data_import.roundTimeArray(r, 3)
w = r.linear_search_value(r._time[0])
# For activity_small, should return a sum of 0
self.assertEqual(w, [0.0])
def test_linear_search_double_index(self):
# To make sure it's handling double digits okay, I choese
# to return a double digit entry
r = data_import.ImportData('./smallData/activity_small.csv')
data_import.roundTimeArray(r, 1)
w = r.linear_search_value(r._time[14])
self.assertEqual([r._value[14]], w)
def test_printarray_bolus_cgm(self):
bolus_data = data_import.ImportData('smallData/bolus_small.csv')
cgm_data = data_import.ImportData('smallData/cgm_small.csv')
cgm_zip = data_import.roundTimeArray(cgm_data, 60, 'average')
bolus_zip = data_import.roundTimeArray(bolus_data, 60, 'sum')
data_list = [cgm_zip, bolus_zip]
ann_list = ['cgm_small', 'bolus_small']
base_name = 'test_printarray.csv'
key_file = 'cgm_small'
data_import.printArray(data_list, ann_list, base_name, key_file)
assert os.path.exists(base_name)
with open(base_name, 'r') as f:
assert 'time,cgm,bolus' in f.readline()
assert '2018-03-16 00:00:00,144.5,0.7,' in f.readline()
def test_round_time(self):
filename = './smallData/cgm_small.csv'
obj = data_import.ImportData(filename)
z = data_import.roundTimeArray(obj, 5)
for (t, v) in z:
self.assertEqual(v, 131)
self.assertEqual(t.minute, 5)
break
z = data_import.roundTimeArray(obj, 30)
for (t, v) in z:
self.assertEqual(v, (131 + 138 + 144) / 3)
self.assertEqual(t.minute, 0)
break
def test_roundtimearray_test_file_sum(self):
csv_reader = data_import.ImportData('test_timeround.csv')
zip_obj = data_import.roundTimeArray(csv_reader, 60, 'sum')
for time_round, value_sum in zip_obj:
assert value_sum == 435.0
assert time_round == data_import.datetime.datetime(
2018, 3, 16, 0, 0)
def test_roundtimearray_test_file_average(self):
csv_reader = data_import.ImportData('test_timeround.csv')
zip_obj = data_import.roundTimeArray(csv_reader, 60, 'average')
for time_round, value_avg in zip_obj:
assert value_avg == 145.0
assert time_round == data_import.datetime.datetime(
2018, 3, 16, 0, 0)
def test_print_array(self):
folder_path = 'smallData'
resolution = 5
output_file = 'tmp.csv'
key_file = 'cgm_small.csv'
# pull all the folders in the file
files_lst = [
f for f in listdir(folder_path) if isfile(join(folder_path, f))
]
# import all the files into a list of ImportData objects
data_lst = []
for f in files_lst:
data_lst.append(data_import.ImportData(folder_path + '/' + f))
# convert to zipped, rounded data
zip_data = []
for data in data_lst:
zip_data.append(data_import.roundTimeArray(data, resolution))
# print to a csv file
data_import.printArray(zip_data, files_lst, output_file, key_file)
self.assertTrue(os.path.exists(output_file))
os.remove(output_file)
def test_rounding_resolution(self):
file_name = 'smallData/activity_small.csv'
resolution = 5
test_data = data_import.ImportData(file_name)
rounded_data = data_import.roundTimeArray(test_data, resolution)
# make sure the rounded times correct resolution
for t, v in rounded_data:
self.assertTrue(t.minute % resolution == 0)
def test_round_time(self):
filename = './smallData/smbg_small.csv'
obj = data_import.ImportData(filename)
rounded = data_import.roundTimeArray(obj, 5)
for (time, value) in rounded:
self.assertEqual(value, 254.0)
d = datetime.datetime(2018, 3, 16, 8, 45)
self.assertEqual(time, d)
break
def test_rounding_unique(self):
file_name = 'smallData/activity_small.csv'
resolution = 5
test_data = data_import.ImportData(file_name)
rounded_data = data_import.roundTimeArray(test_data, resolution)
times = []
for t, v in rounded_data:
times.append(t)
# make sure the rounded times are unique
self.assertFalse(len(times) > len(times))
def test_print_array_round_to_15(self):
data = []
for f in os.listdir('smallData'):
data.append(di.ImportData('smallData/' + f))
rdata_15 = []
for i in data:
rdata_15.append(di.roundTimeArray(i, 15))
self.assertNotEqual(
di.printArray(rdata_15, os.listdir('smallData'), 'out_15',
'meal_small.csv'), -1)
self.assertTrue(os.path.exists('out_15.csv'))
os.remove('out_15.csv')
def test_print_array(self):
files_lst = os.listdir('./smallData/')
data = []
for f in files_lst:
data.append(data_import.ImportData(join('./smallData/', f)))
data_5 = []
for obj in data:
data_5.append(data_import.roundTimeArray(obj, 5))
r = data_import.printArray(data_5, files_lst, 'out_5',
'smbg_small.csv')
self.assertTrue(os.path.exists('out_5.csv'))
os.remove('out_5.csv')
def test_print_array(self):
files_lst = os.listdir('smallData')
data_lst = []
for f in files_lst:
data_lst.append(data_import.ImportData('smallData/' + f))
data_5 = []
for obj in data_lst:
data_5.append(data_import.roundTimeArray(obj, 5))
r = data_import.printArray(data_5, files_lst, 'out_5', 'hr_small.csv')
self.assertNotEqual(r, -1)
self.assertTrue(os.path.exists('out_5.csv'))
os.remove('out_5.csv')
def test_print_array_round_to_5(self):
data = []
for f in os.listdir('smallData'):
if '.csv' in f:
data.append(data_import.ImportData('smallData/' + f))
data_5 = []
for i in data:
data_5.append(data_import.roundTimeArray(i, 5))
self.assertNotEqual(
data_import.printArray(data_5,
os.listdir('smallData'),
'out_5', 'cgm_small.csv'), -1)
self.assertTrue(os.path.exists('out_5.csv'))
os.remove('out_5.csv')
def test_printarray(self):
"""
A testing function for printArray
"""
file_lst = os.listdir('./smallData')
data_list = []
for i in range(len(file_lst)):
obj = data_import.ImportData('./smallData/' + file_lst[i])
data_list.append(data_import.roundTimeArray(obj, 5))
result = data_import.printArray(data_list, file_lst, 'test_printarray',
'meal_small.csv')
self.assertNotEqual(result, -1)
self.assertTrue(os.path.exists('test_printarray.csv'))
os.remove('test_printarray.csv')
def test_DataImport_linear_search_value(self):
data_times = []
data_values = []
key_index = random.randint(0, 9)
key_time = None
with open("test_file.csv", mode="w") as test_data:
data_writer = csv.writer(test_data, delimiter=",")
data_writer.writerow(["time", "value"])
idate = datetime.datetime.now()
for item in range(9):
idatestr = idate.strftime("%m/%d/%Y %H:%M")
randval = str(random.randint(0, 10000))
data_writer.writerow([idatestr, randval])
data_times.append(idatestr)
data_values.append(randval)
idate = idate + datetime.timedelta(minutes=2)
test_data.close()
testdata = ImportData("test_file.csv")
data_import.roundTimeArray(testdata, 5)
key_time = testdata._roundtime[key_index]
os.remove("test_file.csv")
self.assertIn(int(data_values[key_index]),
testdata.linear_search_value(key_time))
def test_printarray_input_types(self):
bolus_data = data_import.ImportData('smallData/bolus_small.csv')
cgm_data = data_import.ImportData('smallData/cgm_small.csv')
cgm_zip = data_import.roundTimeArray(cgm_data, 60, 'average')
bolus_zip = data_import.roundTimeArray(bolus_data, 60, 'sum')
data_list = [cgm_zip, bolus_zip]
ann_list = ['cgm_small', 'bolus_small']
base_name = 'test_printarray.csv'
key_file = 'cgm_small'
self.assertRaises(TypeError, data_import.printArray, 1, ann_list,
base_name, key_file)
self.assertRaises(TypeError, data_import.printArray, data_list,
'string!', base_name, key_file)
self.assertRaises(TypeError, data_import.printArray, data_list,
ann_list, 1.234, key_file)
self.assertRaises(TypeError, data_import.printArray, data_list,
ann_list, base_name, [1, 2, 3, 4])
self.assertRaises(
TypeError, data_import.printArray,
[zip([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]), 'not a zip!'], ann_list,
base_name, key_file)
self.assertRaises(IndexError, data_import.printArray, data_list,
['a', 'b', 10, [1, 2, 3, 4]], base_name, key_file)
os.remove('test_printarray.csv')
def test_roundtimearray_test_modify(self):
csv_reader = data_import.ImportData('test_timeround.csv')
csv_reader_old = copy.deepcopy(csv_reader)
data_import.roundTimeArray(csv_reader, 60, 'sum', modify=True)
assert len(csv_reader._time) != len(csv_reader_old._time)
def test_round_output_type(self):
data = datimp.ImportData('smallData/cgm_small.csv')
output = datimp.roundTimeArray(data, 5)
self.assertEqual(type(output), zip)
def test_linear_search_roundtime_sum(self):
# Linear search of 5 minute rounding, which should be a sum of 0
r = data_import.ImportData('./smallData/activity_small.csv')
data_import.roundTimeArray(r, 5)
w = r.linear_search_value(r._time[0])
self.assertEqual(w, [0.0])
def test_linear_search_roundtime_avg(self):
# Linear search of forty minute rounding, which should be an avg of 138
r = data_import.ImportData('./smallData/cgm_small.csv')
data_import.roundTimeArray(r, 9)
w = r.linear_search_value(r._time[1])
self.assertEqual(w, [138.0])
def test_linear_search_first(self):
# Given a specific time, we should return the proper value
r = data_import.ImportData('./smallData/activity_small.csv')
data_import.roundTimeArray(r, 1)
w = r.linear_search_value(r._time[0])
self.assertEqual([r._value[0]], w)
def test_linear_search_mid(self):
# See if a mid entry matches
r = data_import.ImportData('./smallData/cgm_small.csv')
data_import.roundTimeArray(r, 1)
w = r.linear_search_value(r._time[4])
self.assertEqual([r._value[4]], w)
# do this in a loop, where you loop through the data_lst
data_5 = [] # a list with time rounded to 5min
data_15 = [] # a list with time rounded to 15min
# Linear Search (linear search is default)
t1 = time.time()
for data_import_obj in data_lst:
sum_key = [
add_file in data_import_obj._file_name
for add_file in ['activity, bolus, meal']
]
if any(sum_key):
data_5.append(
data_import.roundTimeArray(data_import_obj, 5,
operation='add'))
else:
data_5.append(data_import.roundTimeArray(data_import_obj, 5))
try:
data_import.printArray(data_5, files_lst, args.output_file + '_5.csv',
args.sort_key)
except IndexError:
print("sort_key provided was did not apply to the files in " +
args.folder_name,
file=sys.stderr)
sys.exit(1)
t2 = time.time()
for data_import_obj in data_lst:
sum_key = [
