def test_garmin_mon_db_steps_bounds(self): garmin_mon_db = GarminDB.MonitoringDB(self.db_params_dict) min = GarminDB.Monitoring.get_col_min(garmin_mon_db, GarminDB.Monitoring.steps) self.assertGreater(min, 0) max = GarminDB.Monitoring.get_col_max(garmin_mon_db, GarminDB.Monitoring.steps) self.assertGreater(max, 0) self.assertLess(max, 100000)
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 test_garmin_mon_db_tables_exists(self): garmin_mon_db = GarminDB.MonitoringDB(self.db_params_dict) self.assertGreater(GarminDB.MonitoringInfo.row_count(garmin_mon_db), 0) self.assertGreater(GarminDB.MonitoringHeartRate.row_count(garmin_mon_db), 0) self.assertGreater(GarminDB.MonitoringIntensity.row_count(garmin_mon_db), 0) self.assertGreater(GarminDB.MonitoringClimb.row_count(garmin_mon_db), 0) self.assertGreater(GarminDB.Monitoring.row_count(garmin_mon_db), 0)
def __init__(self, db_params_dict, debug): self.garmindb = GarminDB.GarminDB(db_params_dict, debug) self.mondb = GarminDB.MonitoringDB(db_params_dict, debug) self.garminsumdb = GarminDB.GarminSummaryDB(db_params_dict, debug) self.sumdb = HealthDB.SummaryDB(db_params_dict, debug) self.garmin_act_db = GarminDB.ActivitiesDB(db_params_dict, debug) self.english_units = (GarminDB.Attributes.get( self.garmindb, 'dist_setting') == 'statute')
def __init__(self, db_params_dict, debug): self.garmindb = GarminDB.GarminDB(db_params_dict, debug) self.mondb = GarminDB.MonitoringDB(db_params_dict, debug) self.garminsumdb = GarminDB.GarminSummaryDB(db_params_dict, debug) self.sumdb = HealthDB.SummaryDB(db_params_dict, debug) self.garmin_act_db = GarminDB.ActivitiesDB(db_params_dict, debug) self.english_units = (GarminDB.Attributes.measurements_type_metric( self.garmindb) == False)
def __init__(self, db_params_dict, debug): self.garmin_db = GarminDB.GarminDB(db_params_dict, debug) self.garmin_mon_db = GarminDB.MonitoringDB(db_params_dict, debug) self.garmin_sum_db = GarminDB.GarminSummaryDB(db_params_dict, debug) self.sum_db = HealthDB.SummaryDB(db_params_dict, debug) self.garmin_act_db = GarminDB.ActivitiesDB(db_params_dict, debug) self.measurement_system = GarminDB.Attributes.measurements_type( self.garmin_db)
def __init__(self, db_params_dict, debug): """Return an instance of the Analyze class.""" self.garmin_db = GarminDB.GarminDB(db_params_dict, debug) self.garmin_mon_db = GarminDB.MonitoringDB(db_params_dict, debug) self.garmin_sum_db = GarminDB.GarminSummaryDB(db_params_dict, debug) self.sum_db = HealthDB.SummaryDB(db_params_dict, debug) self.garmin_act_db = GarminDB.ActivitiesDB(db_params_dict, debug) self.measurement_system = GarminDB.Attributes.measurements_type(self.garmin_db)
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 __init__(self, db_params_dict, debug): logger.info("Debug: %s", str(debug)) self.db_params_dict = db_params_dict self.debug = debug self.garmin_db = GarminDB.GarminDB(db_params_dict, debug - 1) self.garmin_mon_db = GarminDB.MonitoringDB(self.db_params_dict, self.debug - 1) self.garmin_act_db = GarminDB.ActivitiesDB(self.db_params_dict, self.debug - 1)
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 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 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 __init__(self, db_params, debug): """ Return a new FitFileProcessor instance. Paramters: db_params (dict): database access configuration debug (Boolean): if True, debug logging is enabled """ root_logger.info("Debug: %s", debug) self.debug = debug self.garmin_db = GarminDB.GarminDB(db_params, debug - 1) self.garmin_mon_db = GarminDB.MonitoringDB(db_params, self.debug - 1) self.garmin_act_db = GarminDB.ActivitiesDB(db_params, self.debug - 1)
def __init__(self, db_params_dict, english_units, debug): self.db_params_dict = db_params_dict self.english_units = english_units self.debug = debug self.garmin_db = GarminDB.GarminDB(db_params_dict, debug - 1) self.garmin_mon_db = GarminDB.MonitoringDB(self.db_params_dict, self.debug - 1) self.garmin_act_db = GarminDB.ActivitiesDB(self.db_params_dict, self.debug - 1) if english_units: GarminDB.Attributes.set_newer(self.garmin_db, 'dist_setting', 'statute') else: GarminDB.Attributes.set_newer(self.garmin_db, 'dist_setting', 'metric') logger.info("Debug: %s English units: %s" % (str(debug), str(english_units)))
def __init__(self, db_params, plugin_manager, ignore_dev_fields=False, debug=0): """ Return a new FitFileProcessor instance. Paramters: db_params (dict): database access configuration ignore_dev_fields (Boolean): If True, then ignore develoepr fields in Fit files debug (Boolean): if True, debug logging is enabled """ root_logger.info("Ignore dev fields: %s Debug: %s", ignore_dev_fields, debug) super().__init__(db_params, plugin_manager, ignore_dev_fields, debug) self.garmin_mon_db = GarminDB.MonitoringDB(db_params, self.debug - 1)
def __init__(self, db_params, ignore_dev_fields, debug): """ Return a new FitFileProcessor instance. Paramters: db_params (dict): database access configuration ignore_dev_fields (Boolean): If True, then ignore develoepr fields in Fit files debug (Boolean): if True, debug logging is enabled """ root_logger.info("Ignore dev fields: %s Debug: %s", ignore_dev_fields, debug) self.debug = debug self.garmin_db = GarminDB.GarminDB(db_params, debug - 1) self.garmin_mon_db = GarminDB.MonitoringDB(db_params, self.debug - 1) self.garmin_act_db = GarminDB.ActivitiesDB(db_params, self.debug - 1) self.ignore_dev_fields = ignore_dev_fields if not self.ignore_dev_fields: self.field_prefixes = ['dev_', ''] else: self.field_prefixes = ['']
def __init__(self, db_params_dict, english_units, debug): self.db_params_dict = db_params_dict self.english_units = english_units self.debug = debug self.garmin_db = GarminDB.GarminDB(db_params_dict, debug - 1) self.garmin_mon_db = GarminDB.MonitoringDB(self.db_params_dict, self.debug - 1) self.garmin_act_db = GarminDB.ActivitiesDB(self.db_params_dict, self.debug - 1) if english_units: GarminDB.Attributes.set_newer( self.garmin_db, 'dist_setting', str(Fit.FieldEnums.DisplayMeasure.statute)) else: GarminDB.Attributes.set_newer( self.garmin_db, 'dist_setting', str(Fit.FieldEnums.DisplayMeasure.metric)) logger.info("Debug: %s English units: %s", str(debug), str(english_units))
def test_garmin_mon_db_exists(self): garmin_mon_db = GarminDB.MonitoringDB(self.db_params_dict) self.assertIsNotNone(garmin_mon_db)
def main(argv): date = None days = None latest = False db_params_dict = {} username = None password = None profile = None activities = None activity_count = 1000 activity_types = False monitoring = None overwite = False weight = None rhr = None sleep = None debug = 0 try: opts, args = getopt.getopt(argv, "a:c:d:n:lm:oP:p:r:S:s:t:u:w:", [ "activities=", "activity_count=", "date=", "days=", "username="******"password="******"profile=", "latest", "monitoring=", "mysql=", "overwrite", "rhr=", "sqlite=", "sleep=", "trace=", "weight=" ]) except getopt.GetoptError: usage(sys.argv[0]) for opt, arg in opts: if opt == '-h': usage(sys.argv[0]) elif opt in ("-a", "--activities"): logger.debug("Activities: " + arg) activities = arg elif opt in ("-c", "--activity_count"): logger.debug("Activity count: " + arg) activity_count = int(arg) elif opt in ("-t", "--trace"): debug = int(arg) elif opt in ("-d", "--date"): logger.debug("Date: " + arg) date = dateutil.parser.parse(arg).date() elif opt in ("-n", "--days"): logger.debug("Days: " + arg) days = int(arg) elif opt in ("-l", "--latest"): logger.debug("Latest") latest = True elif opt in ("-u", "--username"): logger.debug("Username: "******"-p", "--password"): logger.debug("Password: "******"-P", "--profile"): logger.info("Profile: " + arg) profile = arg elif opt in ("-m", "--monitoring"): logger.debug("Monitoring: " + arg) monitoring = arg elif opt in ("-o", "--overwite"): overwite = True elif opt in ("-S", "--sleep"): logger.debug("Sleep: " + arg) sleep = arg elif opt in ("-w", "--weight"): logger.debug("Weight") weight = arg elif opt in ("-r", "--rhr"): logger.debug("Resting heart rate") rhr = arg elif opt in ("-s", "--sqlite"): logging.debug("Sqlite DB path: %s" % arg) db_params_dict['db_type'] = 'sqlite' db_params_dict['db_path'] = arg elif opt in ("--mysql"): logging.debug("Mysql DB string: %s" % arg) db_args = arg.split(',') db_params_dict['db_type'] = 'mysql' db_params_dict['db_username'] = db_args[0] db_params_dict['db_password'] = db_args[1] db_params_dict['db_host'] = db_args[2] if debug > 0: root_logger.setLevel(logging.DEBUG) else: root_logger.setLevel(logging.INFO) if ((not date or not days) and not latest) and (monitoring or sleep): print "Missing arguments: specify date and days or latest when downloading monitoring or sleep data" usage(sys.argv[0]) if not username or not password: print "Missing arguments: need username and password" usage(sys.argv[0]) if len(db_params_dict) == 0 and monitoring and latest: print "Missing arguments: must specify <db params> with --sqlite or --mysql" usage(sys.argv[0]) download = Download() if not download.login(username, password, profile): sys.exit() if activities and activity_count > 0: logger.info("Fetching %d activities" % activity_count) download.get_activity_types(activities) download.get_activities(activities, activity_count, overwite) download.unzip_files(activities) if latest and monitoring: mondb = GarminDB.MonitoringDB(db_params_dict) last_ts = GarminDB.Monitoring.latest_time(mondb) if last_ts is None: days = 31 date = datetime.datetime.now().date() - datetime.timedelta(days) logger.info("Automatic date not found, using: " + str(date)) else: # start from the day after the last day in the DB logger.info("Automatically downloading monitoring data from: " + str(last_ts)) date = last_ts.date() + datetime.timedelta(1) days = (datetime.datetime.now().date() - date).days if latest and sleep: garmindb = GarminDB.GarminDB(db_params_dict) last_ts = GarminDB.Sleep.latest_time(garmindb) if last_ts is None: days = 31 date = datetime.datetime.now().date() - datetime.timedelta(days) logger.info("Automatic date not found, using: " + str(date)) else: # start from the day after the last day in the DB logger.info("Automatically downloading sleep data from: " + str(last_ts)) date = last_ts + datetime.timedelta(1) days = (datetime.datetime.now().date() - date).days if latest and weight: garmindb = GarminDB.GarminDB(db_params_dict) last_ts = GarminDB.Weight.latest_time(garmindb) date = datetime.datetime.now() if last_ts is None: days = 31 logger.info("Automatic date not found, using: " + str(date)) else: # start from the day after the last day in the DB logger.info("Automatically downloading weight data from: " + str(last_ts)) days = (date - last_ts).days if latest and rhr: garmindb = GarminDB.GarminDB(db_params_dict) last_ts = GarminDB.RestingHeartRate.latest_time(garmindb) date = datetime.datetime.now().date() if last_ts is None: days = 31 logger.info("Automatic date not found, using: " + str(date)) else: # start from the day after the last day in the DB logger.info("Automatically downloading rhr data from: " + str(last_ts)) days = (date - last_ts).days if monitoring and days > 0: logger.info("Date range to update: %s (%d)" % (str(date), days)) download.get_monitoring(date, days) download.unzip_files(monitoring) logger.info("Saved monitoring files for %s (%d) to %s for processing" % (str(date), days, monitoring)) if sleep and days > 0: logger.info("Date range to update: %s (%d)" % (str(date), days)) download.get_sleep(sleep, date, days) logger.info("Saved sleep files for %s (%d) to %s for processing" % (str(date), days, sleep)) if weight and days > 0: download.get_weight(weight, date, days) if rhr and days > 0: download.get_rhr(rhr, date, days)
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)