Merge pull request #276 from ribhavsharma/overwrite-typo

Fix "Overwrite" typo in function args

Author: tcgoetz

Plugins

@@ -119,35 +119,35 @@ def __convert_to_json(cls, object):
         return object.__str__()
 
     @classmethod
-    def save_json_to_file(cls, filename, json_data, overwite=False):
+    def save_json_to_file(cls, filename, json_data, overwrite=False):
         """Save JSON formatted data to a file."""
         full_filename = f'{filename}.json'
         exists = os.path.isfile(full_filename)
-        if not exists or overwite:
+        if not exists or overwrite:
             logger.debug("%s %s", 'Overwriting' if exists else 'Saving', full_filename)
             with open(full_filename, 'w') as file:
                 file.write(json.dumps(json_data, default=cls.__convert_to_json))
 
-    def save_binary_file(self, filename, url, overwite=False):
+    def save_binary_file(self, filename, url, overwrite=False):
         """Save binary data to a file."""
         exists = os.path.isfile(filename)
-        if not exists or overwite:
+        if not exists or overwrite:
             logger.debug("%s %s", 'Overwriting' if exists else 'Saving', filename)
             response = self.garth.get("connectapi", url, api=True)
             with open(filename, 'wb') as file:
                 for chunk in response:
                     file.write(chunk)
 
-    def __get_stat(self, stat_function, directory, date, days, overwite):
+    def __get_stat(self, stat_function, directory, date, days, overwrite):
         for day in tqdm(range(0, days), unit='days'):
             download_date = date + datetime.timedelta(days=day)
             # always overwrite for yesterday and today since the last download may have been a partial result
             delta = datetime.datetime.now().date() - download_date
-            stat_function(directory, download_date, overwite or delta.days <= self.download_days_overlap)
+            stat_function(directory, download_date, overwrite or delta.days <= self.download_days_overlap)
             # pause for a second between every page access
             time.sleep(1)
 
