def test_get_rool(self):
flumodel = FluModel()
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
datapoint = ModelScore()
datapoint.region = 'e'
datapoint.score_date = date(2018, 6, 29)
datapoint.calculation_timestamp = datetime.now()
datapoint.score_value = 1.23
datapoint.confidence_interval_lower = 0.81
datapoint.confidence_interval_upper = 1.65
flumodel.model_scores = [datapoint]
model_function = ModelFunction()
model_function.id = 1
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
default_model = DefaultFluModel()
default_model.flu_model_id = 1
with self.app.app_context():
flumodel.save()
model_function.save()
DB.session.add(default_model)
DB.session.commit()
response = self.client().get('/')
result = response.get_json()
expected = {
'model_list': [{
'id': 1,
'name': 'Test Model'
}],
'rate_thresholds': {},
'model_data': [{
'id':
1,
'name':
'Test Model',
'average_score':
1.23,
'start_date':
'2018-06-29',
'end_date':
'2018-06-29',
'has_confidence_interval':
True,
'data_points': [{
'score_date': '2018-06-29',
'score_value': 1.23,
'confidence_interval_lower': 0.81,
'confidence_interval_upper': 1.65
}]
}]
}
self.assertEqual(result, expected)
self.assertEqual(response.status_code, 200)
def set_model_score_confidence_interval(
model_id: int,
score_date: date,
score_value: float,
confidence_interval: Tuple[float, float]
):
""" Persists a model score entity including its confidence interval """
model_score = ModelScore()
model_score.flu_model_id = model_id
model_score.region = 'e' # Default for Google data
model_score.score_date = score_date
model_score.score_value = score_value
model_score.confidence_interval_lower = confidence_interval[0]
model_score.confidence_interval_upper = confidence_interval[1]
model_score.save()
def test_build_scores_response(self):
data_points = [{
'score_date': '2019-01-01',
'score_value': 0.2,
'confidence_interval_lower': 0.1,
'confidence_interval_upper': 0.5
}, {
'score_date': '2019-01-02',
'score_value': 0.4,
'confidence_interval_lower': 0.1,
'confidence_interval_upper': 0.5
}]
model_data = [{
'id': 1,
'name': 'Test Model',
'start_date': '2019-01-01',
'end_date': '2019-01-02',
'average_score': 0.3,
'has_confidence_interval': True,
'data_points': data_points
}]
expected = {'model_data': model_data}
flu_model_score_1, flu_model_score_2 = ModelScore(), ModelScore()
flu_model_score_1.score_date, flu_model_score_2.score_date = date(
2019, 1, 1), date(2019, 1, 2)
flu_model_score_1.score_value, flu_model_score_2.score_value = 0.2, 0.4
flu_model_score_1.confidence_interval_lower, flu_model_score_2.confidence_interval_lower = 0.1, 0.1
flu_model_score_1.confidence_interval_upper, flu_model_score_2.confidence_interval_upper = 0.5, 0.5
flu_model_data = [({
'id': 1,
'name': 'Test Model',
'start_date': date(2019, 1, 1),
'end_date': date(2019, 1, 2),
'has_confidence_interval': True,
'average_score': 0.3
}, [flu_model_score_1, flu_model_score_2])]
result = build_scores_response(flu_model_data)
self.assertDictEqual(result, expected)
def test_csv(self):
flumodel = FluModel()
flumodel.id = 1
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
dates = [date(2018, 6, d) for d in range(1, 30)]
datapoints = []
for d in dates:
entry = ModelScore()
entry.region = 'e'
entry.score_date = d
entry.calculation_timestamp = datetime.now()
entry.score_value = 1 + 10 / d.day
entry.confidence_interval_lower = 0
entry.confidence_interval_upper = 2
datapoints.append(entry)
flumodel.model_scores = datapoints
model_function = ModelFunction()
model_function.id = 1
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
with self.app.app_context():
flumodel.save()
model_function.save()
response = self.client().get(
'/csv?id=1&tartDate=2018-06-01&endDate=2018-06-07&resolution=week'
)
expected_header = r'attachment; filename=RawScores-\d{13}\.csv'
expected_data = b'score_date,score_Test Model\r\n2018-06-03,4.333333333333334\r\n'
self.assertEquals(response.data, expected_data)
self.assertRegexpMatches(response.headers['Content-Disposition'],
expected_header)
def test_build_root_plink_twlink_response(self):
model_list = [{
'id': 1,
'name': 'Test Model'
}, {
'id': 2,
'name': 'Another Test Model'
}]
rate_thresholds = {
'very_high_value': {
'label': 'Very high epidemic rate',
'value': 0.4
},
'high_value': {
'label': 'High epidemic rate',
'value': 0.3
},
'medium_value': {
'label': 'Medium epidemic rate',
'value': 0.2
},
'low_value': {
'label': 'Low epidemic rate',
'value': 0.1
}
}
data_points = [{
'score_date': '2019-01-01',
'score_value': 0.2,
'confidence_interval_lower': 0.1,
'confidence_interval_upper': 0.5
}, {
'score_date': '2019-01-02',
'score_value': 0.4,
'confidence_interval_lower': 0.1,
'confidence_interval_upper': 0.5
}]
model_data = [{
'id': 1,
'name': 'Test Model',
'start_date': '2019-01-01',
'end_date': '2019-01-02',
'average_score': 0.3,
'has_confidence_interval': True,
'data_points': data_points
}]
expected = {
'model_list': model_list,
'rate_thresholds': rate_thresholds,
'model_data': model_data
}
flu_model_1, flu_model_2 = FluModel(), FluModel()
flu_model_1.id, flu_model_2.id = 1, 2
flu_model_1.name, flu_model_2.name = 'Test Model', 'Another Test Model'
flu_model_list = [flu_model_1, flu_model_2]
flu_model_score_1, flu_model_score_2 = ModelScore(), ModelScore()
flu_model_score_1.score_date, flu_model_score_2.score_date = date(
2019, 1, 1), date(2019, 1, 2)
flu_model_score_1.score_value, flu_model_score_2.score_value = 0.2, 0.4
flu_model_score_1.confidence_interval_lower, flu_model_score_2.confidence_interval_lower = 0.1, 0.1
flu_model_score_1.confidence_interval_upper, flu_model_score_2.confidence_interval_upper = 0.5, 0.5
flu_model_data = [({
'id': 1,
'name': 'Test Model',
'start_date': date(2019, 1, 1),
'end_date': date(2019, 1, 2),
'has_confidence_interval': True,
'average_score': 0.3
}, [flu_model_score_1, flu_model_score_2])]
result = build_root_plink_twlink_response(flu_model_list,
rate_thresholds,
flu_model_data)
self.assertEquals(result, expected)
def test_get_plink_smoothing(self):
with self.app.app_context():
for idx in [1, 2]:
flumodel = FluModel()
flumodel.name = 'Test Model %d' % idx
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
dates = [date(2018, 6, d) for d in range(1, 30)]
datapoints = []
for d in dates:
entry = ModelScore()
entry.region = 'e'
entry.score_date = d
entry.calculation_timestamp = datetime.now()
entry.score_value = 1.23 / d.day
entry.confidence_interval_lower = 0.81
entry.confidence_interval_upper = 1.65
datapoints.append(entry)
flumodel.model_scores = datapoints
model_function = ModelFunction()
model_function.id = idx
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = idx
model_function.has_confidence_interval = True
flumodel.save()
model_function.save()
default_model = DefaultFluModel()
default_model.flu_model_id = 1
rate_thresholds = RateThresholdSet()
rate_thresholds.low_value = 0.1
rate_thresholds.medium_value = 0.2
rate_thresholds.high_value = 0.3
rate_thresholds.very_high_value = 0.4
rate_thresholds.valid_from = date(2010, 1, 1)
rate_thresholds.save()
DB.session.add(default_model)
DB.session.commit()
response = self.client().get(
'/plink?id=1&id=2&startDate=2018-06-01&endDate=2018-06-05&smoothing=3'
)
self.assertListEqual(response.get_json()['model_list'],
[{
'id': 1,
'name': 'Test Model 1'
}, {
'id': 2,
'name': 'Test Model 2'
}])
self.assertEqual(
len(response.get_json()['model_data'][0]['data_points']), 5)
self.assertEqual(
len(response.get_json()['model_data'][1]['data_points']), 5)
expected = {
'low_value': {
'label': 'Low epidemic rate',
'value': 0.1
},
'medium_value': {
'label': 'Medium epidemic rate',
'value': 0.2
},
'high_value': {
'label': 'High epidemic rate',
'value': 0.3
},
'very_high_value': {
'label': 'Very high epidemic rate',
'value': 0.4
}
}
self.assertDictEqual(response.get_json()['rate_thresholds'], expected)
list_expected = [0.252833, 0.321167, 0.444167, 0.751667, 0.922500]
list_result = [
round(s['score_value'], 6)
for s in response.get_json()['model_data'][0]['data_points']
]
self.assertListEqual(list_result, list_expected)
def test_get_twlink_current_link(self):
flumodel = FluModel()
flumodel.id = 1
flumodel.name = 'Test Model'
flumodel.is_public = True
flumodel.is_displayed = True
flumodel.source_type = 'google'
flumodel.calculation_parameters = 'matlab_model,1'
flumodel.model_region_id = '1-e'
dates = [date(2018, 6, d) for d in range(1, 30)]
datapoints = []
for d in dates:
entry = ModelScore()
entry.region = 'e'
entry.score_date = d
entry.calculation_timestamp = datetime.now()
entry.score_value = 1.23
entry.confidence_interval_lower = 0.81
entry.confidence_interval_upper = 1.65
datapoints.append(entry)
flumodel.model_scores = datapoints
model_function = ModelFunction()
model_function.id = 1
model_function.function_name = 'matlab_model'
model_function.average_window_size = 1
model_function.flu_model_id = 1
model_function.has_confidence_interval = True
default_model = DefaultFluModel()
default_model.flu_model_id = 1
rate_thresholds = RateThresholdSet()
rate_thresholds.low_value = 0.1
rate_thresholds.medium_value = 0.2
rate_thresholds.high_value = 0.3
rate_thresholds.very_high_value = 0.4
rate_thresholds.valid_from = date(2010, 1, 1)
with self.app.app_context():
flumodel.save()
model_function.save()
rate_thresholds.save()
DB.session.add(default_model)
DB.session.commit()
response = self.client().get(
'/twlink?id=1&start=2018-06-01&end=2018-06-10')
self.assertListEqual(response.get_json()['model_list'],
[{
'id': 1,
'name': 'Test Model'
}])
self.assertEqual(
len(response.get_json()['model_data'][0]['data_points']), 10)
expected = {
'low_value': {
'label': 'Low epidemic rate',
'value': 0.1
},
'medium_value': {
'label': 'Medium epidemic rate',
'value': 0.2
},
'high_value': {
'label': 'High epidemic rate',
'value': 0.3
},
'very_high_value': {
'label': 'Very high epidemic rate',
'value': 0.4
}
}
self.assertDictEqual(response.get_json()['rate_thresholds'], expected)