def __init__(self, debug):
"""Return an instance of the CheckUp class."""
self.db_params = GarminDBConfigManager.get_db_params()
self.debug = debug
self.garmin_db = GarminDB.GarminDB(self.db_params)
self.measurement_system = GarminDB.Attributes.measurements_type(self.garmin_db)
self.unit_strings = Fit.units.unit_strings[self.measurement_system]
def delete_dbs(delete_db_list=[]):
"""Delete selected, or all if none selected GarminDB, database files."""
db_params_dict = GarminDBConfigManager.get_db_params()
if len(delete_db_list) == 0:
delete_db_list = [GarminDB.GarminDB, GarminDB.MonitoringDB, GarminDB.ActivitiesDB, GarminDB.GarminSummaryDB, HealthDB.SummaryDB]
for db in delete_db_list:
db.delete_db(db_params_dict)
def setUpClass(cls):
cls.garmin_act_db = GarminDB.ActivitiesDB(GarminDBConfigManager.get_db_params())
table_dict = {
'activities_table' : GarminDB.Activities,
'activity_laps_table' : GarminDB.ActivityLaps,
'activity_records_table' : GarminDB.ActivityRecords,
'run_activities_table' : GarminDB.StepsActivities,
'paddle_activities_table' : GarminDB.PaddleActivities,
'cycle_activities_table' : GarminDB.CycleActivities,
'elliptical_activities_table' : GarminDB.EllipticalActivities
}
super().setUpClass(cls.garmin_act_db, table_dict, {GarminDB.Activities : [GarminDB.Activities.name]})
cls.test_db_params = GarminDBConfigManager.get_db_params(test_db=True)
cls.test_mon_db = GarminDB.GarminDB(cls.test_db_params)
cls.test_act_db = GarminDB.ActivitiesDB(cls.test_db_params)
cls.measurement_system = Fit.field_enums.DisplayMeasure.statute
def graph_date(self, date):
"""Generate a graph for the given date."""
if date is None:
date = (datetime.datetime.now() - datetime.timedelta(days=1)).date()
db_params = GarminDBConfigManager.get_db_params()
mon_db = GarminDB.MonitoringDB(db_params, self.debug)
start_ts = datetime.datetime.combine(date, datetime.datetime.min.time())
end_ts = datetime.datetime.combine(date, datetime.datetime.max.time())
hr_data = GarminDB.MonitoringHeartRate.get_for_period(mon_db, start_ts, end_ts, GarminDB.MonitoringHeartRate)
data = GarminDB.Monitoring.get_for_period(mon_db, start_ts, end_ts, GarminDB.Monitoring)
over_data_dict = [
{
'label' : 'Cumulative Steps',
'time' : [entry.timestamp for entry in data],
'data' : self.__format_steps(data),
},
{
'label' : 'Heart Rate',
'time' : [entry.timestamp for entry in hr_data],
'data' : [entry.heart_rate for entry in hr_data],
'limits' : (30, 220)
}
]
under_data_dict = {
'time' : [entry.timestamp for entry in data],
'data' : self.__remove_discontinuities([entry.intensity for entry in data]),
'limits' : (0, 10)
}
# self.__graph_day(date, (hr_time, hr), (mon_time, activity), self.save)
save_name = f"{date}_daily.png" if self.save else None
self.__graph_over(date, over_data_dict, under_data_dict, f'Daily Summary for {date}: Heart Rate and Steps over Activity',
'Time of Day', 'heart rate', save_name=save_name)
def export_activity(debug, directory, export_activity_id):
"""Export an activity given its database id."""
db_params_dict = GarminDBConfigManager.get_db_params()
garmindb = GarminDB.GarminDB(db_params_dict)
measurement_system = GarminDB.Attributes.measurements_type(garmindb)
ae = ActivityExporter(directory, export_activity_id, measurement_system, debug)
ae.process(db_params_dict)
return ae.write('activity_%s.tcx' % export_activity_id)
def analyze_data(debug):
"""Analyze the downloaded and imported Garmin data and create summary tables."""
logger.info("___Analyzing Data___")
db_params_dict = GarminDBConfigManager.get_db_params()
analyze = Analyze(db_params_dict, debug - 1)
analyze.get_stats()
analyze.summary()
analyze.create_dynamic_views()
def test_fit_file_import(self):
db_params = GarminDBConfigManager.get_db_params(test_db=True)
self.profile_function('fit_mon_import', self.fit_file_import, db_params)
test_mon_db = GarminDB.GarminDB(db_params)
self.check_db_tables_exists(test_mon_db, {'device_table' : GarminDB.Device})
self.check_db_tables_exists(test_mon_db, {'file_table' : GarminDB.File, 'device_info_table' : GarminDB.DeviceInfo}, self.gfd_file_count)
table_not_none_cols_dict = {GarminDB.Monitoring : [GarminDB.Monitoring.timestamp, GarminDB.Monitoring.activity_type, GarminDB.Monitoring.duration]}
self.check_not_none_cols(GarminDB.MonitoringDB(db_params), table_not_none_cols_dict)
def delete_dbs(debug):
"""Delete all GarminDB database files."""
db_params_dict = GarminDBConfigManager.get_db_params()
GarminDB.GarminDB.delete_db(db_params_dict)
GarminDB.MonitoringDB.delete_db(db_params_dict)
GarminDB.ActivitiesDB.delete_db(db_params_dict)
GarminDB.GarminSummaryDB.delete_db(db_params_dict)
HealthDB.SummaryDB.delete_db(db_params_dict)
def test_summary_json_file_import(self):
db_params_dict = GarminDBConfigManager.get_db_params(test_db=True)
gjsd = GarminJsonSummaryData(db_params_dict, 'test_files/json/activity/summary', latest=False, measurement_system=Fit.field_enums.DisplayMeasure.statute, debug=2)
if gjsd.file_count() > 0:
gjsd.process()
self.check_not_none_cols(GarminDB.ActivitiesDB(db_params_dict),
{GarminDB.Activities : [GarminDB.Activities.name, GarminDB.Activities.type, GarminDB.Activities.sport, GarminDB.Activities.sub_sport]}
)
def test_fit_file_import(self):
db_params_dict = GarminDBConfigManager.get_db_params(test_db=True)
self.profile_function('fit_activities_import', self.fit_file_import, db_params_dict)
test_mon_db = GarminDB.GarminDB(db_params_dict)
self.check_db_tables_exists(test_mon_db, {'device_table' : GarminDB.Device})
self.check_db_tables_exists(test_mon_db, {'file_table' : GarminDB.File, 'device_info_table' : GarminDB.DeviceInfo}, self.gfd_file_count)
self.check_not_none_cols(GarminDB.ActivitiesDB(db_params_dict),
{GarminDB.Activities : [GarminDB.Activities.start_time, GarminDB.Activities.stop_time, GarminDB.Activities.elapsed_time]}
)
def test_summary_json_file_import(self):
db_params = GarminDBConfigManager.get_db_params(test_db=True)
gjsd = GarminSummaryData(db_params, 'test_files/json/monitoring/summary', latest=False, measurement_system=Fit.field_enums.DisplayMeasure.statute, debug=2)
if gjsd.file_count() > 0:
gjsd.process()
table_not_none_cols_dict = {
GarminDB.DailySummary : [GarminDB.DailySummary.rhr, GarminDB.DailySummary.distance, GarminDB.DailySummary.steps, GarminDB.DailySummary.floors_goal]
}
self.check_not_none_cols(GarminDB.GarminDB(db_params), table_not_none_cols_dict)
def test_fit_file_import(self):
db_params_dict = GarminDBConfigManager.get_db_params(test_db=True)
gfd = GarminActivitiesFitData(
'test_files/fit/activity',
latest=False,
measurement_system=Fit.field_enums.DisplayMeasure.statute,
debug=2)
if gfd.file_count() > 0:
gfd.process_files(db_params_dict)
def setUpClass(cls):
db_params = GarminDBConfigManager.get_db_params()
db = GarminDB.GarminSummaryDB(db_params)
table_dict = {
'summary_table' : GarminDB.Summary,
'months_table' : GarminDB.MonthsSummary,
'weeks_table' : GarminDB.WeeksSummary,
'days_table' : GarminDB.DaysSummary
}
super().setUpClass(db, table_dict)
def test_parse_uprofile(self):
db_params = GarminDBConfigManager.get_db_params(test_db=True)
gp = GarminProfile(db_params, self.file_path, debug=2)
if gp.file_count() > 0:
gp.process()
garmindb = GarminDB.GarminDB(db_params)
measurement_system = GarminDB.Attributes.measurements_type(garmindb)
self.assertEqual(
measurement_system, Fit.field_enums.DisplayMeasure.statute,
'DisplayMeasure expected %r found %r' %
(Fit.field_enums.DisplayMeasure.statute, measurement_system))
def setUpClass(cls):
db_params_dict = GarminDBConfigManager.get_db_params()
garmin_mon_db = GarminDB.MonitoringDB(db_params_dict)
super(TestMonitoringDB, cls).setUpClass(
garmin_mon_db, {
'monitoring_info_table': GarminDB.MonitoringInfo,
'monitoring_hr_table': GarminDB.MonitoringHeartRate,
'monitoring_intensity_table': GarminDB.MonitoringIntensity,
'monitoring_climb_table': GarminDB.MonitoringClimb,
'monitoring_table': GarminDB.Monitoring,
})
def setUpClass(cls):
db_params = GarminDBConfigManager.get_db_params()
cls.garmin_mon_db = GarminDB.MonitoringDB(db_params)
table_dict = {
'monitoring_info_table' : GarminDB.MonitoringInfo,
'monitoring_hr_table' : GarminDB.MonitoringHeartRate,
'monitoring_intensity_table' : GarminDB.MonitoringIntensity,
'monitoring_climb_table' : GarminDB.MonitoringClimb,
'monitoring_table' : GarminDB.Monitoring,
}
super().setUpClass(cls.garmin_mon_db, table_dict)
def main(argv):
"""Import and analyze Microsoft Health data."""
parser = argparse.ArgumentParser()
parser.add_argument("-v",
"--version",
help="print the program's version",
action='version',
version=format_version(sys.argv[0]))
parser.add_argument("-t",
"--trace",
help="Turn on debug tracing",
type=int,
default=0)
modes_group = parser.add_argument_group('Modes')
modes_group.add_argument(
"-i",
"--input_file",
help="Specifiy the CSV file to import into the database")
modes_group.add_argument("--delete_db",
help="Delete FiBit db file.",
action="store_true",
default=False)
args = parser.parse_args()
root_logger = logging.getLogger()
if args.trace:
root_logger.setLevel(logging.DEBUG)
else:
root_logger.setLevel(logging.INFO)
db_params = GarminDBConfigManager.get_db_params()
if args.delete_db:
MSHealthDB.MSHealthDB.delete_db(db_params)
sys.exit()
mshealth_dir = GarminDBConfigManager.get_or_create_mshealth_dir()
metric = GarminDBConfigManager.get_metric()
msd = MSHealthData(args.input_file, mshealth_dir, db_params, metric,
args.trace)
if msd.file_count() > 0:
msd.process_files()
mshv = MSVaultData(args.input_file, mshealth_dir, db_params, metric,
args.trace)
if mshv.file_count() > 0:
mshv.process_files()
analyze = Analyze(db_params)
analyze.get_years()
analyze.summary()
def download_data(overwite, latest, stats):
"""Download selected activity types from Garmin Connect and save the data in files. Overwrite previously downloaded data if indicated."""
logger.info("___Downloading %s Data___", 'Latest' if latest else 'All')
db_params_dict = GarminDBConfigManager.get_db_params()
download = Download()
if not download.login():
logger.error("Failed to login!")
sys.exit()
if Statistics.activities in stats:
if latest:
activity_count = gc_config.latest_activity_count()
else:
activity_count = gc_config.all_activity_count()
activities_dir = GarminDBConfigManager.get_or_create_activities_dir()
root_logger.info("Fetching %d activities to %s", activity_count, activities_dir)
download.get_activity_types(activities_dir, overwite)
download.get_activities(activities_dir, activity_count, overwite)
if Statistics.monitoring in stats:
date, days = __get_date_and_days(GarminDB.MonitoringDB(db_params_dict), latest, GarminDB.MonitoringHeartRate, GarminDB.MonitoringHeartRate.heart_rate, 'monitoring')
if days > 0:
root_logger.info("Date range to update: %s (%d) to %s", date, days, GarminDBConfigManager.get_monitoring_base_dir())
download.get_daily_summaries(GarminDBConfigManager.get_or_create_monitoring_dir, date, days, overwite)
download.get_hydration(GarminDBConfigManager.get_or_create_monitoring_dir, date, days, overwite)
download.get_monitoring(GarminDBConfigManager.get_or_create_monitoring_dir, date, days)
root_logger.info("Saved monitoring files for %s (%d) to %s for processing", date, days, GarminDBConfigManager.get_monitoring_base_dir())
if Statistics.sleep in stats:
date, days = __get_date_and_days(GarminDB.GarminDB(db_params_dict), latest, GarminDB.Sleep, GarminDB.Sleep.total_sleep, 'sleep')
if days > 0:
sleep_dir = GarminDBConfigManager.get_or_create_sleep_dir()
root_logger.info("Date range to update: %s (%d) to %s", date, days, sleep_dir)
download.get_sleep(sleep_dir, date, days, overwite)
root_logger.info("Saved sleep files for %s (%d) to %s for processing", date, days, sleep_dir)
if Statistics.weight in stats:
date, days = __get_date_and_days(GarminDB.GarminDB(db_params_dict), latest, GarminDB.Weight, GarminDB.Weight.weight, 'weight')
if days > 0:
weight_dir = GarminDBConfigManager.get_or_create_weight_dir()
root_logger.info("Date range to update: %s (%d) to %s", date, days, weight_dir)
download.get_weight(weight_dir, date, days, overwite)
root_logger.info("Saved weight files for %s (%d) to %s for processing", date, days, weight_dir)
if Statistics.rhr in stats:
date, days = __get_date_and_days(GarminDB.GarminDB(db_params_dict), latest, GarminDB.RestingHeartRate, GarminDB.RestingHeartRate.resting_heart_rate, 'rhr')
if days > 0:
rhr_dir = GarminDBConfigManager.get_or_create_rhr_dir()
root_logger.info("Date range to update: %s (%d) to %s", date, days, rhr_dir)
download.get_rhr(rhr_dir, date, days, overwite)
root_logger.info("Saved rhr files for %s (%d) to %s for processing", date, days, rhr_dir)
def main(argv):
"""Import and analyze Microsoft Health data."""
debug = False
input_file = None
_delete_db = False
try:
opts, args = getopt.getopt(
argv, "hi:t", ["help", "delete_db", "trace", "input_file="])
except getopt.GetoptError:
print "Bad argument"
__usage(sys.argv[0])
for opt, arg in opts:
if opt == '-h':
__usage(sys.argv[0])
elif opt in ("--delete_db"):
logging.debug("Delete DB")
_delete_db = True
elif opt in ("-t", "--trace"):
logger.info("Trace:")
debug = True
elif opt in ("-i", "--input_file"):
logger.info("Input File: %s" % arg)
input_file = arg
root_logger = logging.getLogger()
if debug:
root_logger.setLevel(logging.DEBUG)
else:
root_logger.setLevel(logging.INFO)
db_params_dict = GarminDBConfigManager.get_db_params()
if _delete_db:
MSHealthDB.MSHealthDB.delete_db(db_params_dict)
sys.exit()
mshealth_dir = GarminDBConfigManager.get_or_create_mshealth_dir()
metric = GarminDBConfigManager.get_metric()
msd = MSHealthData(input_file, mshealth_dir, db_params_dict, metric, debug)
if msd.file_count() > 0:
msd.process_files()
mshv = MSVaultData(input_file, mshealth_dir, db_params_dict, metric, debug)
if mshv.file_count() > 0:
mshv.process_files()
analyze = Analyze(db_params_dict)
analyze.get_years()
analyze.summary()
def setUpClass(cls):
db_params_dict = GarminDBConfigManager.get_db_params()
cls.garmin_act_db = GarminDB.ActivitiesDB(db_params_dict)
super(TestActivitiesDb, cls).setUpClass(
cls.garmin_act_db, {
'activities_table': GarminDB.Activities,
'activity_laps_table': GarminDB.ActivityLaps,
'activity_records_table': GarminDB.ActivityRecords,
'run_activities_table': GarminDB.StepsActivities,
'paddle_activities_table': GarminDB.PaddleActivities,
'cycle_activities_table': GarminDB.CycleActivities,
'elliptical_activities_table': GarminDB.EllipticalActivities
}, {GarminDB.Activities: [GarminDB.Activities.name]})
def setUpClass(cls):
db_params_dict = GarminDBConfigManager.get_db_params()
cls.garmindb = GarminDB.GarminDB(db_params_dict)
super(TestGarminDb, cls).setUpClass(
cls.garmindb, {
'attributes_table': GarminDB.Attributes,
'device_table': GarminDB.Device,
'device_info_table': GarminDB.DeviceInfo,
'file_table': GarminDB.File,
'weight_table': GarminDB.Weight,
'stress_table': GarminDB.Stress,
'sleep_table': GarminDB.Sleep,
'sleep_events_table': GarminDB.SleepEvents,
'resting_heart_rate_table': GarminDB.RestingHeartRate
})
def main(argv):
"""Import into a DB and summarize CSV formatted FitBit export data."""
debug = False
input_file = None
_delete_db = False
try:
opts, args = getopt.getopt(argv, "dhi:", ["debug", "delete_db", "input_file="])
except getopt.GetoptError:
usage(sys.argv[0])
for opt, arg in opts:
if opt == '-h':
usage(sys.argv[0])
elif opt in ("-d", "--debug"):
debug = True
elif opt in ("--delete_db"):
logging.debug("Delete DB")
_delete_db = True
elif opt in ("-i", "--input_file"):
logging.debug("Input File: %s" % arg)
input_file = arg
root_logger = logging.getLogger()
if debug:
root_logger.setLevel(logging.DEBUG)
else:
root_logger.setLevel(logging.INFO)
db_params_dict = GarminDBConfigManager.get_db_params()
if _delete_db:
FitBitDB.FitBitDB.delete_db(db_params_dict)
sys.exit()
fitbit_dir = GarminDBConfigManager.get_or_create_fitbit_dir()
metric = GarminDBConfigManager.get_metric()
fd = FitBitData(input_file, fitbit_dir, db_params_dict, metric, debug)
if fd.file_count() > 0:
fd.process_files()
analyze = Analyze(db_params_dict)
analyze.get_years()
analyze.summary()
def graph_activity(self, activity, period, days):
"""Generate a graph for the given activity with points every period spanning days."""
if period is None or period == 'default':
period = GarminDBConfigManager.graphs_activity_config(activity, 'period')
if days is None or days == 'default':
days = GarminDBConfigManager.graphs_activity_config(activity, 'days')
db_params_dict = GarminDBConfigManager.get_db_params()
sum_db = HealthDB.SummaryDB(db_params_dict, self.debug)
end_ts = datetime.datetime.now()
start_ts = end_ts - datetime.timedelta(days=days)
table = self.__table[period]
data = table.get_for_period(sum_db, table, start_ts, end_ts)
if period == 'days':
time = [entry.day for entry in data]
else:
time = [entry.first_day for entry in data]
graph_func_name = '_graph_' + activity
graph_func = getattr(self, graph_func_name, None)
graph_func(time, data, period)
def download_data(overwrite, latest, weight, monitoring, sleep, rhr,
activities):
"""Download selected activity types from Garmin Connect and save the data in files. Overwrite previously downloaded data if indicated."""
db_params_dict = GarminDBConfigManager.get_db_params()
download = Download()
if not download.login():
logger.error("Failed to login!")
sys.exit()
if activities:
if latest:
activity_count = gc_gonfig.latest_activity_count()
else:
activity_count = gc_gonfig.all_activity_count()
activities_dir = GarminDBConfigManager.get_or_create_activities_dir()
root_logger.info("Fetching %d activities to %s", activity_count,
activities_dir)
download.get_activity_types(activities_dir, overwrite)
download.get_activities(activities_dir, activity_count, overwrite)
download.unzip_files(activities_dir)
if monitoring:
date, days = __get_date_and_days(
GarminDB.MonitoringDB(db_params_dict), latest,
GarminDB.MonitoringHeartRate,
GarminDB.MonitoringHeartRate.heart_rate, 'monitoring')
if days > 0:
monitoring_dir = GarminDBConfigManager.get_or_create_monitoring_dir(
date.year)
root_logger.info("Date range to update: %s (%d) to %s", date, days,
monitoring_dir)
download.get_daily_summaries(monitoring_dir, date, days, overwrite)
download.get_monitoring(date, days)
download.unzip_files(monitoring_dir)
root_logger.info(
"Saved monitoring files for %s (%d) to %s for processing",
date, days, monitoring_dir)
if sleep:
date, days = __get_date_and_days(GarminDB.GarminDB(db_params_dict),
latest, GarminDB.Sleep,
GarminDB.Sleep.total_sleep, 'sleep')
if days > 0:
sleep_dir = GarminDBConfigManager.get_or_create_sleep_dir()
root_logger.info("Date range to update: %s (%d) to %s", date, days,
sleep_dir)
download.get_sleep(sleep_dir, date, days, overwrite)
root_logger.info(
"Saved sleep files for %s (%d) to %s for processing", date,
days, sleep_dir)
if weight:
date, days = __get_date_and_days(GarminDB.GarminDB(db_params_dict),
latest, GarminDB.Weight,
GarminDB.Weight.weight, 'weight')
if days > 0:
weight_dir = GarminDBConfigManager.get_or_create_weight_dir()
root_logger.info("Date range to update: %s (%d) to %s", date, days,
weight_dir)
download.get_weight(weight_dir, date, days, overwrite)
root_logger.info(
"Saved weight files for %s (%d) to %s for processing", date,
days, weight_dir)
if rhr:
date, days = __get_date_and_days(
GarminDB.GarminDB(db_params_dict), latest,
GarminDB.RestingHeartRate,
GarminDB.RestingHeartRate.resting_heart_rate, 'rhr')
if days > 0:
rhr_dir = GarminDBConfigManager.get_or_create_rhr_dir()
root_logger.info("Date range to update: %s (%d) to %s", date, days,
rhr_dir)
download.get_rhr(rhr_dir, date, days, overwrite)
root_logger.info(
"Saved rhr files for %s (%d) to %s for processing", date, days,
rhr_dir)
def setUpClass(cls):
cls.db_params_dict = GarminDBConfigManager.get_db_params(test_db=True)
def __init__(self, debug):
"""Return an instance of the CheckUp class."""
self.db_params_dict = GarminDBConfigManager.get_db_params()
self.debug = debug
def import_data(debug, latest, stats):
"""Import previously downloaded Garmin data into the database."""
logger.info("___Importing %s Data___", 'Latest' if latest else 'All')
db_params_dict = GarminDBConfigManager.get_db_params()
ignore_dev_fields = gc_config.ignore_dev_fields()
# Import the user profile and/or settings FIT file first so that we can get the measurement system and some other things sorted out first.
fit_files_dir = GarminDBConfigManager.get_or_create_fit_files_dir()
gp = GarminProfile(db_params_dict, fit_files_dir, debug)
if gp.file_count() > 0:
gp.process()
gsfd = GarminSettingsFitData(fit_files_dir, ignore_dev_fields, debug)
if gsfd.file_count() > 0:
gsfd.process_files(db_params_dict)
garmindb = GarminDB.GarminDB(db_params_dict)
measurement_system = GarminDB.Attributes.measurements_type(garmindb)
if Statistics.weight in stats:
weight_dir = GarminDBConfigManager.get_or_create_weight_dir()
gwd = GarminWeightData(db_params_dict, weight_dir, latest, measurement_system, debug)
if gwd.file_count() > 0:
gwd.process()
if Statistics.monitoring in stats:
monitoring_dir = GarminDBConfigManager.get_or_create_monitoring_base_dir()
gsd = GarminSummaryData(db_params_dict, monitoring_dir, latest, measurement_system, debug)
if gsd.file_count() > 0:
gsd.process()
ghd = GarminHydrationData(db_params_dict, monitoring_dir, latest, measurement_system, debug)
if ghd.file_count() > 0:
ghd.process()
gfd = GarminMonitoringFitData(monitoring_dir, latest, measurement_system, ignore_dev_fields, debug)
if gfd.file_count() > 0:
gfd.process_files(db_params_dict)
if Statistics.sleep in stats:
sleep_dir = GarminDBConfigManager.get_or_create_sleep_dir()
gsd = GarminSleepData(db_params_dict, sleep_dir, latest, debug)
if gsd.file_count() > 0:
gsd.process()
if Statistics.rhr in stats:
rhr_dir = GarminDBConfigManager.get_or_create_rhr_dir()
grhrd = GarminRhrData(db_params_dict, rhr_dir, latest, debug)
if grhrd.file_count() > 0:
grhrd.process()
if Statistics.activities in stats:
activities_dir = GarminDBConfigManager.get_or_create_activities_dir()
# Tcx fields are less precise than the JSON files, so load Tcx first and overwrite with better JSON values.
gtd = GarminTcxData(activities_dir, latest, measurement_system, debug)
if gtd.file_count() > 0:
gtd.process_files(db_params_dict)
gjsd = GarminJsonSummaryData(db_params_dict, activities_dir, latest, measurement_system, debug)
if gjsd.file_count() > 0:
gjsd.process()
gdjd = GarminJsonDetailsData(db_params_dict, activities_dir, latest, measurement_system, debug)
if gdjd.file_count() > 0:
gdjd.process()
gfd = GarminActivitiesFitData(activities_dir, latest, measurement_system, ignore_dev_fields, debug)
if gfd.file_count() > 0:
gfd.process_files(db_params_dict)
def import_data(debug, test, latest, weight, monitoring, sleep, rhr,
activities):
"""Import previously downloaded Garmin data into the database."""
db_params_dict = GarminDBConfigManager.get_db_params(test_db=test)
gp = GarminProfile(db_params_dict,
GarminDBConfigManager.get_fit_files_dir(), debug)
if gp.file_count() > 0:
gp.process()
garmindb = GarminDB.GarminDB(db_params_dict)
measurement_system = GarminDB.Attributes.measurements_type(garmindb)
if weight:
weight_dir = GarminDBConfigManager.get_weight_dir()
gwd = GarminWeightData(db_params_dict, weight_dir, latest,
measurement_system, debug)
if gwd.file_count() > 0:
gwd.process()
if monitoring:
monitoring_dir = GarminDBConfigManager.get_monitoring_base_dir()
gsd = GarminSummaryData(db_params_dict, monitoring_dir, latest,
measurement_system, debug)
if gsd.file_count() > 0:
gsd.process()
ged = GarminMonitoringExtraData(db_params_dict, monitoring_dir, latest,
debug)
if ged.file_count() > 0:
ged.process()
gfd = GarminMonitoringFitData(monitoring_dir, latest,
measurement_system, debug)
if gfd.file_count() > 0:
gfd.process_files(db_params_dict)
if sleep:
sleep_dir = GarminDBConfigManager.get_sleep_dir()
gsd = GarminSleepData(db_params_dict, sleep_dir, latest, debug)
if gsd.file_count() > 0:
gsd.process()
if rhr:
rhr_dir = GarminDBConfigManager.get_rhr_dir()
grhrd = GarminRhrData(db_params_dict, rhr_dir, latest, debug)
if grhrd.file_count() > 0:
grhrd.process()
if activities:
activities_dir = GarminDBConfigManager.get_activities_dir()
gjsd = GarminJsonSummaryData(db_params_dict, activities_dir, latest,
measurement_system, debug)
if gjsd.file_count() > 0:
gjsd.process()
gdjd = GarminJsonDetailsData(db_params_dict, activities_dir, latest,
measurement_system, debug)
if gdjd.file_count() > 0:
gdjd.process()
ged = GarminActivitiesExtraData(db_params_dict, activities_dir, latest,
debug)
if ged.file_count() > 0:
ged.process()
gtd = GarminTcxData(activities_dir, latest, measurement_system, debug)
if gtd.file_count() > 0:
gtd.process_files(db_params_dict)
gfd = GarminActivitiesFitData(activities_dir, latest,
measurement_system, debug)
if gfd.file_count() > 0:
gfd.process_files(db_params_dict)
def analyze_data(debug):
"""Analyze the downloaded and imported Garmin data and create summary tables."""
db_params_dict = GarminDBConfigManager.get_db_params()
analyze = Analyze(db_params_dict, debug - 1)
analyze.get_stats()
analyze.summary()
def setUpClass(cls):
cls.db_params = GarminDBConfigManager.get_db_params(test_db=True)
cls.garmin_db = GarminDB.GarminDB(cls.db_params)
