def load_glucose_velocities(self, resource_name): """ Load effect-velocity json file Arguments: resource_name -- name of file without the extension Output: 3 lists in (start_date, end_date, glucose_effects) format """ fixture = load_fixture(resource_name, ".json") start_dates = [ datetime.fromisoformat( dict_.get("startDate") if dict_.get("startDate") else dict_. get("start_at")) for dict_ in fixture ] end_dates = [ datetime.fromisoformat( dict_.get("endDate") if dict_.get("endDate") else dict_. get("end_at")) for dict_ in fixture ] glucose_effects = [ dict_.get("value") if dict_.get("value") else dict_.get("velocity") for dict_ in fixture ] assert len(start_dates) == len(end_dates) == len(glucose_effects),\ "expected output shape to match" return (start_dates, end_dates, glucose_effects)
def load_ice_input_fixture(self, name): """ Load insulin counteraction effects (ICE) from json file Arguments: name -- name of file without the extension Output: 3 lists in (start_date, end_date, insulin_counteraction_value) format """ fixture = load_fixture(name, ".json") start_dates = [ datetime.fromisoformat(dict_.get("start_at")) for dict_ in fixture ] end_dates = [ datetime.fromisoformat(dict_.get("end_at")) for dict_ in fixture ] ice_values = [dict_.get("velocity") for dict_ in fixture] assert len(start_dates) == len(end_dates) == len(ice_values),\ "expected output shape to match" return (start_dates, end_dates, ice_values)
def load_counteraction_input_fixture(self, name): """ Load insulin counteraction effects from json file Arguments: name -- name of file without the extension Output: 3 lists in (start_date, end_date, insulin_counteraction_value) format """ fixture = load_fixture(name, ".json") start_dates = [ datetime.fromisoformat(dict_.get("startDate")) if "T" in dict_.get("startDate") else datetime.strptime( dict_.get("startDate"), "%Y-%m-%d %H:%M:%S %z" ) for dict_ in fixture ] end_dates = [ datetime.fromisoformat(dict_.get("endDate")) if "T" in dict_.get("endDate") else datetime.strptime( dict_.get("endDate"), "%Y-%m-%d %H:%M:%S %z" ) for dict_ in fixture ] ice_values = [dict_.get("value") for dict_ in fixture] assert len(start_dates) == len(end_dates) == len(ice_values),\ "expected output shape to match" return (start_dates, end_dates, ice_values)
def load_sensitivities(self, resource_name): """ Load insulin sensitivity schedule from json file Arguments: resource_name -- name of file without the extension Output: 3 lists in (sensitivity_start_time, sensitivity_end_time, sensitivity_value (mg/dL/U)) format """ data = load_fixture(resource_name, ".json") start_times = [ datetime.strptime(dict_.get("start"), "%H:%M:%S").time() for dict_ in data ] end_times = [ datetime.strptime(dict_.get("end"), "%H:%M:%S").time() for dict_ in data ] values = [dict_.get("value") for dict_ in data] assert len(start_times) == len(end_times) == len(values),\ "expected output shape to match" return (start_times, end_times, values)
def load_glucose_effect_fixture_normal_time(self, name): """ Load glucose effects from json file if dates are in format "%Y-%m-%d %H:%M:%S %z" Output: 2 lists in (date, glucose_value) format """ fixture = load_fixture( name, ".json" ) dates = [ datetime.strptime( dict_.get("date"), "%Y-%m-%d %H:%M:%S %z" ) for dict_ in fixture ] glucose_values = [dict_.get("value") for dict_ in fixture] assert len(dates) == len(glucose_values),\ "expected output shape to match" return (dates, glucose_values)
def load_reservoir_fixture(self, resource_name): """ Load reservior data from json file Arguments: resource_name -- name of file without the extension Variable names: fixture -- list of dictionaries; each dictionary contains properties of a NewReserviorValue Output: 2 lists in (date, units_given) format """ fixture = load_fixture(resource_name, ".json") dates = [ datetime.fromisoformat(dict_.get("date")) for dict_ in fixture ] unit_volumes = [dict_.get("amount") for dict_ in fixture] assert len(dates) == len(unit_volumes),\ "expected output shape to match" return (dates, unit_volumes)
def load_input_fixture(self, resource_name): """ Load input json file Arguments: resource_name -- name of file without the extension Variable names: fixture -- list of dictionaries; each dictionary contains properties of a GlucoseFixtureValue Output: 4 lists in (date, glucose_value, display_only (for calibration purposes), providence_identifier) format """ fixture = load_fixture(resource_name, ".json") dates = [ datetime.fromisoformat(dict_.get("date")) for dict_ in fixture ] glucose_values = [dict_.get("amount") for dict_ in fixture] def get_boolean(dict_): return dict_.get("display_only") in ("yes", "true", "True") display_onlys = [get_boolean(dict_) for dict_ in fixture] providences = [ dict_.get("provenance_identifier") or "com.loopkit.LoopKitTests" for dict_ in fixture ] assert len(dates) == len(glucose_values) == len(display_onlys) ==\ len(providences), "expected output shape to match" return (dates, glucose_values, display_onlys, providences)
def load_report_insulin_effects(self, report_name): """ Load the expected insulin effects from an issue report """ report = load_fixture(report_name, ".json") assert report.get("insulin_effect"),\ "expected issue report to contain insulin effect information" return load_insulin_effects(report.get("insulin_effect"))
def load_report_insulin_doses(self, report_name): """ Load the normalized dose entries from an issue report """ report = load_fixture(report_name, ".json") assert report.get("get_normalized_dose_entries"),\ "expected issue report to contain dose information" return get_insulin_data(report.get("get_normalized_dose_entries"))
def load_report_predicted_glucoses(self, report_name): """ Load the expected retrospective effects from an issue report """ report = load_fixture(report_name, ".json") assert report.get("predicted_glucose"),\ "expected issue report to contain glucose prediction information" return load_insulin_effects(report.get("predicted_glucose"))
def load_report_glucose_values(self, report_name): """ Load the cached glucose values from an issue report """ report = load_fixture(report_name, ".json") assert report.get("cached_glucose_samples"),\ "expected issue report to contain glucose information" return get_glucose_data(report.get("cached_glucose_samples"))
def load_report_basal_schedule(self, report_name): """ Load the basal schedule from an issue report """ report = load_fixture(report_name, ".json") assert report.get("basal_rate_schedule"),\ "expected issue report to contain basal rate information" return get_basal_schedule(report.get("basal_rate_schedule"))
def load_report_cr_schedule(self, report_name): """ Load the carb ratio schedule from an issue report """ report = load_fixture(report_name, ".json") assert report.get("carb_ratio_schedule"),\ "expected issue report to contain carb ratio information" return get_carb_ratios(report.get("carb_ratio_schedule"))
def load_report_momentum_effects(self, report_name): """ Load the expected momentum effects from an issue report """ report = load_fixture(report_name, ".json") assert report.get("glucose_momentum_effect"),\ "expected issue report to contain momentum information" return load_momentum_effects(report.get("glucose_momentum_effect"))
def load_report_retrospective_effects(self, report_name): """ Load the expected retrospective effects from an issue report """ report = load_fixture(report_name, ".json") assert report.get("retrospective_glucose_effect"),\ "expected issue report to contain retrospective effect information" return get_retrospective_effects( report.get("retrospective_glucose_effect"))
def load_carb_entry_fixture(self): """ Load carb entry Output: 3 lists in (carb_values, carb_start_dates, carb_absorption_times) format """ fixture = load_fixture("carb_entry_input", ".json") return self.carb_entries_from_fixture(fixture)
def load_report_sensitivity_schedule(self, report_name): """ Load the insulin sensitivity schedule from an issue report """ report = load_fixture(report_name, ".json") assert report.get("insulin_sensitivity_factor_schedule"),\ "expected issue report to contain insulin sensitivity information" return get_sensitivities( report.get("insulin_sensitivity_factor_schedule"))
def load_report_carb_values(self, report_name): """ Load the carb entries from an issue report """ report = load_fixture(report_name, ".json") if not report.get("cached_carb_entries"): print("Issue report contains no carb information") return ([], []) return get_carb_data(report.get("cached_carb_entries"))
def load_history_fixture(self, name): """ Load carb history from json file Argument: name -- name of file, without .json extension Output: 3 lists in (carb_values, carb_start_dates, carb_absorption_times) format """ fixture = load_fixture(name, ".json") return self.carb_entries_from_fixture(fixture)
def load_carb_ratios(self): """ Load carb ratios from json file Output: 2 lists in (ratio_start_time, ratio (in units/insulin), length_of_rate) format """ schedule = load_fixture("read_carb_ratios", ".json").get("schedule") carb_sched_starts = [ time.fromisoformat(dict_.get("start")) for dict_ in schedule ] carb_sched_ratios = [dict_.get("ratio") for dict_ in schedule] return (carb_sched_starts, carb_sched_ratios)
def load_schedules(self): """ Load the carb schedule Output: 2 lists in (schedule_offsets, carb_ratios) format """ schedule = load_fixture("read_carb_ratios", ".json").get("schedule") carb_sched_starts = [ time.fromisoformat(dict_.get("start")) for dict_ in schedule ] carb_sched_ratios = [dict_.get("ratio") for dict_ in schedule] return (carb_sched_starts, carb_sched_ratios)
def load_glucose_value_fixture(self, name): """ Load glucose effects from json file Output: 2 lists in (date, glucose_value) format """ fixture = load_fixture(name, ".json") dates = [ datetime.fromisoformat(dict_.get("date")) for dict_ in fixture ] glucose_values = [dict_.get("amount") for dict_ in fixture] assert len(dates) == len(glucose_values),\ "expected output shape to match" return (dates, glucose_values)
def load_dose_fixture(self, resource_name): """ Load dose from json file Arguments: resource_name -- name of file without the extension Output: 5 lists in (dose_type (basal/bolus), start_dates, end_dates, values (in units/insulin), scheduled_basal_rates) format """ fixture = load_fixture(resource_name, ".json") dose_types = [ DoseType.from_str( dict_.get("type") ) or "!" for dict_ in fixture ] start_dates = [ datetime.fromisoformat(dict_.get("start_at")) for dict_ in fixture ] end_dates = [ datetime.fromisoformat(dict_.get("end_at")) for dict_ in fixture ] values = [dict_.get("amount") for dict_ in fixture] # not including description, unit, and raw bc not relevent scheduled_basal_rates = [ dict_.get("scheduled") or 0 for dict_ in fixture ] assert len(dose_types) == len(start_dates) == len(end_dates) ==\ len(values) == len(scheduled_basal_rates),\ "expected output shape to match" # if dose_type doesn't exist (meaning there's an "!"), remove entry if "!" in dose_types: for i in range(0, len(dose_types)): if dose_types[i] == "!": del dose_types[i] del start_dates[i] del end_dates[i] del values[i] del scheduled_basal_rates[i] return (dose_types, start_dates, end_dates, values, scheduled_basal_rates)
def load_glucose_effect_fixture(resource_name): """ Load glucose effects from json file Arguments: resource_name -- name of file without the extension Output: 2 lists in (date, glucose_value) format """ fixture = load_fixture(resource_name, ".json") dates = [datetime.fromisoformat(dict_.get("date")) for dict_ in fixture] glucose_values = [dict_.get("amount") for dict_ in fixture] assert len(dates) == len(glucose_values),\ "expected output shape to match" return (dates, glucose_values)
def load_insulin_value_fixture(resource_name): """ Load insulin values from json file Arguments: resource_name -- name of file without the extension Output: 2 lists in (start_date, insulin_amount) format """ fixture = load_fixture(resource_name, ".json") start_dates = [datetime.fromisoformat(dict_.get("date")) for dict_ in fixture] insulin_values = [dict_.get("value") for dict_ in fixture] assert len(start_dates) == len(insulin_values),\ "expected output shape to match" return (start_dates, insulin_values)
def basal_rate_schedule(self): """ Load basal schedule Output: 3 lists in (rate_start_time, rate (in Units/insulin), length_of_rate) format """ fixture = load_fixture("read_selected_basal_profile", ".json") start_times = [ datetime.strptime(dict_.get("start"), "%H:%M:%S").time() for dict_ in fixture ] rates = [dict_.get("rate") for dict_ in fixture] minutes = [dict_.get("minutes") for dict_ in fixture] assert len(start_times) == len(rates) == len(minutes),\ "expected output shape to match" return (start_times, rates, minutes)
def load_cob_output_fixture(self, name): """ Load COB from json file Arguments: name -- name of file without the extension Output: 2 lists in (date, cob_value) format """ fixture = load_fixture(name, ".json") dates = [ datetime.fromisoformat(dict_.get("date")) for dict_ in fixture ] cob_values = [dict_.get("amount") for dict_ in fixture] assert len(dates) == len(cob_values),\ "expected output shape to match" return (dates, cob_values)
def load_carb_data(self, resource_name): """ Load carb entries data from json file Arguments: resource_name -- name of file without the extension Output: 3 lists in (carb_values, carb_start_dates, carb_absorption_times) format """ data = load_fixture(resource_name, ".json") carb_values = [dict_.get("amount") for dict_ in data] start_dates = [ datetime.fromisoformat(dict_.get("start_at")) for dict_ in data ] absorption_times = [ dict_.get("absorption_time") if dict_.get("absorption_time") else None for dict_ in data ] return (start_dates, carb_values, absorption_times)
def load_basal_rate_schedule_fixture(self, resource_name): """ Load basal schedule from json file Arguments: resource_name -- name of file without the extension Output: 3 lists in (rate_start_time, rate (in units/insulin), length_of_rate) format """ fixture = load_fixture(resource_name, ".json") start_times = [ datetime.strptime(dict_.get("start"), "%H:%M:%S").time() for dict_ in fixture ] rates = [dict_.get("rate") for dict_ in fixture] minutes = [dict_.get("minutes") for dict_ in fixture] assert len(start_times) == len(rates) == len(minutes),\ "expected output shape to match" return (start_times, rates, minutes)
def load_sample_value_fixture(self, name): """ Load sample values from json file Output: 2 lists in (date, glucose_value) format """ fixture = load_fixture( name, ".json" ) dates = [ datetime.strptime( dict_.get("startDate"), "%Y-%m-%dT%H:%M:%S%z" ) for dict_ in fixture ] glucose_values = [dict_.get("value") for dict_ in fixture] assert len(dates) == len(glucose_values),\ "expected output shape to match" return (dates, glucose_values)