def process(self, db_params):
"""Process database data for an activity into a an XML tree in TCX format."""
garmin_act_db = GarminDB.ActivitiesDB(db_params, self.debug - 1)
with garmin_act_db.managed_session() as garmin_act_db_session:
activity = GarminDB.Activities.s_get(garmin_act_db_session,
self.activity_id)
self.tcx = GarminDbTcx()
self.tcx.create(activity.sport, activity.start_time)
laps = GarminDB.ActivityLaps.s_get_activity(
garmin_act_db_session, self.activity_id)
records = GarminDB.ActivityRecords.s_get_activity(
garmin_act_db_session, self.activity_id)
for lap in laps:
distance = Distance.from_meters_or_feet(
lap.distance, self.measurement_system)
track = self.tcx.add_lap(lap.start_time, lap.stop_time,
distance, lap.calories)
for record in records:
if record.timestamp >= lap.start_time and record.timestamp <= lap.stop_time:
alititude = Distance.from_meters_or_feet(
record.altitude, self.measurement_system)
speed = Speed.from_kph_or_mph(record.speed,
self.measurement_system)
self.tcx.add_point(track, record.timestamp,
record.position, alititude,
record.hr, speed)
garmindb = GarminDB.GarminDB(db_params)
with garmindb.managed_session() as garmin_db_session:
file = GarminDB.File.s_get(garmin_db_session, self.activity_id)
device = GarminDB.Device.s_get(garmin_db_session,
file.serial_number)
self.tcx.add_creator(device.product, file.serial_number)
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):
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.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):
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):
"""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_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 __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 process_files(self, db_params_dict):
"""Import data from files into the databse."""
garmin_db = GarminDB.GarminDB(db_params_dict, self.debug - 1)
garmin_act_db = GarminDB.ActivitiesDB(db_params_dict, self.debug)
with garmin_db.managed_session() as self.garmin_db_session:
with garmin_act_db.managed_session() as self.garmin_act_db_session:
for file_name in progressbar.progressbar(self.file_names):
self.__process_file(file_name)
self.garmin_db_session.commit()
self.garmin_act_db_session.commit()
def process_files(self, db_params):
"""Import data from TCX files into the database."""
garmin_db = GarminDB.GarminDB(db_params, self.debug - 1)
garmin_act_db = GarminDB.ActivitiesDB(db_params, self.debug - 1)
with garmin_db.managed_session() as self.garmin_db_session, garmin_act_db.managed_session() as self.garmin_act_db_session:
for file_name in tqdm(self.file_names, unit='files'):
try:
self.__process_file(file_name)
except Exception as e:
logger.error('Failed to processes file %s: %s', file_name, e)
self.garmin_db_session.commit()
self.garmin_act_db_session.commit()
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 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 __init__(self, db_params_dict, input_file, input_dir, latest,
english_units, debug):
GarminJsonData.__init__(self, input_file, input_dir,
'activity_details_\\d*\.json', latest,
english_units, debug)
self.garmin_act_db = GarminDB.ActivitiesDB(db_params_dict,
self.debug - 1)
def __process_record(self, tcx, activity_id, record_number, point):
root_logger.debug("Processing record: %r (%d)", point, record_number)
if not GarminDB.ActivityRecords.s_exists(self.garmin_act_db_session, {
'activity_id': activity_id,
'record': record_number
}):
record = {
'activity_id':
activity_id,
'record':
record_number,
'timestamp':
tcx.get_point_time(point),
'hr':
tcx.get_point_hr(point),
'altitude':
tcx.get_point_altitude(point).meters_or_feet(
measurement_system=self.measurement_system),
'speed':
tcx.get_point_speed(point).kph_or_mph(
measurement_system=self.measurement_system)
}
loc = tcx.get_point_loc(point)
if loc is not None:
record.update({
'position_lat': loc.lat_deg,
'position_long': loc.long_deg
})
self.garmin_act_db_session.add(GarminDB.ActivityRecords(**record))
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_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 __init__(self, db_params, input_dir, latest, measurement_system,
debug):
"""
Return an instance of GarminSummaryData.
Parameters:
----------
db_params (dict): configuration data for accessing the database
input_dir (string): directory (full path) to check for data files
latest (Boolean): check for latest files only
measurement_system (enum): which measurement system to use when importing the files
debug (Boolean): enable debug logging
"""
logger.info("Processing daily summary data")
super().__init__(r'daily_summary_\d{4}-\d{2}-\d{2}\.json',
input_dir=input_dir,
latest=latest,
debug=debug,
recursive=True)
self.input_dir = input_dir
self.measurement_system = measurement_system
self.garmin_db = GarminDB.GarminDB(db_params)
self.conversions = {
'calendarDate': dateutil.parser.parse,
'moderateIntensityMinutes': Fit.conversions.min_to_dt_time,
'vigorousIntensityMinutes': Fit.conversions.min_to_dt_time,
'intensityMinutesGoal': Fit.conversions.min_to_dt_time,
}
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 goals(self):
"""Do a checkup of th euser's goals."""
garmin_db = GarminDB.GarminDB(self.db_params_dict, self.debug)
look_back_days = GarminDBConfigManager.checkup('look_back_days')
end_ts = datetime.now()
start_ts = end_ts - timedelta(days=look_back_days)
results = GarminDB.DailySummary.get_for_period(garmin_db, start_ts,
end_ts)
step_goal_days = 0
floors_goal_days = 0
intensity_days = 0
intensity_weeks = 0
intensity_time_goal_percent = 0
intensity_goal_weeks = 0
for result in results:
if result.steps_goal_percent >= 100:
step_goal_days += 1
if result.floors_goal_percent >= 100:
floors_goal_days += 1
if result.day.weekday() == 0:
intensity_days = 0
intensity_time_goal_percent += result.intensity_time_goal_percent
intensity_days += 1
if result.day.weekday() == 6:
if intensity_days == 7:
intensity_weeks += 1
if intensity_time_goal_percent >= 100:
intensity_goal_weeks += 1
logger.info('Steps: on goal %d of %d days', step_goal_days,
look_back_days)
logger.info('Floors: on goal %d of %d days', floors_goal_days,
look_back_days)
logger.info('Intensity mins: on goal %d of %d weeks',
intensity_goal_weeks, intensity_weeks)
def __init__(self, db_params, input_dir, latest, debug):
"""
Return an instance of GarminSleepData.
Parameters:
----------
db_params (object): configuration data for accessing the database
input_dir (string): directory (full path) to check for sleep data files
latest (Boolean): check for latest files only
debug (Boolean): enable debug logging
"""
logger.info("Processing sleep data")
super().__init__(r'sleep_\d{4}-\d{2}-\d{2}\.json',
input_dir=input_dir,
latest=latest,
debug=debug)
self.garmin_db = GarminDB.GarminDB(db_params)
self.conversions = {
'calendarDate': dateutil.parser.parse,
'sleepTimeSeconds': Fit.conversions.secs_to_dt_time,
'sleepStartTimestampGMT': Fit.conversions.epoch_ms_to_dt,
'sleepEndTimestampGMT': Fit.conversions.epoch_ms_to_dt,
'deepSleepSeconds': Fit.conversions.secs_to_dt_time,
'lightSleepSeconds': Fit.conversions.secs_to_dt_time,
'remSleepSeconds': Fit.conversions.secs_to_dt_time,
'awakeSleepSeconds': Fit.conversions.secs_to_dt_time,
'startGMT': dateutil.parser.parse,
'endGMT': dateutil.parser.parse
}
def _write_record_entry(self, fit_file, message_dict):
# We don't get record data from multiple sources so we don't need to coellesce data in the DB.
# It's fastest to just write the new data out if it doesn't currently exist.
activity_id = GarminDB.File.id_from_path(fit_file.filename)
if not GarminDB.ActivityRecords.s_exists(self.garmin_act_db_session, {
'activity_id': activity_id,
'record': self.record
}):
record = {
'activity_id':
activity_id,
'record':
self.record,
'timestamp':
self.__get_field_value(message_dict, 'timestamp'),
'position_lat':
self.__get_field_value(message_dict, 'position_lat'),
'position_long':
self.__get_field_value(message_dict, 'position_long'),
'distance':
self.__get_field_value(message_dict, 'distance'),
'cadence':
self.__get_field_value(message_dict, 'cadence'),
'hr':
self.__get_field_value(message_dict, 'heart_rate'),
'alititude':
self.__get_field_value(message_dict, 'altitude'),
'speed':
self.__get_field_value(message_dict, 'speed'),
'temperature':
self.__get_field_value(message_dict, 'temperature'),
}
self.garmin_act_db_session.add(GarminDB.ActivityRecords(**record))
self.record += 1
def _write_lap_entry(self, fit_file, message_fields, lap_num):
# we don't get laps data from multiple sources so we don't need to coellesce data in the DB.
# It's fastest to just write new data out if the it doesn't currently exist.
activity_id = GarminDB.File.id_from_path(fit_file.filename)
plugin_lap = self._plugin_dispatch('write_lap_entry', self.garmin_act_db_session, fit_file, activity_id, message_fields, lap_num)
if not GarminDB.ActivityLaps.s_exists(self.garmin_act_db_session, {'activity_id' : activity_id, 'lap' : lap_num}):
lap = {
'activity_id' : GarminDB.File.id_from_path(fit_file.filename),
'lap' : lap_num,
'start_time' : fit_file.utc_datetime_to_local(message_fields.start_time),
'stop_time' : fit_file.utc_datetime_to_local(message_fields.timestamp),
'elapsed_time' : self._get_field_value(message_fields, 'total_elapsed_time'),
'moving_time' : self._get_field_value(message_fields, 'total_timer_time'),
'start_lat' : self._get_field_value(message_fields, 'start_position_lat'),
'start_long' : self._get_field_value(message_fields, 'start_position_long'),
'stop_lat' : self._get_field_value(message_fields, 'end_position_lat'),
'stop_long' : self._get_field_value(message_fields, 'end_position_long'),
'distance' : self._get_field_value(message_fields, 'total_distance'),
'cycles' : self._get_field_value(message_fields, 'total_cycles'),
'avg_hr' : self._get_field_value(message_fields, 'avg_heart_rate'),
'max_hr' : self._get_field_value(message_fields, 'max_heart_rate'),
'avg_rr' : self._get_field_value(message_fields, 'avg_respiration_rate'),
'max_rr' : self._get_field_value(message_fields, 'max_respiration_rate'),
'calories' : self._get_field_value(message_fields, 'total_calories'),
'avg_cadence' : self._get_field_value(message_fields, 'avg_cadence'),
'max_cadence' : self._get_field_value(message_fields, 'max_cadence'),
'avg_speed' : self._get_field_value(message_fields, 'avg_speed'),
'max_speed' : self._get_field_value(message_fields, 'max_speed'),
'ascent' : self._get_field_value(message_fields, 'total_ascent'),
'descent' : self._get_field_value(message_fields, 'total_descent'),
'max_temperature' : self._get_field_value(message_fields, 'max_temperature'),
'avg_temperature' : self._get_field_value(message_fields, 'avg_temperature'),
}
lap.update(plugin_lap)
self.garmin_act_db_session.add(GarminDB.ActivityLaps(**lap))
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 _write_lap_entry(self, fit_file, message_dict):
# we don't get laps data from multiple sources so we don't need to coellesce data in the DB.
# It's fastest to just write new data out if the it doesn't currently exist.
activity_id = GarminDB.File.id_from_path(fit_file.filename)
if not GarminDB.ActivityLaps.s_exists(self.garmin_act_db_session, {
'activity_id': activity_id,
'lap': self.lap
}):
lap = {
'activity_id':
GarminDB.File.id_from_path(fit_file.filename),
'lap':
self.lap,
'start_time':
self.__get_field_value(message_dict, 'start_time'),
'stop_time':
self.__get_field_value(message_dict, 'timestamp'),
'elapsed_time':
self.__get_field_value(message_dict, 'total_elapsed_time'),
'moving_time':
self.__get_field_value(message_dict, 'total_timer_time'),
'start_lat':
self.__get_field_value(message_dict, 'start_position_lat'),
'start_long':
self.__get_field_value(message_dict, 'start_position_long'),
'stop_lat':
self.__get_field_value(message_dict, 'end_position_lat'),
'stop_long':
self.__get_field_value(message_dict, 'end_position_long'),
'distance':
self.__get_field_list_value(
message_dict, ['user_distance', 'total_distance']),
'cycles':
self.__get_field_value(message_dict, 'total_cycles'),
'avg_hr':
self.__get_field_value(message_dict, 'avg_heart_rate'),
'max_hr':
self.__get_field_value(message_dict, 'max_heart_rate'),
'calories':
self.__get_field_value(message_dict, 'total_calories'),
'avg_cadence':
self.__get_field_value(message_dict, 'avg_cadence'),
'max_cadence':
self.__get_field_value(message_dict, 'max_cadence'),
'avg_speed':
self.__get_field_value(message_dict, 'avg_speed'),
'max_speed':
self.__get_field_value(message_dict, 'max_speed'),
'ascent':
self.__get_field_value(message_dict, 'total_ascent'),
'descent':
self.__get_field_value(message_dict, 'total_descent'),
'max_temperature':
self.__get_field_value(message_dict, 'max_temperature'),
'avg_temperature':
self.__get_field_value(message_dict, 'avg_temperature'),
}
self.garmin_act_db_session.add(GarminDB.ActivityLaps(**lap))
self.lap += 1
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 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 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_garminsumdb_cols_have_values(self):
garminsumdb = GarminDB.GarminSummaryDB(self.db_params_dict)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(garminsumdb,
GarminDB.MonthsSummary.hr_avg),
0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(garminsumdb,
GarminDB.MonthsSummary.hr_min),
0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(garminsumdb,
GarminDB.MonthsSummary.hr_max),
0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(garminsumdb,
GarminDB.MonthsSummary.rhr_avg),
0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(garminsumdb,
GarminDB.MonthsSummary.rhr_min),
0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(garminsumdb,
GarminDB.MonthsSummary.rhr_max),
0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.weight_avg), 0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.weight_min), 0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.weight_max), 0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.stress_avg), 0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.calories_avg), 0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.calories_bmr_avg), 0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.calories_active_avg), 0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.activities), 0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.activities_calories), 0)
self.assertGreater(
GarminDB.MonthsSummary.get_col_max(
garminsumdb, GarminDB.MonthsSummary.activities_distance), 0)
