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)