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 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 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 MSHealth 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 setUpClass(cls):
db_params = GarminDBConfigManager.get_db_params()
cls.plugin_manager = GarminDbPluginManager(
GarminDBConfigManager.get_or_create_plugins_dir(), 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 = GarminDBConfigManager.get_db_params()
cls.garmin_db = GarminDB.GarminDB(db_params)
table_dict = {
'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
}
super().setUpClass(cls.garmin_db, table_dict)
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 = 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 graph_activity(self, activity, period, days):
"""Generate a graph for the given activity with points every period spanning days."""
if period is None:
period = GarminDBConfigManager.graphs_activity_config(
activity, 'period')
if days is None:
days = GarminDBConfigManager.graphs_activity_config(
activity, 'days')
db_params = GarminDBConfigManager.get_db_params()
sum_db = HealthDB.SummaryDB(db_params, 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, start_ts, end_ts, table)
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 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 setUpClass(cls):
cls.db_params = GarminDBConfigManager.get_db_params(test_db=True)
cls.garmin_db = GarminDB.GarminDB(cls.db_params)
import HealthDB
import GarminDB
from garmin_db_config_manager import GarminDBConfigManager
from garmin_connect_config_manager import GarminConnectConfigManager
from statistics import Statistics
from open_with_basecamp import OpenWithBaseCamp
from open_with_google_earth import OpenWithGoogleEarth
from garmin_db_plugin import GarminDbPluginManager
logging.basicConfig(filename='garmin.log', filemode='w', level=logging.INFO)
logger = logging.getLogger(__file__)
logger.addHandler(logging.StreamHandler(stream=sys.stdout))
root_logger = logging.getLogger()
gc_config = GarminConnectConfigManager()
db_params_dict = GarminDBConfigManager.get_db_params()
plugin_manager = GarminDbPluginManager(
GarminDBConfigManager.get_or_create_plugins_dir(), db_params_dict)
stats_to_db_map = {
Statistics.monitoring: GarminDB.MonitoringDB,
Statistics.steps: GarminDB.MonitoringDB,
Statistics.itime: GarminDB.MonitoringDB,
Statistics.sleep: GarminDB.GarminDB,
Statistics.rhr: GarminDB.GarminDB,
Statistics.weight: GarminDB.GarminDB,
Statistics.activities: GarminDB.ActivitiesDB
}
summary_dbs = [GarminDB.GarminSummaryDB, HealthDB.SummaryDB]