def setUpClass(cls):
cls.db_helper = DefinitionsDatabaseManager(
cls.DB_FILE_PATH, cls.DB_CREATION_SCRIPT_PATH,
cls.DEFAULT_DATA_TYPES_SCRIPT_PATH,
cls.DEFAULT_DATA_SOURCE_TYPES_SCRIPT_PATH,
cls.DEFAULT_OPERATIONS_SCRIPT_PATH)
cls.ds_aosp_email = DataSource('Application',
{'package_name': 'com.android.email'})
cls.ds_facebook = DataSource('Application',
{'package_name': 'com.facebook.katana'})
cls.ds_aosp_sms = DataSource(
'Application', {'package_name': 'com.android.providers.telephony'})
cls.bad_ds = DataSource('Application', {})
cls.dv_info = DeviceInfo('3.0.0', 'GT-I9300')
cls.op_info_email_aosp_email = OperationInfo('EmailMessageAOSPEmail',
'EmailMessage',
cls.ds_aosp_email,
['GT-I9300'],
[('2.3.7', '5.1.1')])
cls.op_info_image_aosp_email = OperationInfo('ImageFileAOSPEmail',
'ImageFile',
cls.ds_aosp_email,
['GT-I9300'],
[('2.3.7', '5.1.1')])
cls.op_info_image_facebook = OperationInfo('ImageFileFacebook',
'ImageFile',
cls.ds_facebook,
['GT-I9300', 'XT1053'],
[('2.3.7', '5.1.1')])
cls.op_info_sms_aosp_sms = OperationInfo('SmsMessageAOSPSms',
'SmsMessage', cls.ds_aosp_sms,
['GT-I9300', 'LG-D820'],
[('2.0', '4.4.4')])
def get_operation_info_by_id(self, id_):
"""
:param id_: int
:rtype: OperationInfo
"""
with sqlite3.connect(self.db_file_path) as conn:
conn.row_factory = sqlite3.Row
c = conn.cursor()
c.execute(
"""
SELECT dt.name AS dt_name, dst.name AS dst_name, o.name AS o_name
FROM operations AS o, data_types AS dt, data_source_types AS dst
WHERE o.data_type_id = dt.id AND o.data_source_type_id = dst.id AND o.id = ?
""", [id_])
res = c.fetchone()
data_type = res['dt_name']
data_source_type = res['dst_name']
op_name = res['o_name']
c.execute(
"""
SELECT param_name, param_value
FROM data_source_params_values dspv
WHERE dspv.operation_id = ?
""", [id_])
param_values = {}
for pv in c:
param_values[pv['param_name']] = pv['param_value']
c.execute(
'SELECT model_number FROM device_models WHERE operation_id = ?',
[id_])
supported_models = []
for dm in c:
supported_models.append(dm['model_number'])
c.execute(
'SELECT from_version, to_version FROM android_versions WHERE operation_id = ?',
[id_])
supported_os_versions = []
for av in c:
supported_os_versions.append(
(av['from_version'], av['to_version']))
c.close()
return OperationInfo(op_name, data_type,
DataSource(data_source_type, param_values),
supported_models, supported_os_versions)
def parse_list_args(self, arg_line):
"""
:type arg_line: string
:rtype: (string, DataSource, DeviceInfo)
"""
dt = None
ds = None
di = None
parser = ArgumentParser()
parser.add_argument('--data_type', '-dt')
parser.add_argument('--source_type', '-st')
parser.add_argument('--source_params', '-sp', nargs='*')
parser.add_argument('--model', '-m')
parser.add_argument('--version', '-v')
args, unknown = parser.parse_known_args(shlex.split(arg_line))
if args.data_type:
dt = args.data_type
if args.source_type:
ds = DataSource(args.source_type, {})
if args.source_params:
params = {}
for p in args.source_params:
if ':' not in p:
raise ValueError(
"The parameter 'source_params' is a whitespace separated list of pairs param_name:param_value."
)
p_split = re.search('(.*):(.*)', p)
params[p_split.group(1)] = p_split.group(2)
ds.info = params
if args.model and args.version:
if not self.android_version_pattern.match(args.version):
raise ValueError('The Android version is not valid.')
di = DeviceInfo(args.version, args.model)
di.os_version = args.version
return dt, ds, di
def test_add_operation(self):
op_name = 'newOperation'
dt_name = 'EmailMessage'
dst_name = 'Application'
param_values = {'package': 'com.example.email'}
inspector_name = 'new_op_inspector'
dev_models = ['GT-i9300']
os_versions = [('2.2.0', '4.4.4')]
ds = DataSource(dst_name, param_values)
dev_info = DeviceInfo('4.3', dev_models[0])
self.db_helper.add_operation(op_name, dt_name, dst_name,
inspector_name, param_values, dev_models,
os_versions)
result = self.db_helper.query_operations_info(dt_name, ds, dev_info)
self.assertEqualList(
result,
[OperationInfo(op_name, dt_name, ds, dev_models, os_versions)])
def test_query_operation_for_data_source_with_missing_params(self):
self.assertFalse(
self.db_helper.has_all_required_param_values(
DataSource('Application', None)))
def get_and_predict():
print("Get and predict for ebola")
engine = create_engine(DATABASE_URL)
Session = sessionmaker(bind=engine)
session = Session()
data = pd.read_csv(data_url,
skiprows=[1],
parse_dates=["report_date", "publication_date"])
cases_by_time = data.groupby("report_date").sum()
cases_by_time.to_sql("cases_by_time", engine, if_exists="replace")
latest_update_date = data["publication_date"].max()
incidence, result_dates = get_incidence(cases_by_time["total_cases"])
ebola_gamma_params = {"a": 2.41975308641975, "scale": 4.74428571428571}
ebola_gamma = disease_model.discrete_prob(stats.gamma, ebola_gamma_params)
force_of_infection = disease_model.force_of_infection_time(
incidence, ebola_gamma)
mean_r, lower_r, upper_r, post_a, post_b = disease_model.estimated_r(
incidence, force_of_infection, ebola_gamma)
n_pred = 21
sims = disease_model.simulate_from_end_N(
incidence,
ebola_gamma,
n_pred,
lambda x: stats.gamma.mean(a=post_a[-1], scale=post_b[-1]),
N=100)
cum_sims = np.cumsum(sims, axis=1)
results = pd.DataFrame()
results["date"] = result_dates
results["incidence"] = incidence
results["cumulative_incidence"] = np.cumsum(incidence)
results["estimated_r"] = [0] * 9 + mean_r
results["estimated_r_lower"] = [0] * 9 + lower_r
results["estimated_r_upper"] = [0] * 9 + upper_r
predictions = pd.DataFrame()
predictions["date"] = [
result_dates[0] + datetime.timedelta(days=i)
for i in range(len(result_dates) + n_pred)
]
predictions["incidence"] = np.mean(sims, axis=0)
predictions["incidence_upper"] = np.quantile(sims, 0.95, axis=0)
predictions["incidence_lower"] = np.quantile(sims, 0.05, axis=0)
predictions["cumulative_incidence"] = np.mean(cum_sims, axis=0)
predictions["cumulative_incidence_upper"] = np.quantile(cum_sims,
0.95,
axis=0)
predictions["cumulative_incidence_lower"] = np.quantile(cum_sims,
0.05,
axis=0)
results.to_sql("estimate_r", engine, if_exists="replace")
predictions.to_sql("predictions", engine, if_exists="replace")
session.add(
DataSource(update_time=latest_update_date,
data=json.dumps({
"cases_by_time": "cases_by_time",
"estimate_r": "estimate_r",
"predictions": "predictions"
})))
session.commit()
