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)