-    def __get_summary_day(self, directory_func, date, overwite=False):
+    def __get_summary_day(self, directory_func, date, overwrite=False):
         root_logger.info("get_summary_day: %s", date)
         date_str = date.strftime('%Y-%m-%d')
         params = {
@@ -157,14 +157,14 @@ def __get_summary_day(self, directory_func, date, overwite=False):
         url = f'{self.garmin_connect_daily_summary_url}/{self.display_name}'
         json_filename = f'{directory_func(date.year)}/daily_summary_{date_str}'
         try:
-            self.save_json_to_file(json_filename, self.garth.connectapi(url, params=params), overwite)
+            self.save_json_to_file(json_filename, self.garth.connectapi(url, params=params), overwrite)
         except GarthHTTPError as e:
             root_logger.error("Exception getting daily summary: %s", e)
 
-    def get_daily_summaries(self, directory_func, date, days, overwite):
+    def get_daily_summaries(self, directory_func, date, days, overwrite):
         """Download the daily summary data from Garmin Connect and save to a JSON file."""
         root_logger.info("Getting daily summaries: %s (%d)", date, days)
-        self.__get_stat(self.__get_summary_day, directory_func, date, days, overwite)
+        self.__get_stat(self.__get_summary_day, directory_func, date, days, overwrite)
 
     def __get_monitoring_day(self, date):
         root_logger.info("get_monitoring_day: %s to %s", date, self.temp_dir)
@@ -186,8 +186,8 @@ def get_monitoring(self, directory_func, date, days):
             # pause for a second between every page access
             time.sleep(1)
 
-    def __get_weight_day(self, directory, day, overwite=False):
-        root_logger.info("Checking weight: %s overwite %r", day, overwite)
+    def __get_weight_day(self, directory, day, overwrite=False):
+        root_logger.info("Checking weight: %s overwrite %r", day, overwrite)
         date_str = day.strftime('%Y-%m-%d')
         params = {
             'startDate' : date_str,
@@ -196,14 +196,15 @@ def __get_weight_day(self, directory, day, overwite=False):
         }
         json_filename = f'{directory}/weight_{date_str}'
         try:
-            self.save_json_to_file(json_filename, self.garth.connectapi(self.garmin_connect_weight_url, params=params), overwite)
+            self.save_json_to_file(json_filename, self.garth.connectapi(self.garmin_connect_weight_url, params=params), overwrite)
         except GarthHTTPError as e:
             root_logger.error("Exception getting daily summary: %s", e)
 
-    def get_weight(self, directory, date, days, overwite):
+    def get_weight(self, directory, date, days, overwrite):
         """Download the sleep data from Garmin Connect and save to a JSON file."""
         root_logger.info("Getting weight: %s (%d)", date, days)
-        self.__get_stat(self.__get_weight_day, directory, date, days, overwite)
+        self.__get_stat(self.__get_weight_day,
+                        directory, date, days, overwrite)
 
     def __get_activity_summaries(self, start, count):
         root_logger.info("get_activity_summaries")
@@ -216,12 +217,13 @@ def __get_activity_summaries(self, start, count):
         except GarthHTTPError as e:
             root_logger.error("Exception getting activity summary: %s", e)
 
-    def __save_activity_details(self, directory, activity_id_str, overwite):
+    def __save_activity_details(self, directory, activity_id_str, overwrite):
         root_logger.debug("save_activity_details")
         json_filename = f'{directory}/activity_details_{activity_id_str}'
         try:
             url = f'{self.garmin_connect_activity_service_url}/{activity_id_str}'
-            self.save_json_to_file(json_filename, self.garth.connectapi(url), overwite)
+            self.save_json_to_file(
+                json_filename, self.garth.connectapi(url), overwrite)
         except GarthHTTPError as e:
             root_logger.error("Exception getting daily summary %s", e)
 
@@ -234,7 +236,7 @@ def __save_activity_file(self, activity_id_str):
         except GarthHTTPError as e:
             root_logger.error("Exception downloading activity file: %s", e)
 
-    def get_activities(self, directory, count, overwite=False):
+    def get_activities(self, directory, count, overwrite=False):
         """Download activities files from Garmin Connect and save the raw files."""
         self.temp_dir = tempfile.mkdtemp()
         logger.info("Getting activities: '%s' (%d) temp %s", directory, count, self.temp_dir)
@@ -244,46 +246,47 @@ def get_activities(self, directory, count, overwite=False):
             activity_name_str = conversions.printable(activity.get('activityName'))
             root_logger.info("get_activities: %s (%s)", activity_name_str, activity_id_str)
             json_filename = f'{directory}/activity_{activity_id_str}'
-            if not os.path.isfile(json_filename + '.json') or overwite:
+            if not os.path.isfile(json_filename + '.json') or overwrite:
                 root_logger.info("get_activities: %s <- %r", json_filename, activity)
-                self.__save_activity_details(directory, activity_id_str, overwite)
+                self.__save_activity_details(directory, activity_id_str, overwrite)
                 self.save_json_to_file(json_filename, activity)
-                if not os.path.isfile(f'{directory}/{activity_id_str}.fit') or overwite:
+                if not os.path.isfile(f'{directory}/{activity_id_str}.fit') or overwrite:
                     self.__save_activity_file(activity_id_str)
                 # pause for a second between every page access
                 time.sleep(1)
             else:
                 root_logger.info("get_activities: skipping download of %s, already present", activity_id_str)
         self.__unzip_files(directory)
 
-    def get_activity_types(self, directory, overwite):
+    def get_activity_types(self, directory, overwrite):
         """Download the activity types from Garmin Connect and save to a JSON file."""
         root_logger.info("get_activity_types: '%s'", directory)
         json_filename = f'{directory}/activity_types'
         try:
             url = f'{self.garmin_connect_activity_service_url}/activityTypes'
-            self.save_json_to_file(json_filename, self.garth.connectapi(url), overwite)
+            self.save_json_to_file(
+                json_filename, self.garth.connectapi(url), overwrite)
         except GarthHTTPError as e:
             root_logger.error("Exception getting activity types: %s", e)
 
-    def __get_sleep_day(self, directory, date, overwite=False):
+    def __get_sleep_day(self, directory, date, overwrite=False):
         json_filename = f'{directory}/sleep_{date}'
         params = {
             'date'                  : date.strftime("%Y-%m-%d"),
             'nonSleepBufferMinutes' : 60
         }
         url = f'{self.garmin_connect_sleep_daily_url}/{self.display_name}'
         try:
-            self.save_json_to_file(json_filename, self.garth.connectapi(url, params=params), overwite)
+            self.save_json_to_file(json_filename, self.garth.connectapi(url, params=params), overwrite)
         except GarthHTTPError as e:
             root_logger.error("Exception getting daily summary: %s", e)
 
-    def get_sleep(self, directory, date, days, overwite):
+    def get_sleep(self, directory, date, days, overwrite):
         """Download the sleep data from Garmin Connect and save to a JSON file."""
         root_logger.info("Getting sleep: %s (%d)", date, days)
-        self.__get_stat(self.__get_sleep_day, directory, date, days, overwite)
+        self.__get_stat(self.__get_sleep_day, directory, date, days, overwrite)
 
-    def __get_rhr_day(self, directory, day, overwite=False):
+    def __get_rhr_day(self, directory, day, overwrite=False):
         date_str = day.strftime('%Y-%m-%d')
         json_filename = f'{directory}/rhr_{date_str}'
         params = {
@@ -293,25 +296,26 @@ def __get_rhr_day(self, directory, day, overwite=False):
         }
         url = f'{self.garmin_connect_rhr}/{self.display_name}'
         try:
-            self.save_json_to_file(json_filename, self.garth.connectapi(url, params=params), overwite)
+            self.save_json_to_file(json_filename, self.garth.connectapi(
+                url, params=params), overwrite)
         except GarthHTTPError as e:
             root_logger.error("Exception getting daily summary %s", e)
 
-    def get_rhr(self, directory, date, days, overwite):
+    def get_rhr(self, directory, date, days, overwrite):
         """Download the resting heart rate data from Garmin Connect and save to a JSON file."""
         root_logger.info("Getting rhr: %s (%d)", date, days)
-        self.__get_stat(self.__get_rhr_day, directory, date, days, overwite)
+        self.__get_stat(self.__get_rhr_day, directory, date, days, overwrite)
 
-    def __get_hydration_day(self, directory_func, day, overwite=False):
+    def __get_hydration_day(self, directory_func, day, overwrite=False):
         date_str = day.strftime('%Y-%m-%d')
         json_filename = f'{directory_func(day.year)}/hydration_{date_str}'
         url = f'{self.garmin_connect_daily_hydration_url}/{date_str}'
         try:
-            self.save_json_to_file(json_filename, self.garth.connectapi(url), overwite)
+            self.save_json_to_file(json_filename, self.garth.connectapi(url), overwrite)
         except GarthHTTPError as e:
             root_logger.error("Exception getting hydration: %s", e)
 
-    def get_hydration(self, directory_func, date, days, overwite):
+    def get_hydration(self, directory_func, date, days, overwrite):
         """Download the hydration data from Garmin Connect and save to a JSON file."""
         root_logger.info("Getting hydration: %s (%d)", date, days)
-        self.__get_stat(self.__get_hydration_day, directory_func, date, days, overwite)
+        self.__get_stat(self.__get_hydration_day, directory_func, date, days, overwrite)

garmindb/download.py

@@ -81,7 +81,7 @@ def __get_date_and_days(self, db, latest, table, col, stat_name):
         return (date, days)
 
 
-    def copy_data(self, overwite, latest, stats):
+    def copy_data(self, overwrite, latest, stats):
         """Copy data from a mounted Garmin USB device to files."""
         logger.info("___Copying Data___")
         copy = Copy(self.gc_config)
@@ -106,7 +106,7 @@ def copy_data(self, overwite, latest, stats):
             copy.copy_sleep(monitoring_dir, latest)
 
 
-    def download_data(self, overwite, latest, stats):
+    def download_data(self, overwrite, 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')
 
@@ -122,16 +122,16 @@ def download_data(self, overwite, latest, stats):
                 activity_count = self.gc_config.all_activity_count()
             activities_dir = self.gc_config.get_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)
+            download.get_activity_types(activities_dir, overwrite)
+            download.get_activities(activities_dir, activity_count, overwrite)
 
         if Statistics.monitoring in stats:
             date, days = self.__get_date_and_days(MonitoringDb(self.gc_config.get_db_params()), latest, MonitoringHeartRate, MonitoringHeartRate.heart_rate, 'monitoring')
             if days > 0:
                 monitoring_dir = self.gc_config.get_monitoring_base_dir()
                 root_logger.info("Date range to update: %s (%d) to %s", date, days, monitoring_dir)
-                download.get_daily_summaries(self.gc_config.get_monitoring_dir, date, days, overwite)
-                download.get_hydration(self.gc_config.get_monitoring_dir, date, days, overwite)
+                download.get_daily_summaries(self.gc_config.get_monitoring_dir, date, days, overwrite)
+                download.get_hydration(self.gc_config.get_monitoring_dir, date, days, overwrite)
                 download.get_monitoring(self.gc_config.get_monitoring_dir, date, days)
                 root_logger.info("Saved monitoring files for %s (%d) to %s for processing", date, days, monitoring_dir)
 
@@ -140,23 +140,23 @@ def download_data(self, overwite, latest, stats):
             if days > 0:
                 sleep_dir = self.gc_config.get_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)
+                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 Statistics.weight in stats:
             date, days = self.__get_date_and_days(GarminDb(self.gc_config.get_db_params()), latest, Weight, Weight.weight, 'weight')
             if days > 0:
                 weight_dir = self.gc_config.get_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)
+                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 Statistics.rhr in stats:
             date, days = self.__get_date_and_days(GarminDb(self.gc_config.get_db_params()), latest, RestingHeartRate, RestingHeartRate.resting_heart_rate, 'rhr')
             if days > 0:
                 rhr_dir = self.gc_config.get_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)
+                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)
 
 
@@ -317,7 +317,7 @@ def main(argv):
     stats_group.add_argument("-w", "--weight", help="Download and/or import weight data.", dest='stats', action='append_const', const=Statistics.weight)
     modifiers_group = parser.add_argument_group('Modifiers')
     modifiers_group.add_argument("-l", "--latest", help="Only download and/or import the latest data.", action="store_true", default=False)
-    modifiers_group.add_argument("-o", "--overwrite", help="Overwite existing files when downloading. The default is to only download missing files.",
+    modifiers_group.add_argument("-o", "--overwrite", help="Overwrite existing files when downloading. The default is to only download missing files.",
                                  action="store_true", default=False)
     args = parser.parse_args()