Repository: carlkidcrypto/purpleair_data_logger (language: python)

Issue:
Add support for Member* API calls
The goal here is to add support for the following API calls to PAA.

1. https://api.purpleair.com/#api-groups-get-member-data
2. https://api.purpleair.com/#api-groups-get-member-history
3. https://api.purpleair.com/#api-groups-get-members-data


Discussion / hints:

Fix patch:
diff --git a/.gitignore b/.gitignore
index 218af3c..e6717d0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,6 @@
 **/build/**
 **/__pycache__/**
 **/purpleair_data_logger.egg-info/**
-behave_tests/logs/**
-*.ini
-*.xml
+**/logs/**
+**.ini
+**.xml
\ No newline at end of file
diff --git a/purpleair_data_logger/PurpleAirAPI.py b/purpleair_data_logger/PurpleAirAPI.py
index 1e14af5..a99e1db 100644
--- a/purpleair_data_logger/PurpleAirAPI.py
+++ b/purpleair_data_logger/PurpleAirAPI.py
@@ -9,12 +9,16 @@
 import requests
 import json
 from purpleair_data_logger.PurpleAirAPIConstants import (
-    ACCEPTED_FIELD_NAMES_DICT, PRINT_DEBUG_MSGS, SUCCESS_CODE_LIST, ERROR_CODES_LIST)
+    ACCEPTED_FIELD_NAMES_DICT,
+    PRINT_DEBUG_MSGS,
+    SUCCESS_CODE_LIST,
+    ERROR_CODES_LIST,
+)
 
 
 class PurpleAirAPIError(Exception):
     """
-        Custom Exception for our PurpleAirAPI class.
+    Custom Exception for our PurpleAirAPI class.
     """
 
     def __init__(self, message_string):
@@ -24,12 +28,12 @@ def __init__(self, message_string):
 
 def debug_log(debug_msg_string):
     """
-        A helper function to print out
-        debug messages only if DEBUG is defined as True in
-        'PurpleAirAPIConstants.py'. Messages will be the color
-        red.
+    A helper function to print out
+    debug messages only if DEBUG is defined as True in
+    'PurpleAirAPIConstants.py'. Messages will be the color
+    red.
 
-        :param str debug_msg_string: The debug message string
+    :param str debug_msg_string: The debug message string
     """
 
     if PRINT_DEBUG_MSGS:
@@ -37,21 +41,22 @@ def debug_log(debug_msg_string):
         print("\033[1;31m" + str(debug_msg_string) + "\x1b[0m")
 
 
-class PurpleAirAPI():
+class PurpleAirAPI:
     """
-        The PurpleAirAPI class designed to send valid
-        PurpleAirAPI requests.
+    The PurpleAirAPI class designed to send valid
+    PurpleAirAPI requests.
     """
 
     def __init__(self, your_api_read_key=None, your_api_write_key=None):
         """
-            :param str your_api_read_key: A valid PurpleAirAPI Read key
-            :param str your_api_write_key: A valid PurpleAirAPI Write key
+        :param str your_api_read_key: A valid PurpleAirAPI Read key
+        :param str your_api_write_key: A valid PurpleAirAPI Write key
         """
 
         if your_api_read_key is None and your_api_write_key is None:
             raise PurpleAirAPIError(
-                "Ensure one or both of 'your_api_read_key'/'your_api_write_key' key(s) are provided")
+                "Ensure one or both of 'your_api_read_key'/'your_api_write_key' key(s) are provided"
+            )
 
         # Save off the API key for internal usage
         self._your_api_read_key = your_api_read_key
@@ -83,49 +88,55 @@ def __init__(self, your_api_read_key=None, your_api_write_key=None):
                 print("PurpleAirAPI: Successfully authenticated read key")
 
             else:
-                raise PurpleAirAPIError(
-                    "Ensure 'your_api_read_key' is a read key.")
+                raise PurpleAirAPIError("Ensure 'your_api_read_key' is a read key.")
 
         if retval_api_write_key is not None:
             if self._api_key_types[your_api_write_key] == "WRITE":
                 print("PurpleAirAPI: Successfully authenticated write key")
 
             else:
-                raise PurpleAirAPIError(
-                    "Ensure 'your_api_write_key' is a write key")
+                raise PurpleAirAPIError("Ensure 'your_api_write_key' is a write key")
 
     def _check_an_api_key(self, str_api_key_to_check):
         """
-            An internal class helper method to check if an API key is valid.
+        An internal class helper method to check if an API key is valid.
 
-            :param str str_api_key_to_check: A valid PurpleAirAPI key to check
+        :param str str_api_key_to_check: A valid PurpleAirAPI key to check
 
-            :return True, if an API key can be successfully verified.
+        :return True, if an API key can be successfully verified.
         """
         request_url = self._base_api_v1_request_string + "keys"
-        my_request = requests.get(request_url, headers={
-                                  "X-API-Key": str(str_api_key_to_check)})
+        my_request = requests.get(
+            request_url, headers={"X-API-Key": str(str_api_key_to_check)}
+        )
 
         the_request_text_as_json = json.loads(my_request.text)
         debug_log(the_request_text_as_json)
 
         if my_request.status_code in SUCCESS_CODE_LIST:
             # We good :) get the request text
-            self._api_versions[str_api_key_to_check] = the_request_text_as_json["api_version"]
-            self._api_keys_last_checked[str_api_key_to_check] = the_request_text_as_json["time_stamp"]
-            self._api_key_types[str_api_key_to_check] = the_request_text_as_json["api_key_type"]
+            self._api_versions[str_api_key_to_check] = the_request_text_as_json[
+                "api_version"
+            ]
+            self._api_keys_last_checked[
+                str_api_key_to_check
+            ] = the_request_text_as_json["time_stamp"]
+            self._api_key_types[str_api_key_to_check] = the_request_text_as_json[
+                "api_key_type"
+            ]
             my_request.close()
             del my_request
             return True
 
         else:
             raise PurpleAirAPIError(
-                f"""{my_request.status_code}: {the_request_text_as_json['error']} - {the_request_text_as_json['description']}""")
+                f"""{my_request.status_code}: {the_request_text_as_json['error']} - {the_request_text_as_json['description']}"""
+            )
 
     @property
     def get_api_versions(self):
         """
-            A method to return the API versions being used for both read/write keys.
+        A method to return the API versions being used for both read/write keys.
         """
 
         return self._api_versions
@@ -133,7 +144,7 @@ def get_api_versions(self):
     @property
     def get_api_key_last_checked(self):
         """
-            A method to return the timestamp of when the API read/write keys were last checked.
+        A method to return the timestamp of when the API read/write keys were last checked.
         """
 
         return self._api_keys_last_checked
@@ -141,122 +152,136 @@ def get_api_key_last_checked(self):
     @property
     def get_api_key_type(self):
         """
-            A method to return the API key types being used.
+        A method to return the API key types being used.
         """
 
         return self._api_key_types
 
     def request_sensor_data(self, sensor_index, read_key=None, fields=None):
         """
-            A method to retrieve sensor data from one sensor. Will return the 
-            response payload as a python dictionary.
+        A method to retrieve sensor data from one sensor. Will return the
+        response payload as a python dictionary.
 
-            :param int sensor_index: The sensor_index as found in the JSON for
-                                     this specific sensor.
-    
-            :param (optional) str read_key: This read_key is required for
-                                            private devices. It is separate
-                                            to the api_key and each sensor has
-                                            its own read_key. Submit multiple
-                                            keys by separating them with a
-                                            comma (,) character for example:
-                                            key-one,key-two,key-three.
+        :param int sensor_index: The sensor_index as found in the JSON for
+                                 this specific sensor.
 
-            :param (optional) str fields: The 'Fields' parameter specifies which
-                                          'sensor data fields' to include in the
-                                          response. It is a comma separated list
-                                          with one or more of the following:
-                                          Refer to PurpleAir documentation for more
-                                          information:
-                                          https://api.purpleair.com/#api-sensors-get-sensor-data
+        :param (optional) str read_key: This read_key is required for
+                                        private devices. It is separate
+                                        to the api_key and each sensor has
+                                        its own read_key. Submit multiple
+                                        keys by separating them with a
+                                        comma (,) character for example:
+                                        key-one,key-two,key-three.
 
-            :return A python dictionary containing the payload response
+        :param (optional) str fields: The 'Fields' parameter specifies which
+                                      'sensor data fields' to include in the
+                                      response. It is a comma separated list
+                                      with one or more of the following:
+                                      Refer to PurpleAir documentation for more
+                                      information:
+                                      https://api.purpleair.com/#api-sensors-get-sensor-data
+
+        :return A python dictionary containing the payload response
         """
 
-        request_url = self._base_api_v1_request_string + \
-            "sensors/" + f"{sensor_index}"
+        request_url = self._base_api_v1_request_string + "sensors/" + f"{sensor_index}"
 
-        optional_parameters_dict = {
-            "read_key": read_key,
-            "fields": fields
-        }
+        optional_parameters_dict = {"read_key": read_key, "fields": fields}
 
         first_optional_parameter_separator = "?"
-        return self._send_url_get_request(request_url, self._your_api_read_key, first_optional_parameter_separator, optional_parameters_dict)
+        return self._send_url_get_request(
+            request_url,
+            self._your_api_read_key,
+            first_optional_parameter_separator,
+            optional_parameters_dict,
+        )
 
-    def request_multiple_sensors_data(self, fields, location_type=None, read_keys=None, show_only=None, modified_since=None, max_age=None, nwlng=None, nwlat=None, selng=None, selat=None):
+    def request_multiple_sensors_data(
+        self,
+        fields,
+        location_type=None,
+        read_keys=None,
+        show_only=None,
+        modified_since=None,
+        max_age=None,
+        nwlng=None,
+        nwlat=None,
+        selng=None,
+        selat=None,
+    ):
         """
-            A method to retrieve sensor data from multiple sensors. Will return the 
-            response payload as a python dictionary.
+        A method to retrieve sensor data from multiple sensors. Will return the
+        response payload as a python dictionary.
+
+        :param str fields: The 'Fields' parameter specifies which 'sensor data fields' to include in the response. It is a comma separated list with one or more of the following:
+                            Station information and status fields:
+                            name, icon, model, hardware, location_type, private, latitude, longitude, altitude, position_rating, led_brightness, firmware_version, firmware_upgrade, rssi, uptime, pa_latency, memory, last_seen, last_modified, date_created, channel_state, channel_flags, channel_flags_manual, channel_flags_auto, confidence, confidence_manual, confidence_auto
+
+                            Environmental fields:
+                            humidity, humidity_a, humidity_b, temperature, temperature_a, temperature_b, pressure, pressure_a, pressure_b
 
-            :param str fields: The 'Fields' parameter specifies which 'sensor data fields' to include in the response. It is a comma separated list with one or more of the following:
-                                Station information and status fields:
-                                name, icon, model, hardware, location_type, private, latitude, longitude, altitude, position_rating, led_brightness, firmware_version, firmware_upgrade, rssi, uptime, pa_latency, memory, last_seen, last_modified, date_created, channel_state, channel_flags, channel_flags_manual, channel_flags_auto, confidence, confidence_manual, confidence_auto
+                            Miscellaneous fields:
+                            voc, voc_a, voc_b, ozone1, analog_input
 
-                                Environmental fields:
-                                humidity, humidity_a, humidity_b, temperature, temperature_a, temperature_b, pressure, pressure_a, pressure_b
+                            PM1.0 fields:
+                            pm1.0, pm1.0_a, pm1.0_b, pm1.0_atm, pm1.0_atm_a, pm1.0_atm_b, pm1.0_cf_1, pm1.0_cf_1_a, pm1.0_cf_1_b
 
-                                Miscellaneous fields:
-                                voc, voc_a, voc_b, ozone1, analog_input
+                            PM2.5 fields:
+                            pm2.5_alt, pm2.5_alt_a, pm2.5_alt_b, pm2.5, pm2.5_a, pm2.5_b, pm2.5_atm, pm2.5_atm_a, pm2.5_atm_b, pm2.5_cf_1, pm2.5_cf_1_a, pm2.5_cf_1_b
 
-                                PM1.0 fields:
-                                pm1.0, pm1.0_a, pm1.0_b, pm1.0_atm, pm1.0_atm_a, pm1.0_atm_b, pm1.0_cf_1, pm1.0_cf_1_a, pm1.0_cf_1_b
+                            PM2.5 pseudo (simple running) average fields:
+                            pm2.5_10minute, pm2.5_10minute_a, pm2.5_10minute_b, pm2.5_30minute, pm2.5_30minute_a, pm2.5_30minute_b, pm2.5_60minute, pm2.5_60minute_a, pm2.5_60minute_b, pm2.5_6hour, pm2.5_6hour_a, pm2.5_6hour_b, pm2.5_24hour, pm2.5_24hour_a, pm2.5_24hour_b, pm2.5_1week, pm2.5_1week_a, pm2.5_1week_b
 
-                                PM2.5 fields:
-                                pm2.5_alt, pm2.5_alt_a, pm2.5_alt_b, pm2.5, pm2.5_a, pm2.5_b, pm2.5_atm, pm2.5_atm_a, pm2.5_atm_b, pm2.5_cf_1, pm2.5_cf_1_a, pm2.5_cf_1_b
+                            PM10.0 fields:
+                            pm10.0, pm10.0_a, pm10.0_b, pm10.0_atm, pm10.0_atm_a, pm10.0_atm_b, pm10.0_cf_1, pm10.0_cf_1_a, pm10.0_cf_1_b
 
-                                PM2.5 pseudo (simple running) average fields:
-                                pm2.5_10minute, pm2.5_10minute_a, pm2.5_10minute_b, pm2.5_30minute, pm2.5_30minute_a, pm2.5_30minute_b, pm2.5_60minute, pm2.5_60minute_a, pm2.5_60minute_b, pm2.5_6hour, pm2.5_6hour_a, pm2.5_6hour_b, pm2.5_24hour, pm2.5_24hour_a, pm2.5_24hour_b, pm2.5_1week, pm2.5_1week_a, pm2.5_1week_b
+                            Visibility fields:
+                            scattering_coefficient, scattering_coefficient_a, scattering_coefficient_b, deciviews, deciviews_a, deciviews_b, visual_range, visual_range_a, visual_range_b
 
-                                PM10.0 fields:
-                                pm10.0, pm10.0_a, pm10.0_b, pm10.0_atm, pm10.0_atm_a, pm10.0_atm_b, pm10.0_cf_1, pm10.0_cf_1_a, pm10.0_cf_1_b
+                            Particle count fields:
+                            0.3_um_count, 0.3_um_count_a, 0.3_um_count_b, 0.5_um_count, 0.5_um_count_a, 0.5_um_count_b, 1.0_um_count, 1.0_um_count_a, 1.0_um_count_b, 2.5_um_count, 2.5_um_count_a, 2.5_um_count_b, 5.0_um_count, 5.0_um_count_a, 5.0_um_count_b, 10.0_um_count 10.0_um_count_a, 10.0_um_count_b
 
-                                Visibility fields:
-                                scattering_coefficient, scattering_coefficient_a, scattering_coefficient_b, deciviews, deciviews_a, deciviews_b, visual_range, visual_range_a, visual_range_b
+                            ThingSpeak fields, used to retrieve data from api.thingspeak.com:
+                            primary_id_a, primary_key_a, secondary_id_a, secondary_key_a, primary_id_b, primary_key_b, secondary_id_b, secondary_key_b
 
-                                Particle count fields:
-                                0.3_um_count, 0.3_um_count_a, 0.3_um_count_b, 0.5_um_count, 0.5_um_count_a, 0.5_um_count_b, 1.0_um_count, 1.0_um_count_a, 1.0_um_count_b, 2.5_um_count, 2.5_um_count_a, 2.5_um_count_b, 5.0_um_count, 5.0_um_count_a, 5.0_um_count_b, 10.0_um_count 10.0_um_count_a, 10.0_um_count_b
+        :param (optional) int location_type: The location_type of the sensors.
+                                             Possible values are: 0 = Outside or 1 = Inside.
 
-                                ThingSpeak fields, used to retrieve data from api.thingspeak.com:
-                                primary_id_a, primary_key_a, secondary_id_a, secondary_key_a, primary_id_b, primary_key_b, secondary_id_b, secondary_key_b
-                                
-            :param (optional) int location_type: The location_type of the sensors.
-                                                 Possible values are: 0 = Outside or 1 = Inside.
+        :param (optional) str read_keys: A read_key is required for private devices. It is separate to the api_key and each sensor has its own read_key.
+                                         Submit multiple keys by separating them with a comma (,) character for example: key-one,key-two,key-three
 
-            :param (optional) str read_keys: A read_key is required for private devices. It is separate to the api_key and each sensor has its own read_key.
-                                             Submit multiple keys by separating them with a comma (,) character for example: key-one,key-two,key-three
-            
-            :param (optional) str show_only: A comma (,) separated list of sensor_index values. When provided, the results are limited only to
-                                             the sensors included in this list.
+        :param (optional) str show_only: A comma (,) separated list of sensor_index values. When provided, the results are limited only to
+                                         the sensors included in this list.
 
-            :param (optional) str modified_since: The modified_since parameter causes only sensors modified after
-                                                  the provided time stamp to be included in the results. Using the
-                                                  time_stamp value from a previous call (recommended) will limit results
-                                                  to those with new values since the last request. Using a value of 0
-                                                  will match sensors modified at any time
+        :param (optional) str modified_since: The modified_since parameter causes only sensors modified after
+                                              the provided time stamp to be included in the results. Using the
+                                              time_stamp value from a previous call (recommended) will limit results
+                                              to those with new values since the last request. Using a value of 0
+                                              will match sensors modified at any time
 
-            :param (optional) int max_age: Filter results to only include sensors modified or updated within the last
-                                           number of seconds. Using a value of 0 will match sensors of any age. 
-                                           Default value: 604800
-            
-            :param (optional) int nwlng: A north west longitude for the bounding box. Use a bounding box to limit the sensors
-                                         returned to a specific geographic area. The bounding box is defined by two points, a
-                                         north west latitude/longitude and a south east latitude/longitude.
+        :param (optional) int max_age: Filter results to only include sensors modified or updated within the last
+                                       number of seconds. Using a value of 0 will match sensors of any age.
+                                       Default value: 604800
 
-            :param (optional) int nwlat: A north west latitude for the bounding box.
+        :param (optional) int nwlng: A north west longitude for the bounding box. Use a bounding box to limit the sensors
+                                     returned to a specific geographic area. The bounding box is defined by two points, a
+                                     north west latitude/longitude and a south east latitude/longitude.
 
-            :param (optional) int selng: A south east longitude for the bounding box.
+        :param (optional) int nwlat: A north west latitude for the bounding box.
 
-            :param (optional) int selat: A south east latitude for the bounding box.
+        :param (optional) int selng: A south east longitude for the bounding box.
 
-            :return A python dictionary containing the payload response                    
+        :param (optional) int selat: A south east latitude for the bounding box.
+
+        :return A python dictionary containing the payload response
         """
 
-        request_url = self._base_api_v1_request_string + \
-            "sensors/" + f"?fields={fields}"
+        request_url = (
+            self._base_api_v1_request_string + "sensors/" + f"?fields={fields}"
+        )
 
         # Add to the request_url string depending on what optional parameters are
-        # passed in. Turn them into a list of optional parameters
+        # passed in. Turn them into a dict of optional parameters
         optional_parameters_dict = {
             "location_type": location_type,
             "read_keys": read_keys,
@@ -266,269 +291,601 @@ def request_multiple_sensors_data(self, fields, location_type=None, read_keys=No
             "nwlng": nwlng,
             "nwlat": nwlat,
             "selng": selng,
-            "selat": selat}
+            "selat": selat,
+        }
 
         first_optional_parameter_separator = "&"
-        return self._send_url_get_request(request_url, self._your_api_read_key, first_optional_parameter_separator, optional_parameters_dict)
+        return self._send_url_get_request(
+            request_url,
+            self._your_api_read_key,
+            first_optional_parameter_separator,
+            optional_parameters_dict,
+        )
 
-    def request_sensor_historic_data(self, sensor_index, fields, read_key=None, start_timestamp=None, end_timestamp=None, average=None):
+    def request_sensor_historic_data(
+        self,
+        sensor_index,
+        fields,
+        read_key=None,
+        start_timestamp=None,
+        end_timestamp=None,
+        average=None,
+    ):
         """
-            A method to request historic data from a single sensor.
+        A method to request historic data from a single sensor.
 
-            :param int sensor_index: The sensor_index as found in the JSON for this specific sensor.
+        :param int sensor_index: The sensor_index as found in the JSON for this specific sensor.
 
-            :param (optional) str read_key: This read_key is required for private devices. It is separate to the api_key and each sensor has its own read_key. Submit multiple keys by separating them with a comma (,) character for example: key-one,key-two,key-three.
+        :param (optional) str read_key: This read_key is required for private devices. It is separate to the api_key and each sensor has its own read_key. Submit multiple keys by separating them with a comma (,) character for example: key-one,key-two,key-three.
 
-            :param (optional) int start_timestamp: The time stamp of the first required history entry. Query is executed using data_timestamp >= start_timestamp.
-                                                   Time can be specified as a UNIX time stamp in seconds or an ISO 8601 string. https://en.wikipedia.org/wiki/ISO_8601.
-                                                   The time_stamp column in the resulting JSON or CSV will be in the same format and or time zone that you use for this start_timestamp parameter.
-                                                   If not specified, the last maximum time span for the requested average will be returned.
+        :param (optional) int start_timestamp: The time stamp of the first required history entry. Query is executed using data_timestamp >= start_timestamp.
+                                               Time can be specified as a UNIX time stamp in seconds or an ISO 8601 string. https://en.wikipedia.org/wiki/ISO_8601.
+                                               The time_stamp column in the resulting JSON or CSV will be in the same format and or time zone that you use for this start_timestamp parameter.
+                                               If not specified, the last maximum time span for the requested average will be returned.
 
-            :param (optional) int end_timestamp: The end time stamp of the history to return. Query is executed using data_timestamp < end_timestamp.
-                                                 Time can be specified as a UNIX time stamp in seconds or an ISO 8601 string. https://en.wikipedia.org/wiki/ISO_8601.
-                                                 If not specified, the maximum time span will be returned starting from the provided start_timestamp.
+        :param (optional) int end_timestamp: The end time stamp of the history to return. Query is executed using data_timestamp < end_timestamp.
+                                             Time can be specified as a UNIX time stamp in seconds or an ISO 8601 string. https://en.wikipedia.org/wiki/ISO_8601.
+                                             If not specified, the maximum time span will be returned starting from the provided start_timestamp.
 
-            :param (optional) int average: The desired average in minutes, one of the following: 0 (real-time), 10 (default if not specified), 30, 60, 360 (6 hour), 1440 (1 day)
-                                           Coming soon: 10080 (1 week), 44640 (1 month), 525600 (1 year).
+        :param (optional) int average: The desired average in minutes, one of the following: 0 (real-time), 10 (default if not specified), 30, 60, 360 (6 hour), 1440 (1 day)
+                                       Coming soon: 10080 (1 week), 44640 (1 month), 525600 (1 year).
 
-            :param str fields: The 'Fields' parameter specifies which 'sensor data fields' to include in the response. Not all fields are available as history fields and we will be working to add more as time goes on. Fields marked with an asterisk (*) may not be available when using averages. It is a comma separated list with one or more of the following:
+        :param str fields: The 'Fields' parameter specifies which 'sensor data fields' to include in the response. Not all fields are available as history fields and we will be working to add more as time goes on. Fields marked with an asterisk (*) may not be available when using averages. It is a comma separated list with one or more of the following:
 
-                               Station information and status fields:
-                               hardware*, latitude*, longitude*, altitude*, firmware_version*, rssi, uptime, pa_latency, memory,
+                           Station information and status fields:
+                           hardware*, latitude*, longitude*, altitude*, firmware_version*, rssi, uptime, pa_latency, memory,
 
-                               Environmental fields:
-                               humidity, humidity_a, humidity_b, temperature, temperature_a, temperature_b, pressure, pressure_a, pressure_b
+                           Environmental fields:
+                           humidity, humidity_a, humidity_b, temperature, temperature_a, temperature_b, pressure, pressure_a, pressure_b
 
-                               Miscellaneous fields:
-                               voc, voc_a, voc_b, analog_input
+                           Miscellaneous fields:
+                           voc, voc_a, voc_b, analog_input
 
-                               PM1.0 fields:
-                               pm1.0_atm, pm1.0_atm_a, pm1.0_atm_b, pm1.0_cf_1, pm1.0_cf_1_a, pm1.0_cf_1_b
+                           PM1.0 fields:
+                           pm1.0_atm, pm1.0_atm_a, pm1.0_atm_b, pm1.0_cf_1, pm1.0_cf_1_a, pm1.0_cf_1_b
 
-                               PM2.5 fields:
-                               pm2.5_alt, pm2.5_alt_a, pm2.5_alt_b, pm2.5_atm, pm2.5_atm_a, pm2.5_atm_b, pm2.5_cf_1, pm2.5_cf_1_a, pm2.5_cf_1_b
+                           PM2.5 fields:
+                           pm2.5_alt, pm2.5_alt_a, pm2.5_alt_b, pm2.5_atm, pm2.5_atm_a, pm2.5_atm_b, pm2.5_cf_1, pm2.5_cf_1_a, pm2.5_cf_1_b
 
-                               PM10.0 fields:
-                               pm10.0_atm, pm10.0_atm_a, pm10.0_atm_b, pm10.0_cf_1, pm10.0_cf_1_a, pm10.0_cf_1_b
+                           PM10.0 fields:
+                           pm10.0_atm, pm10.0_atm_a, pm10.0_atm_b, pm10.0_cf_1, pm10.0_cf_1_a, pm10.0_cf_1_b
 
-                               Visibility fields:
-                               scattering_coefficient, scattering_coefficient_a, scattering_coefficient_b, deciviews, deciviews_a, deciviews_b, visual_range, visual_range_a, visual_range_b
+                           Visibility fields:
+                           scattering_coefficient, scattering_coefficient_a, scattering_coefficient_b, deciviews, deciviews_a, deciviews_b, visual_range, visual_range_a, visual_range_b
 
-                               Particle count fields:
-                               0.3_um_count, 0.3_um_count_a, 0.3_um_count_b, 0.5_um_count, 0.5_um_count_a, 0.5_um_count_b, 1.0_um_count, 1.0_um_count_a, 1.0_um_count_b, 2.5_um_count, 2.5_um_count_a, 2.5_um_count_b, 5.0_um_count, 5.0_um_count_a, 5.0_um_count_b, 10.0_um_count, 10.0_um_count_a, 10.0_um_count_b
+                           Particle count fields:
+                           0.3_um_count, 0.3_um_count_a, 0.3_um_count_b, 0.5_um_count, 0.5_um_count_a, 0.5_um_count_b, 1.0_um_count, 1.0_um_count_a, 1.0_um_count_b, 2.5_um_count, 2.5_um_count_a, 2.5_um_count_b, 5.0_um_count, 5.0_um_count_a, 5.0_um_count_b, 10.0_um_count, 10.0_um_count_a, 10.0_um_count_b
 
-                               For field descriptions, please see the 'sensor data fields'. section.
+                           For field descriptions, please see the 'sensor data fields'. section.
         """
 
-        request_url = self._base_api_v1_request_string + \
-            "sensors/" + f"{sensor_index}" + "/history" + f"?fields={fields}"
+        request_url = (
+            self._base_api_v1_request_string
+            + "sensors/"
+            + f"{sensor_index}"
+            + "/history"
+            + f"?fields={fields}"
+        )
 
         # Add to the request_url string depending on what optional parameters are
-        # passed in. Turn them into a list of optional parameters
+        # passed in. Turn them into a dict of optional parameters
         optional_parameters_dict = {
             "read_key": read_key,
             "start_timestamp": start_timestamp,
             "end_timestamp": end_timestamp,
             "modified_since": end_timestamp,
-            "average": average}
+            "average": average,
+        }
 
         first_optional_parameter_separator = "&"
-        return self._send_url_get_request(request_url, self._your_api_read_key, first_optional_parameter_separator, optional_parameters_dict)
+        return self._send_url_get_request(
+            request_url,
+            self._your_api_read_key,
+            first_optional_parameter_separator,
+            optional_parameters_dict,
+        )
 
-    def post_create_group(self, name):
+    def request_group_detail_data(self, group_id):
         """
-            A method to create a group for sensors.
+        A method to retrieve a list of all members of a specified group.
 
-            :param int sensor_index: The sensor_index as found in the JSON for this specific sensor.
+        :param int group_id: The group_id of the requested group. This group must be owned by the api_key.
         """
 
-        post_url = self._base_api_v1_request_string + \
-            f"groups"
+        request_url = self._base_api_v1_request_string + f"groups/{group_id}"
+        return self._send_url_get_request(request_url, self._your_api_read_key)
 
-        return self._send_url_post_request(post_url, self._your_api_write_key, {"name": name})
+    def request_group_list_data(self):
+        """
+        A method to retrieve a list of all groups owned by the provided api_key.
+        """
+
+        request_url = self._base_api_v1_request_string + f"groups/"
+        return self._send_url_get_request(request_url, self._your_api_read_key)
 
-    def post_create_member(self, group_id, sensor_index=None, sensor_id=None, owner_email=None, location_type=None):
+    def request_member_data(self, group_id, member_id, fields=None):
         """
-            Using a sensor_id (Parameters Option 1)
-            The sensor_id should be exactly as printed on the label on the sensor. When no owner_email is provided, the sensor has to be marked as public.
+        A method to get a members' data from a group to which said member belongs.
+
+        :param int group_id: Groups unique ID.
 
-            :param int group_id: The group_id of the group to add a member to. This group must be owned by the api_key.
+        :param int member_id: Members unique ID.
 
-            :param str sensor_id: The sensor_id of the new member sensor. This must be AS PRINTED on the sensor’s label.
+        :param (optional) str fields: The 'Fields' parameter specifies which 'sensor data fields' to include in the response. It is a comma separated list with one or more of the following:
 
-            Using a sensor_index (Parameters Option 2)
-            The sensor_index can be found in lists for example from a /sensors api call. When no owner_email is provided, the sensor has to be marked as public.
+            Station information and status fields:
+            name, icon, model, hardware, location_type, private, latitude, longitude, altitude, position_rating, led_brightness, firmware_version, firmware_upgrade, rssi, uptime, pa_latency, memory, last_seen, last_modified, date_created, channel_state, channel_flags, channel_flags_manual, channel_flags_auto, confidence, confidence_manual, confidence_auto
 
-            :param int group_id: The group_id of the group to add a member to. This group must be owned by the api_key.
+            Environmental fields:
+            humidity, humidity_a, humidity_b, temperature, temperature_a, temperature_b, pressure, pressure_a, pressure_b
 
-            :param int sensor_index: The sensor_index of the new member as found in the JSON for this specific sensor.
+            Miscellaneous fields:
+            voc, voc_a, voc_b, ozone1, analog_input
 
-            Using sensor_id with a private sensor by specifying owner_email and optionally location_type. (Parameters Option 3)
-            This example will produce an error if any provided value does not match the current configuration of the sensor. Note, too many incorrect attempts may disable your API key, so do not try guessing the email!!
+            PM1.0 fields:
+            pm1.0, pm1.0_a, pm1.0_b, pm1.0_atm, pm1.0_atm_a, pm1.0_atm_b, pm1.0_cf_1, pm1.0_cf_1_a, pm1.0_cf_1_b
 
-            :param int group_id: The group_id of the group to add a member to. This group must be owned by the api_key.
+            PM2.5 fields:
+            pm2.5_alt, pm2.5_alt_a, pm2.5_alt_b, pm2.5, pm2.5_a, pm2.5_b, pm2.5_atm, pm2.5_atm_a, pm2.5_atm_b, pm2.5_cf_1, pm2.5_cf_1_a, pm2.5_cf_1_b
 
-            :param str sensor_id: The sensor_id of the new member sensor. This must be AS PRINTED on the sensor’s label.
+            PM2.5 pseudo (simple running) average fields:
+            pm2.5_10minute, pm2.5_10minute_a, pm2.5_10minute_b, pm2.5_30minute, pm2.5_30minute_a, pm2.5_30minute_b, pm2.5_60minute, pm2.5_60minute_a, pm2.5_60minute_b, pm2.5_6hour, pm2.5_6hour_a, pm2.5_6hour_b, pm2.5_24hour, pm2.5_24hour_a, pm2.5_24hour_b, pm2.5_1week, pm2.5_1week_a, pm2.5_1week_b
 
-            :param str owner_email: An email address that matches the Owner email as set by previously completing the PurpleAir registration form at www.purpleair.com/register.
+            PM10.0 fields:
+            pm10.0, pm10.0_a, pm10.0_b, pm10.0_atm, pm10.0_atm_a, pm10.0_atm_b, pm10.0_cf_1, pm10.0_cf_1_a, pm10.0_cf_1_b
 
-            :param (optional) int location_type: The expected location_type of the new member.
-                                                 Possible values are: 0 = Outside or 1 = Inside.
-                                                 If the target member is not of this type, an error will result.
-                                                 NOTE: This value is required if the sensor in question is marked as ‘private’ on the registration form.
+            Particle count fields:
+            0.3_um_count, 0.3_um_count_a, 0.3_um_count_b, 0.5_um_count, 0.5_um_count_a, 0.5_um_count_b, 1.0_um_count, 1.0_um_count_a, 1.0_um_count_b, 2.5_um_count, 2.5_um_count_a, 2.5_um_count_b, 5.0_um_count, 5.0_um_count_a, 5.0_um_count_b, 10.0_um_count 10.0_um_count_a, 10.0_um_count_b
+
+            ThingSpeak fields, used to retrieve data from api.thingspeak.com:
+            primary_id_a, primary_key_a, secondary_id_a, secondary_key_a, primary_id_b, primary_key_b, secondary_id_b, secondary_key_b
+
+            For field descriptions, please see the 'sensor data fields'. section.
         """
 
-        post_url = self._base_api_v1_request_string + \
-            f"groups/{group_id}/members"
+        request_url = (
+            self._base_api_v1_request_string + f"groups/{group_id}/members/{member_id}"
+        )
 
-        if sensor_index is None and sensor_id is not None and owner_email is None and location_type is None:
-            # We good, use the sensor index
-            debug_log("post_create_member - option 1")
-            return self._send_url_post_request(post_url, self._your_api_write_key, {"sensor_id": str(sensor_id)})
+        # Add to the request_url string depending on what optional parameters are
+        # passed in. Turn them into a dict of optional parameters
+        optional_parameters_dict = {"fields": fields}
+
+        first_optional_parameter_separator = "?"
+        return self._send_url_get_request(
+            request_url,
+            self._your_api_read_key,
+            first_optional_parameter_separator,
+            optional_parameters_dict,
+        )
+
+    def request_member_historic_data(
+        self,
+        group_id,
+        member_id,
+        fields,
+        start_timestamp=None,
+        end_timestamp=None,
+        average=None,
+    ):
+        """
+        A method to get a members' historic data from a group to which said member belongs too.
+
+        :param int group_id: Groups unique ID.
+
+        :param int member_id: Members unique ID.
+
+        :param (optional) int start_timestamp: The time stamp of the first required history entry. Query is executed using data_timestamp >= start_timestamp.
+                                    Time can be specified as a UNIX time stamp in seconds or an ISO 8601 string. https://en.wikipedia.org/wiki/ISO_8601.
+                                    The time_stamp column in the resulting JSON or CSV will be in the same format and or time zone that you use for this start_timestamp parameter.
+                                    If not specified, the last maximum time span for the requested average will be returned.
+
+        :param (optional) int end_timestamp: The end time stamp of the history to return. Query is executed using data_timestamp < end_timestamp.
+                                             Time can be specified as a UNIX time stamp in seconds or an ISO 8601 string. https://en.wikipedia.org/wiki/ISO_8601.
+                                             If not specified, the maximum time span will be returned starting from the provided start_timestamp.
+
+        :param (optional) int average: The desired average in minutes, one of the following: 0 (real-time), 10 (default if not specified), 30, 60, 360 (6 hour), 1440 (1 day)
+                                       Coming soon: 10080 (1 week), 44640 (1 month), 525600 (1 year).
+
+        :param str fields: The 'Fields' parameter specifies which 'sensor data fields' to include in the response. Not all fields are available as history fields and we will be working to add more as time goes on. Fields marked with an asterisk (*) may not be available when using averages. It is a comma separated list with one or more of the following:
+
+                            Station information and status fields:
+                            hardware*, latitude*, longitude*, altitude*, firmware_version*, rssi, uptime, pa_latency, memory,
+
+                            Environmental fields:
+                            humidity, humidity_a, humidity_b, temperature, temperature_a, temperature_b, pressure, pressure_a, pressure_b
+
+                            Miscellaneous fields:
+                            voc, voc_a, voc_b, analog_input
+
+                            PM1.0 fields:
+                            pm1.0_atm, pm1.0_atm_a, pm1.0_atm_b, pm1.0_cf_1, pm1.0_cf_1_a, pm1.0_cf_1_b
+
+                            PM2.5 fields:
+                            pm2.5_alt, pm2.5_alt_a, pm2.5_alt_b, pm2.5_atm, pm2.5_atm_a, pm2.5_atm_b, pm2.5_cf_1, pm2.5_cf_1_a, pm2.5_cf_1_b
+
+                            PM10.0 fields:
+                            pm10.0_atm, pm10.0_atm_a, pm10.0_atm_b, pm10.0_cf_1, pm10.0_cf_1_a, pm10.0_cf_1_b
+
+                            Visibility fields:
+                            scattering_coefficient, scattering_coefficient_a, scattering_coefficient_b, deciviews, deciviews_a, deciviews_b, visual_range, visual_range_a, visual_range_b
+
+                            Particle count fields:
+                            0.3_um_count, 0.3_um_count_a, 0.3_um_count_b, 0.5_um_count, 0.5_um_count_a, 0.5_um_count_b, 1.0_um_count, 1.0_um_count_a, 1.0_um_count_b, 2.5_um_count, 2.5_um_count_a, 2.5_um_count_b, 5.0_um_count, 5.0_um_count_a, 5.0_um_count_b, 10.0_um_count, 10.0_um_count_a, 10.0_um_count_b
+
+                            For field descriptions, please see the 'sensor data fields'. section.
+        """
+
+        request_url = (
+            self._base_api_v1_request_string
+            + f"groups/{group_id}/members/{member_id}/history/?{fields}"
+        )
+
+        # Add to the request_url string depending on what optional parameters are
+        # passed in. Turn them into a dict of optional parameters
+        optional_parameters_dict = {
+            "start_timestamp": start_timestamp,
+            "end_timestamp": end_timestamp,
+            "average": average,
+        }
+
+        first_optional_parameter_separator = "&"
+        return self._send_url_get_request(
+            request_url,
+            self._your_api_read_key,
+            first_optional_parameter_separator,
+            optional_parameters_dict,
+        )
+
+    def request_members_data(
+        self,
+        group_id,
+        fields,
+        location_type=None,
+        read_keys=None,
+        show_only=None,
+        modified_since=None,
+        max_age=None,
+        nwlng=None,
+        nwlat=None,
+        selng=None,
+        selat=None,
+    ):
+        """
+        A method to get multiple members' data from from a group to which said members belong too.
+
+        :param int group_id: The group_id of the requested group. This group must be owned by the api_key.
+
+        :param str fields: The 'Fields' parameter specifies which 'sensor data fields' to include in the response. It is a comma separated list with one or more of the following:
+
+                            Station information and status fields:
+                            name, icon, model, hardware, location_type, private, latitude, longitude, altitude, position_rating, led_brightness, firmware_version, firmware_upgrade, rssi, uptime, pa_latency, memory, last_seen, last_modified, date_created, channel_state, channel_flags, channel_flags_manual, channel_flags_auto, confidence, confidence_manual, confidence_auto
+
+                            Environmental fields:
+                            humidity, humidity_a, humidity_b, temperature, temperature_a, temperature_b, pressure, pressure_a, pressure_b
+
+                            Miscellaneous fields:
+                            voc, voc_a, voc_b, ozone1, analog_input
+
+                            PM1.0 fields:
+                            pm1.0, pm1.0_a, pm1.0_b, pm1.0_atm, pm1.0_atm_a, pm1.0_atm_b, pm1.0_cf_1, pm1.0_cf_1_a, pm1.0_cf_1_b
+
+                            PM2.5 fields:
+                            pm2.5_alt, pm2.5_alt_a, pm2.5_alt_b, pm2.5, pm2.5_a, pm2.5_b, pm2.5_atm, pm2.5_atm_a, pm2.5_atm_b, pm2.5_cf_1, pm2.5_cf_1_a, pm2.5_cf_1_b
 
-        elif sensor_index is not None and sensor_id is None and owner_email is None and location_type is None:
+                            PM2.5 pseudo (simple running) average fields:
+                            pm2.5_10minute, pm2.5_10minute_a, pm2.5_10minute_b, pm2.5_30minute, pm2.5_30minute_a, pm2.5_30minute_b, pm2.5_60minute, pm2.5_60minute_a, pm2.5_60minute_b, pm2.5_6hour, pm2.5_6hour_a, pm2.5_6hour_b, pm2.5_24hour, pm2.5_24hour_a, pm2.5_24hour_b, pm2.5_1week, pm2.5_1week_a, pm2.5_1week_b
+
+                            PM10.0 fields:
+                            pm10.0, pm10.0_a, pm10.0_b, pm10.0_atm, pm10.0_atm_a, pm10.0_atm_b, pm10.0_cf_1, pm10.0_cf_1_a, pm10.0_cf_1_b
+
+                            Visibility fields:
+                            scattering_coefficient, scattering_coefficient_a, scattering_coefficient_b, deciviews, deciviews_a, deciviews_b, visual_range, visual_range_a, visual_range_b
+
+                            Particle count fields:
+                            0.3_um_count, 0.3_um_count_a, 0.3_um_count_b, 0.5_um_count, 0.5_um_count_a, 0.5_um_count_b, 1.0_um_count, 1.0_um_count_a, 1.0_um_count_b, 2.5_um_count, 2.5_um_count_a, 2.5_um_count_b, 5.0_um_count, 5.0_um_count_a, 5.0_um_count_b, 10.0_um_count 10.0_um_count_a, 10.0_um_count_b
+
+                            ThingSpeak fields, used to retrieve data from api.thingspeak.com:
+                            primary_id_a, primary_key_a, secondary_id_a, secondary_key_a, primary_id_b, primary_key_b, secondary_id_b, secondary_key_b
+
+                            For field descriptions, please see the 'sensor data fields'. section.
+
+        :param (optional) int location_type: The location_type of the sensors.
+                                             Possible values are: 0 = Outside or 1 = Inside.
+
+        :param (optional) str read_keys: A read_key is required for private devices. It is separate to the api_key and each sensor has its own read_key. Submit multiple keys by separating them with a comma (,) character for example: key-one,key-two,key-three.
+
+        :param (optional) str show_only: A comma (,) separated list of sensor_index values. When provided, the results are limited only to the sensors included in this list.
+
+        :param (optional) int modified_since: The modified_since parameter causes only sensors modified after the provided time stamp to be included in the results. Using the time_stamp value from a previous call (recommended) will limit results to those with new values since the last request. Using a value of 0 will match sensors modified at any time.
+
+        :param (optional) int max_age: Filter results to only include sensors modified or updated within the last number of seconds. Using a value of 0 will match sensors of any age.
+                                        Default value: 604800
+
+        :param (optional) int nwlng: A north west longitude for the bounding box.
+                                     Use a bounding box to limit the sensors returned to a specific geographic area. The bounding box is defined by two points, a north west latitude/longitude and a south east latitude/longitude.
+
+        :param (optional) int nwlat: A north west latitude for the bounding box.
+
+         :param (optional) int selng: A south east longitude for the bounding box.
+
+         :param (optional) int selat: A south east latitude for the bounding box.
+
+        """
+
+        request_url = (
+            self._base_api_v1_request_string + f"groups/{group_id}/members?{fields}"
+        )
+
+        # Add to the request_url string depending on what optional parameters are
+        # passed in. Turn them into a dict of optional parameters
+        optional_parameters_dict = {
+            "location_type": location_type,
+            "read_keys": read_keys,
+            "show_only": show_only,
+            "modified_since": modified_since,
+            "max_age": max_age,
+            "nwlng": nwlng,
+            "nwlat": nwlat,
+            "selng": selng,
+            "selat": selat,
+        }
+
+        first_optional_parameter_separator = "&"
+        return self._send_url_get_request(
+            request_url,
+            self._your_api_read_key,
+            first_optional_parameter_separator,
+            optional_parameters_dict,
+        )
+
+    def post_create_group_data(self, name):
+        """
+        A method to create a group for sensors.
+
+        :param str name: The name of the group to create.
+        """
+
+        post_url = self._base_api_v1_request_string + f"groups"
+
+        return self._send_url_post_request(
+            post_url, self._your_api_write_key, {"name": name}
+        )
+
+    def post_create_member(
+        self,
+        group_id,
+        sensor_index=None,
+        sensor_id=None,
+        owner_email=None,
+        location_type=None,
+    ):
+        """
+        Using a sensor_id (Parameters Option 1)
+        The sensor_id should be exactly as printed on the label on the sensor. When no owner_email is provided, the sensor has to be marked as public.
+
+        :param int group_id: The group_id of the group to add a member to. This group must be owned by the api_key.
+
+        :param str sensor_id: The sensor_id of the new member sensor. This must be AS PRINTED on the sensor’s label.
+
+        Using a sensor_index (Parameters Option 2)
+        The sensor_index can be found in lists for example from a /sensors api call. When no owner_email is provided, the sensor has to be marked as public.
+
+        :param int group_id: The group_id of the group to add a member to. This group must be owned by the api_key.
+
+        :param int sensor_index: The sensor_index of the new member as found in the JSON for this specific sensor.
+
+        Using sensor_id with a private sensor by specifying owner_email and optionally location_type. (Parameters Option 3)
+        This example will produce an error if any provided value does not match the current configuration of the sensor. Note, too many incorrect attempts may disable your API key, so do not try guessing the email!!
+
+        :param int group_id: The group_id of the group to add a member to. This group must be owned by the api_key.
+
+        :param str sensor_id: The sensor_id of the new member sensor. This must be AS PRINTED on the sensor’s label.
+
+        :param str owner_email: An email address that matches the Owner email as set by previously completing the PurpleAir registration form at www.purpleair.com/register.
+
+        :param (optional) int location_type: The expected location_type of the new member.
+                                             Possible values are: 0 = Outside or 1 = Inside.
+                                             If the target member is not of this type, an error will result.
+                                             NOTE: This value is required if the sensor in question is marked as ‘private’ on the registration form.
+        """
+
+        post_url = self._base_api_v1_request_string + f"groups/{group_id}/members"
+
+        if (
+            sensor_index is None
+            and sensor_id is not None
+            and owner_email is None
+            and location_type is None
+        ):
             # We good, use the sensor id
+            debug_log("post_create_member - option 1")
+            return self._send_url_post_request(
+                post_url, self._your_api_write_key, {"sensor_id": str(sensor_id)}
+            )
+
+        elif (
+            sensor_index is not None
+            and sensor_id is None
+            and owner_email is None
+            and location_type is None
+        ):
+            # We good, use the sensor index
             debug_log("post_create_member - option 2")
-            return self._send_url_post_request(post_url, self._your_api_write_key, {"sensor_index": sensor_index})
+            return self._send_url_post_request(
+                post_url, self._your_api_write_key, {"sensor_index": sensor_index}
+            )
 
         elif sensor_index is None and sensor_id is not None and owner_email is not None:
             # We good, use the private sensor id.
             debug_log("post_create_member - option 3")
-            return self._send_url_post_request(post_url, self._your_api_write_key, {"sensor_id": str(sensor_id), "owner_email": owner_email, "location_type": location_type})
+            return self._send_url_post_request(
+                post_url,
+                self._your_api_write_key,
+                {
+                    "sensor_id": str(sensor_id),
+                    "owner_email": owner_email,
+                    "location_type": location_type,
+                },
+            )
 
         else:
-            raise PurpleAirAPIError(
-                "Invalid configuration of method parameters!")
+            raise PurpleAirAPIError("Invalid configuration of method parameters!")
 
     def post_delete_group(self, group_id):
         """
-            A method to delete a group for sensors.
+        A method to delete a group for sensors.
 
-            :param int group_id: The group_id of the group to delete
+        :param int group_id: The group_id of the group to delete
         """
 
-        post_url = self._base_api_v1_request_string + \
-            f"groups/{group_id}"
+        post_url = self._base_api_v1_request_string + f"groups/{group_id}"
 
         return self._send_url_delete_request(post_url, self._your_api_write_key)
 
     def post_delete_member(self, group_id, member_id):
         """
-            :param int group_id: The group_id of the group in which member_id is in.
-            :param int member_id: The member_id to delete.
+        :param int group_id: The group_id of the group in which member_id is in.
+        :param int member_id: The member_id to delete.
         """
 
-        post_url = self._base_api_v1_request_string + \
-            f"groups/{group_id}/members/{member_id}"
+        post_url = (
+            self._base_api_v1_request_string + f"groups/{group_id}/members/{member_id}"
+        )
 
         return self._send_url_delete_request(post_url, self._your_api_write_key)
 
-    def _send_url_get_request(self, request_url, api_key_to_use, first_optional_parameter_separator, optional_parameters_dict={}):
+    def _send_url_get_request(
+        self,
+        request_url,
+        api_key_to_use,
+        first_optional_parameter_separator=None,
+        optional_parameters_dict=None,
+    ):
         """
-            A class helper to send the url request. It can also add onto the
-            'request_url' string if 'optional_parameters_dict' are provided.
+        A class helper to send the url request. It can also add onto the
+        'request_url' string if 'optional_parameters_dict' are provided.
 
-            :param str request_url: The constructed string url request string.
-            :param str first_optional_parameter_separator: The separator between first parameter
-                                                           in optional_parameters_dict. i.e '?' or '&'.
-            :param dict optional_parameters_dict: Optional parameters that can be added onto the
-                                                  request_url. By default '{}'.
+        :param str request_url: The constructed string url request string.
+        :param str first_optional_parameter_separator: The separator between first parameter
+                                                       in optional_parameters_dict. i.e '?' or '&'.
+        :param dict optional_parameters_dict: Optional parameters that can be added onto the
+                                              request_url.
         """
 
-        if optional_parameters_dict is not {}:
+        if optional_parameters_dict is not None:
+            if first_optional_parameter_separator not in ["?", "&"]:
+                raise PurpleAirAPIError(
+                    f"Invalid `first_optional_parameter_separator: {first_optional_parameter_separator}` passed into `_send_url_get_request`!"
+                )
+
             opt_param_count = 0
             for opt_param, val in optional_parameters_dict.items():
                 if val is not None:
                     opt_param_count = opt_param_count + 1
 
                     if opt_param_count == 1:
-                        request_url = request_url + \
-                            f"{first_optional_parameter_separator}{opt_param}={str(val)}"
+                        request_url = (
+                            request_url
+                            + f"{first_optional_parameter_separator}{opt_param}={str(val)}"
+                        )
 
                     elif opt_param_count >= 2:
-                        request_url = request_url + \
-                            f"&{opt_param}={str(val)}"
+                        request_url = request_url + f"&{opt_param}={str(val)}"
 
         # Strip any quotes that might persist
-        request_url = request_url.replace("\"" , "")
+        request_url = request_url.replace('"', "")
         # Strip away any whitespace that might persist
-        request_url = request_url.replace(" " , "")
+        request_url = request_url.replace(" ", "")
         debug_log(request_url)
-        my_request = requests.get(request_url, headers={
-                                  "X-API-Key": str(api_key_to_use)})
+        my_request = requests.get(
+            request_url, headers={"X-API-Key": str(api_key_to_use)}
+        )
 
-        the_request_text_as_json = self._convert_requests_text_to_json(
-            my_request.text)
+        the_request_text_as_json = self._convert_requests_text_to_json(my_request.text)
 
         if self._verify_request_status_codes(my_request.status_code):
             return the_request_text_as_json
 
         else:
             raise PurpleAirAPIError(
-                f"""{my_request.status_code}: {the_request_text_as_json['error']} - {the_request_text_as_json['description']}""")
+                f"""{my_request.status_code}: {the_request_text_as_json['error']} - {the_request_text_as_json['description']}"""
+            )
 
-    def _send_url_post_request(self, request_url, api_key_to_use, json_post_parameters={}):
+    def _send_url_post_request(
+        self, request_url, api_key_to_use, json_post_parameters={}
+    ):
         """
-            A class helper to send the url request. It can also add onto the
-            'request_url' string if 'optional_parameters_dict' are provided.
+        A class helper to send the url request. It can also add onto the
+        'request_url' string if 'optional_parameters_dict' are provided.
 
-            :param str request_url: The constructed string url request string.
+        :param str request_url: The constructed string url request string.
         """
 
         debug_log(request_url)
         if json_post_parameters:
             debug_log(json_post_parameters)
-            my_request = requests.post(request_url, headers={
-                "X-API-Key": str(api_key_to_use)}, json=json_post_parameters)
+            my_request = requests.post(
+                request_url,
+                headers={"X-API-Key": str(api_key_to_use)},
+                json=json_post_parameters,
+            )
 
         else:
             debug_log(json_post_parameters)
-            my_request = requests.post(request_url, headers={
-                "X-API-Key": str(api_key_to_use)})
+            my_request = requests.post(
+                request_url, headers={"X-API-Key": str(api_key_to_use)}
+            )
 
-        the_request_text_as_json = self._convert_requests_text_to_json(
-            my_request.text)
+        the_request_text_as_json = self._convert_requests_text_to_json(my_request.text)
 
         if self._verify_request_status_codes(my_request.status_code):
             return the_request_text_as_json
 
         else:
             raise PurpleAirAPIError(
-                f"""{my_request.status_code}: {the_request_text_as_json['error']} - {the_request_text_as_json['description']}""")
+                f"""{my_request.status_code}: {the_request_text_as_json['error']} - {the_request_text_as_json['description']}"""
+            )
 
-    def _send_url_delete_request(self, request_url, api_key_to_use, json_post_parameters={}):
+    def _send_url_delete_request(
+        self, request_url, api_key_to_use, json_post_parameters={}
+    ):
         """
-            A class helper to send the url request. It can also add onto the
-            'request_url' string if 'optional_parameters_dict' are provided.
+        A class helper to send the url request. It can also add onto the
+        'request_url' string if 'optional_parameters_dict' are provided.
 
-            :param str request_url: The constructed string url request string.
+        :param str request_url: The constructed string url request string.
         """
 
         debug_log(request_url)
         if json_post_parameters:
-            my_request = requests.delete(request_url, headers={
-                "X-API-Key": str(api_key_to_use)}, json=json_post_parameters)
+            my_request = requests.delete(
+                request_url,
+                headers={"X-API-Key": str(api_key_to_use)},
+                json=json_post_parameters,
+            )
 
         else:
-            my_request = requests.delete(request_url, headers={
-                "X-API-Key": str(api_key_to_use)})
+            my_request = requests.delete(
+                request_url, headers={"X-API-Key": str(api_key_to_use)}
+            )
 
-        the_request_text_as_json = self._convert_requests_text_to_json(
-            my_request.text)
+        the_request_text_as_json = self._convert_requests_text_to_json(my_request.text)
 
         if self._verify_request_status_codes(my_request.status_code):
             return the_request_text_as_json
 
         else:
             raise PurpleAirAPIError(
-                f"""{my_request.status_code}: {the_request_text_as_json['error']} - {the_request_text_as_json['description']}""")
+                f"""{my_request.status_code}: {the_request_text_as_json['error']} - {the_request_text_as_json['description']}"""
+            )
 
     @staticmethod
     def _verify_request_status_codes(status_code) -> bool:
         """
-            A helper to check those status codes.
-            True if in SUCCESS_CODE_LIST
-            False if in ERROR_CODES_LIST
+        A helper to check those status codes.
+        True if in SUCCESS_CODE_LIST
+        False if in ERROR_CODES_LIST
         """
 
         if status_code in SUCCESS_CODE_LIST:
@@ -540,7 +897,7 @@ def _verify_request_status_codes(status_code) -> bool:
     @staticmethod
     def _convert_requests_text_to_json(text) -> dict:
         """
-            A helper to convert request.text to json.
+        A helper to convert request.text to json.
         """
 
         the_request_text_as_json = None
@@ -552,13 +909,13 @@ def _convert_requests_text_to_json(text) -> dict:
 
     def _sanitize_sensor_data_from_paa(self, paa_return_data):
         """
-            A helper method.
-            Since not all sensors support all field names we check that the keys exist
-            in the sensor data. If they do not exist we add it in with a NULL 
-            equivalent. i.e 0.0, 0, "", etc.
-            We access the "sensor" key inside this method.
+        A helper method.
+        Since not all sensors support all field names we check that the keys exist
+        in the sensor data. If they do not exist we add it in with a NULL
+        equivalent. i.e 0.0, 0, "", etc.
+        We access the "sensor" key inside this method.
 
-            :param dict paa_return_data: A dictionary with paa return data
+        :param dict paa_return_data: A dictionary with paa return data
         """
 
         for key_str in ACCEPTED_FIELD_NAMES_DICT.keys():
diff --git a/purpleair_data_logger/PurpleAirAPIConstants.py b/purpleair_data_logger/PurpleAirAPIConstants.py
index a9f4b5c..086e614 100644
--- a/purpleair_data_logger/PurpleAirAPIConstants.py
+++ b/purpleair_data_logger/PurpleAirAPIConstants.py
@@ -19,33 +19,129 @@
 #: These keys are derived from the PurpleAir documentation: https://api.purpleair.com/#api-sensors-get-sensor-data
 ACCEPTED_FIELD_NAMES_DICT = {
     # Station information and status fields:
-    "name": "", "icon": 0, "model": "", "hardware": "", "location_type": 0, "private": 0, "latitude": 0.0, "longitude": 0.0, "altitude": 0.0, "position_rating": 0, "led_brightness": 0, "firmware_version": "", "firmware_upgrade": "", "rssi": 0, "uptime": 0, "pa_latency": 0, "memory": 0, "last_seen": 0, "last_modified": 0, "date_created": 0, "channel_state": 0, "channel_flags": 0, "channel_flags_manual": 0, "channel_flags_auto": 0, "confidence": 0, "confidence_manual": 0, "confidence_auto": 0,
-
+    "name": "",
+    "icon": 0,
+    "model": "",
+    "hardware": "",
+    "location_type": 0,
+    "private": 0,
+    "latitude": 0.0,
+    "longitude": 0.0,
+    "altitude": 0.0,
+    "position_rating": 0,
+    "led_brightness": 0,
+    "firmware_version": "",
+    "firmware_upgrade": "",
+    "rssi": 0,
+    "uptime": 0,
+    "pa_latency": 0,
+    "memory": 0,
+    "last_seen": 0,
+    "last_modified": 0,
+    "date_created": 0,
+    "channel_state": 0,
+    "channel_flags": 0,
+    "channel_flags_manual": 0,
+    "channel_flags_auto": 0,
+    "confidence": 0,
+    "confidence_manual": 0,
+    "confidence_auto": 0,
     # Environmental fields:
-    "humidity": 0, "humidity_a": 0, "humidity_b": 0, "temperature": 0, "temperature_a": 0, "temperature_b": 0, "pressure": 0.0, "pressure_a": 0.0, "pressure_b": 0.0,
-
+    "humidity": 0,
+    "humidity_a": 0,
+    "humidity_b": 0,
+    "temperature": 0,
+    "temperature_a": 0,
+    "temperature_b": 0,
+    "pressure": 0.0,
+    "pressure_a": 0.0,
+    "pressure_b": 0.0,
     # Miscellaneous fields:
-    "voc": 0.0, "voc_a": 0.0, "voc_b": 0.0, "ozone1": 0.0, "analog_input": 0.0,
-
+    "voc": 0.0,
+    "voc_a": 0.0,
+    "voc_b": 0.0,
+    "ozone1": 0.0,
+    "analog_input": 0.0,
     # PM1.0 fields:
-    "pm1.0": 0.0, "pm1.0_a": 0.0, "pm1.0_b": 0.0, "pm1.0_atm": 0.0, "pm1.0_atm_a": 0.0, "pm1.0_atm_b": 0.0, "pm1.0_cf_1": 0.0, "pm1.0_cf_1_a": 0.0,
+    "pm1.0": 0.0,
+    "pm1.0_a": 0.0,
+    "pm1.0_b": 0.0,
+    "pm1.0_atm": 0.0,
+    "pm1.0_atm_a": 0.0,
+    "pm1.0_atm_b": 0.0,
+    "pm1.0_cf_1": 0.0,
+    "pm1.0_cf_1_a": 0.0,
     "pm1.0_cf_1_b": 0.0,
-
     # PM2.5 fields:
-    "pm2.5_alt": 0.0, "pm2.5_alt_a": 0.0, "pm2.5_alt_b": 0.0, "pm2.5": 0.0, "pm2.5_a": 0.0, "pm2.5_b": 0.0, "pm2.5_atm": 0.0, "pm2.5_atm_a": 0.0, "pm2.5_atm_b": 0.0, "pm2.5_cf_1": 0.0, "pm2.5_cf_1_a": 0.0, "pm2.5_cf_1_b": 0.0,
-
+    "pm2.5_alt": 0.0,
+    "pm2.5_alt_a": 0.0,
+    "pm2.5_alt_b": 0.0,
+    "pm2.5": 0.0,
+    "pm2.5_a": 0.0,
+    "pm2.5_b": 0.0,
+    "pm2.5_atm": 0.0,
+    "pm2.5_atm_a": 0.0,
+    "pm2.5_atm_b": 0.0,
+    "pm2.5_cf_1": 0.0,
+    "pm2.5_cf_1_a": 0.0,
+    "pm2.5_cf_1_b": 0.0,
     # PM2.5 pseudo (simple running) average fields:
     # Note: These are inside the return json as json["sensor"]["stats"]. They are averages of the two sensors.
     # sensor 'a' and 'b' sensor be. Each sensors data is inside json["sensor"]["stats_a"] and json["sensor"]["stats_b"]
-    "pm2.5_10minute": 0.0, "pm2.5_10minute_a": 0.0, "pm2.5_10minute_b": 0.0, "pm2.5_30minute": 0.0, "pm2.5_30minute_a": 0.0, "pm2.5_30minute_b": 0.0, "pm2.5_60minute": 0.0, "pm2.5_60minute_a": 0.0, "pm2.5_60minute_b": 0.0, "pm2.5_6hour": 0.0, "pm2.5_6hour_a": 0.0, "pm2.5_6hour_b": 0.0,
-    "pm2.5_24hour": 0.0, "pm2.5_24hour_a": 0.0, "pm2.5_24hour_b": 0.0, "pm2.5_1week": 0.0, "pm2.5_1week_a": 0.0, "pm2.5_1week_b": 0.0,
-
+    "pm2.5_10minute": 0.0,
+    "pm2.5_10minute_a": 0.0,
+    "pm2.5_10minute_b": 0.0,
+    "pm2.5_30minute": 0.0,
+    "pm2.5_30minute_a": 0.0,
+    "pm2.5_30minute_b": 0.0,
+    "pm2.5_60minute": 0.0,
+    "pm2.5_60minute_a": 0.0,
+    "pm2.5_60minute_b": 0.0,
+    "pm2.5_6hour": 0.0,
+    "pm2.5_6hour_a": 0.0,
+    "pm2.5_6hour_b": 0.0,
+    "pm2.5_24hour": 0.0,
+    "pm2.5_24hour_a": 0.0,
+    "pm2.5_24hour_b": 0.0,
+    "pm2.5_1week": 0.0,
+    "pm2.5_1week_a": 0.0,
+    "pm2.5_1week_b": 0.0,
     # PM10.0 fields:
-    "pm10.0": 0.0, "pm10.0_a": 0.0, "pm10.0_b": 0.0, "pm10.0_atm": 0.0, "pm10.0_atm_a": 0.0, "pm10.0_atm_b": 0.0, "pm10.0_cf_1": 0.0, "pm10.0_cf_1_a": 0.0, "pm10.0_cf_1_b": 0.0,
-
+    "pm10.0": 0.0,
+    "pm10.0_a": 0.0,
+    "pm10.0_b": 0.0,
+    "pm10.0_atm": 0.0,
+    "pm10.0_atm_a": 0.0,
+    "pm10.0_atm_b": 0.0,
+    "pm10.0_cf_1": 0.0,
+    "pm10.0_cf_1_a": 0.0,
+    "pm10.0_cf_1_b": 0.0,
     # Particle count fields:
-    "0.3_um_count": 0.0, "0.3_um_count_a": 0.0, "0.3_um_count_b": 0.0, "0.5_um_count": 0.0, "0.5_um_count_a": 0.0, "0.5_um_count_b": 0.0, "1.0_um_count": 0.0, "1.0_um_count_a": 0.0, "1.0_um_count_b": 0.0, "2.5_um_count": 0.0, "2.5_um_count_a": 0.0, "2.5_um_count_b": 0.0, "5.0_um_count": 0.0, "5.0_um_count_a": 0.0, "5.0_um_count_b": 0.0, "10.0_um_count": 0.0, "10.0_um_count_a": 0.0, "10.0_um_count_b": 0.0,
-
+    "0.3_um_count": 0.0,
+    "0.3_um_count_a": 0.0,
+    "0.3_um_count_b": 0.0,
+    "0.5_um_count": 0.0,
+    "0.5_um_count_a": 0.0,
+    "0.5_um_count_b": 0.0,
+    "1.0_um_count": 0.0,
+    "1.0_um_count_a": 0.0,
+    "1.0_um_count_b": 0.0,
+    "2.5_um_count": 0.0,
+    "2.5_um_count_a": 0.0,
+    "2.5_um_count_b": 0.0,
+    "5.0_um_count": 0.0,
+    "5.0_um_count_a": 0.0,
+    "5.0_um_count_b": 0.0,
+    "10.0_um_count": 0.0,
+    "10.0_um_count_a": 0.0,
+    "10.0_um_count_b": 0.0,
     # ThingSpeak fields, used to retrieve data from api.thingspeak.com:
-    "primary_id_a": 0, "primary_key_a": "", "secondary_id_a": 0, "secondary_key_a": "", "primary_id_b": 0, "primary_key_b": "", "secondary_id_b": 0, "secondary_key_b": ""
+    "primary_id_a": 0,
+    "primary_key_a": "",
+    "secondary_id_a": 0,
+    "secondary_key_a": "",
+    "primary_id_b": 0,
+    "primary_key_b": "",
+    "secondary_id_b": 0,
+    "secondary_key_b": "",
 }
diff --git a/purpleair_data_logger/PurpleAirCSVDataLogger.py b/purpleair_data_logger/PurpleAirCSVDataLogger.py
index d3e91f1..19869d5 100644
--- a/purpleair_data_logger/PurpleAirCSVDataLogger.py
+++ b/purpleair_data_logger/PurpleAirCSVDataLogger.py
@@ -15,15 +15,25 @@
 
 from purpleair_data_logger.PurpleAirDataLogger import PurpleAirDataLogger
 from purpleair_data_logger.PurpleAirCSVDataLoggerConstants import (
-    STATION_INFORMATION_AND_STATUS_FIELDS_FILE_NAME, STATION_INFORMATION_AND_STATUS_FIELDS_HEADER,
-    ENVIRONMENTAL_FIELDS_FILE_NAME, ENVIRONMENTAL_FIELDS_HEADER,
-    MISCELLANEOUS_FIELDS_FILE_NAME, MISCELLANEOUS_FIELDS_HEADER,
-    PM1_0_FIELDS_FILE_NAME, PM1_0_FIELDS_HEADER,
-    PM2_5_FIELDS_FILE_NAME, PM2_5_FIELDS_HEADER,
-    PM2_5_PSEUDO_AVERAGE_FIELDS_FILE_NAME, PM2_5_PSEUDO_AVERAGE_FIELDS_HEADER,
-    PM10_0_FIELDS_FILE_NAME, PM10_0_FIELDS_HEADER,
-    PARTICLE_COUNT_FIELDS_FILE_NAME, PARTICLE_COUNT_FIELDS_HEADER,
-    THINGSPEAK_FIELDS_FILE_NAME, THINGSPEAK_FIELDS_HEADER)
+    STATION_INFORMATION_AND_STATUS_FIELDS_FILE_NAME,
+    STATION_INFORMATION_AND_STATUS_FIELDS_HEADER,
+    ENVIRONMENTAL_FIELDS_FILE_NAME,
+    ENVIRONMENTAL_FIELDS_HEADER,
+    MISCELLANEOUS_FIELDS_FILE_NAME,
+    MISCELLANEOUS_FIELDS_HEADER,
+    PM1_0_FIELDS_FILE_NAME,
+    PM1_0_FIELDS_HEADER,
+    PM2_5_FIELDS_FILE_NAME,
+    PM2_5_FIELDS_HEADER,
+    PM2_5_PSEUDO_AVERAGE_FIELDS_FILE_NAME,
+    PM2_5_PSEUDO_AVERAGE_FIELDS_HEADER,
+    PM10_0_FIELDS_FILE_NAME,
+    PM10_0_FIELDS_HEADER,
+    PARTICLE_COUNT_FIELDS_FILE_NAME,
+    PARTICLE_COUNT_FIELDS_HEADER,
+    THINGSPEAK_FIELDS_FILE_NAME,
+    THINGSPEAK_FIELDS_HEADER,
+)
 from os import makedirs
 from os.path import exists
 import argparse
@@ -31,14 +41,14 @@
 
 class PurpleAirCSVDataLogger(PurpleAirDataLogger):
     """
-        The logger class. For now we will insert data into a CSV file.
+    The logger class. For now we will insert data into a CSV file.
     """
 
     def __init__(self, PurpleAirAPIReadKey, path_to_save_csv_files_in):
         """
-            :param str PurpleAirAPIReadKey: A valid PurpleAirAPI Read key
-            :param object path_to_save_csv_files_in: A string directory path
-                                                     to save files in.
+        :param str PurpleAirAPIReadKey: A valid PurpleAirAPI Read key
+        :param object path_to_save_csv_files_in: A string directory path
+                                                 to save files in.
         """
 
         # Inherit everything from the parent base class: PurpleAirDataLogger
@@ -54,10 +64,10 @@ def __init__(self, PurpleAirAPIReadKey, path_to_save_csv_files_in):
     @staticmethod
     def _open_csv_file(file_path_and_name):
         """
-            Create the given 'file_path_and_name'.
+        Create the given 'file_path_and_name'.
 
-            :param str file_path_and_name: A string of 'file_path_and_name'. i.e
-                                           '/path_to_place/file_name.csv'.
+        :param str file_path_and_name: A string of 'file_path_and_name'. i.e
+                                       '/path_to_place/file_name.csv'.
         """
         the_file_stream = open(file_path_and_name, "a")
         return the_file_stream
@@ -65,249 +75,395 @@ def _open_csv_file(file_path_and_name):
     @staticmethod
     def _close_and_flush_csv_file(the_file_stream):
         """
-            Close and flush the given 'the_file_stream'.
+        Close and flush the given 'the_file_stream'.
 
-            :param file_stream the_file_stream: An open file stream to flush and close.
+        :param file_stream the_file_stream: An open file stream to flush and close.
         """
         the_file_stream.flush()
         the_file_stream.close()
 
     def store_sensor_data(self, single_sensor_data_dict):
         """
-            Insert the sensor data into CSV files.
+        Insert the sensor data into CSV files.
 
-            :param dict single_sensor_data_dict: A python dictionary containing all fields
-                                                 for insertion. If a sensor doesn't support
-                                                 a certain field make sure it is NULL and part
-                                                 of the dictionary. This method does no type
-                                                 or error checking. That is upto the caller.
+        :param dict single_sensor_data_dict: A python dictionary containing all fields
+                                             for insertion. If a sensor doesn't support
+                                             a certain field make sure it is NULL and part
+                                             of the dictionary. This method does no type
+                                             or error checking. That is upto the caller.
         """
 
         # Step one make the self._path_to_save_csv_files_in if it doesn't exist already
         if exists(self._path_to_save_csv_files_in) == False:
-            print(
-                f"Creating storage directory: {self._path_to_save_csv_files_in}...")
+            print(f"Creating storage directory: {self._path_to_save_csv_files_in}...")
             makedirs(self._path_to_save_csv_files_in)
 
         try:
             # Step two create all the unique files names
             station_information_and_status_fields_file_stream = self._open_csv_file(
-                self._path_to_save_csv_files_in + "/" + STATION_INFORMATION_AND_STATUS_FIELDS_FILE_NAME)
+                self._path_to_save_csv_files_in
+                + "/"
+                + STATION_INFORMATION_AND_STATUS_FIELDS_FILE_NAME
+            )
 
             environmental_fields_file_steam = self._open_csv_file(
-                self._path_to_save_csv_files_in + "/" + ENVIRONMENTAL_FIELDS_FILE_NAME)
+                self._path_to_save_csv_files_in + "/" + ENVIRONMENTAL_FIELDS_FILE_NAME
+            )
 
             miscellaneous_fields_file_stream = self._open_csv_file(
-                self._path_to_save_csv_files_in + "/" + MISCELLANEOUS_FIELDS_FILE_NAME)
+                self._path_to_save_csv_files_in + "/" + MISCELLANEOUS_FIELDS_FILE_NAME
+            )
 
             pm1_0_fields_file_stream = self._open_csv_file(
-                self._path_to_save_csv_files_in + "/" + PM1_0_FIELDS_FILE_NAME)
+                self._path_to_save_csv_files_in + "/" + PM1_0_FIELDS_FILE_NAME
+            )
 
             pm2_5_fields_file_stream = self._open_csv_file(
-                self._path_to_save_csv_files_in + "/" + PM2_5_FIELDS_FILE_NAME)
+                self._path_to_save_csv_files_in + "/" + PM2_5_FIELDS_FILE_NAME
+            )
 
             pm2_5_pseudo_average_fields_file_stream = self._open_csv_file(
-                self._path_to_save_csv_files_in + "/" + PM2_5_PSEUDO_AVERAGE_FIELDS_FILE_NAME)
+                self._path_to_save_csv_files_in
+                + "/"
+                + PM2_5_PSEUDO_AVERAGE_FIELDS_FILE_NAME
+            )
 
             pm10_0_fields_file_stream = self._open_csv_file(
-                self._path_to_save_csv_files_in + "/" + PM10_0_FIELDS_FILE_NAME)
+                self._path_to_save_csv_files_in + "/" + PM10_0_FIELDS_FILE_NAME
+            )
 
             particle_count_fields_file_stream = self._open_csv_file(
-                self._path_to_save_csv_files_in + "/" + PARTICLE_COUNT_FIELDS_FILE_NAME)
+                self._path_to_save_csv_files_in + "/" + PARTICLE_COUNT_FIELDS_FILE_NAME
+            )
 
             thingspeak_fields_file_stream = self._open_csv_file(
-                self._path_to_save_csv_files_in + "/" + THINGSPEAK_FIELDS_FILE_NAME)
+                self._path_to_save_csv_files_in + "/" + THINGSPEAK_FIELDS_FILE_NAME
+            )
 
             if self._did_we_write_the_header_bool == False:
                 # Write the headers
                 station_information_and_status_fields_file_stream.write(
-                    STATION_INFORMATION_AND_STATUS_FIELDS_HEADER + "\n")
+                    STATION_INFORMATION_AND_STATUS_FIELDS_HEADER + "\n"
+                )
 
                 environmental_fields_file_steam.write(
-                    ENVIRONMENTAL_FIELDS_HEADER + "\n")
+                    ENVIRONMENTAL_FIELDS_HEADER + "\n"
+                )
 
                 miscellaneous_fields_file_stream.write(
-                    MISCELLANEOUS_FIELDS_HEADER + "\n")
+                    MISCELLANEOUS_FIELDS_HEADER + "\n"
+                )
 
-                pm1_0_fields_file_stream.write(
-                    PM1_0_FIELDS_HEADER + "\n")
+                pm1_0_fields_file_stream.write(PM1_0_FIELDS_HEADER + "\n")
 
-                pm2_5_fields_file_stream.write(
-                    PM2_5_FIELDS_HEADER + "\n")
+                pm2_5_fields_file_stream.write(PM2_5_FIELDS_HEADER + "\n")
 
                 pm2_5_pseudo_average_fields_file_stream.write(
-                    PM2_5_PSEUDO_AVERAGE_FIELDS_HEADER + "\n")
+                    PM2_5_PSEUDO_AVERAGE_FIELDS_HEADER + "\n"
+                )
 
-                pm10_0_fields_file_stream.write(
-                    PM10_0_FIELDS_HEADER + "\n")
+                pm10_0_fields_file_stream.write(PM10_0_FIELDS_HEADER + "\n")
 
                 particle_count_fields_file_stream.write(
-                    PARTICLE_COUNT_FIELDS_HEADER + "\n")
+                    PARTICLE_COUNT_FIELDS_HEADER + "\n"
+                )
 
-                thingspeak_fields_file_stream.write(
-                    THINGSPEAK_FIELDS_HEADER + "\n")
+                thingspeak_fields_file_stream.write(THINGSPEAK_FIELDS_HEADER + "\n")
 
                 self._did_we_write_the_header_bool = True
 
             # Step three write data to all files.
             station_information_and_status_fields_file_stream.write(
-                str(single_sensor_data_dict["data_time_stamp"]) + "," +
-                str(single_sensor_data_dict["sensor_index"]) + "," +
-                str(single_sensor_data_dict["name"]) + "," +
-                str(single_sensor_data_dict["icon"]) + "," +
-                str(single_sensor_data_dict["model"]) + "," +
-                str(single_sensor_data_dict["hardware"]) + "," +
-                str(single_sensor_data_dict["location_type"]) + "," +
-                str(single_sensor_data_dict["private"]) + "," +
-                str(single_sensor_data_dict["latitude"]) + "," +
-                str(single_sensor_data_dict["longitude"]) + "," +
-                str(single_sensor_data_dict["altitude"]) + "," +
-                str(single_sensor_data_dict["position_rating"]) + "," +
-                str(single_sensor_data_dict["led_brightness"]) + "," +
-                str(single_sensor_data_dict["firmware_version"]) + "," +
-                str(single_sensor_data_dict["firmware_upgrade"]) + "," +
-                str(single_sensor_data_dict["rssi"]) + "," +
-                str(single_sensor_data_dict["uptime"]) + "," +
-                str(single_sensor_data_dict["pa_latency"]) + "," +
-                str(single_sensor_data_dict["memory"]) + "," +
-                str(single_sensor_data_dict["last_seen"]) + "," +
-                str(single_sensor_data_dict["last_modified"]) + "," +
-                str(single_sensor_data_dict["date_created"]) + "," +
-                str(single_sensor_data_dict["channel_state"]) + "," +
-                str(single_sensor_data_dict["channel_flags"]) + "," +
-                str(single_sensor_data_dict["channel_flags_manual"]) + "," +
-                str(single_sensor_data_dict["channel_flags_auto"]) + "," +
-                str(single_sensor_data_dict["confidence"]) + "," +
-                str(single_sensor_data_dict["confidence_manual"]) + "," +
-                str(single_sensor_data_dict["confidence_auto"]) + "\n"
+                str(single_sensor_data_dict["data_time_stamp"])
+                + ","
+                + str(single_sensor_data_dict["sensor_index"])
+                + ","
+                + str(single_sensor_data_dict["name"])
+                + ","
+                + str(single_sensor_data_dict["icon"])
+                + ","
+                + str(single_sensor_data_dict["model"])
+                + ","
+                + str(single_sensor_data_dict["hardware"])
+                + ","
+                + str(single_sensor_data_dict["location_type"])
+                + ","
+                + str(single_sensor_data_dict["private"])
+                + ","
+                + str(single_sensor_data_dict["latitude"])
+                + ","
+                + str(single_sensor_data_dict["longitude"])
+                + ","
+                + str(single_sensor_data_dict["altitude"])
+                + ","
+                + str(single_sensor_data_dict["position_rating"])
+                + ","
+                + str(single_sensor_data_dict["led_brightness"])
+                + ","
+                + str(single_sensor_data_dict["firmware_version"])
+                + ","
+                + str(single_sensor_data_dict["firmware_upgrade"])
+                + ","
+                + str(single_sensor_data_dict["rssi"])
+                + ","
+                + str(single_sensor_data_dict["uptime"])
+                + ","
+                + str(single_sensor_data_dict["pa_latency"])
+                + ","
+                + str(single_sensor_data_dict["memory"])
+                + ","
+                + str(single_sensor_data_dict["last_seen"])
+                + ","
+                + str(single_sensor_data_dict["last_modified"])
+                + ","
+                + str(single_sensor_data_dict["date_created"])
+                + ","
+                + str(single_sensor_data_dict["channel_state"])
+                + ","
+                + str(single_sensor_data_dict["channel_flags"])
+                + ","
+                + str(single_sensor_data_dict["channel_flags_manual"])
+                + ","
+                + str(single_sensor_data_dict["channel_flags_auto"])
+                + ","
+                + str(single_sensor_data_dict["confidence"])
+                + ","
+                + str(single_sensor_data_dict["confidence_manual"])
+                + ","
+                + str(single_sensor_data_dict["confidence_auto"])
+                + "\n"
             )
 
             environmental_fields_file_steam.write(
-                str(single_sensor_data_dict["data_time_stamp"]) + "," +
-                str(single_sensor_data_dict["sensor_index"]) + "," +
-                str(single_sensor_data_dict["humidity"]) + "," +
-                str(single_sensor_data_dict["humidity_a"]) + "," +
-                str(single_sensor_data_dict["humidity_b"]) + "," +
-                str(single_sensor_data_dict["temperature"]) + "," +
-                str(single_sensor_data_dict["temperature_a"]) + "," +
-                str(single_sensor_data_dict["temperature_b"]) + "," +
-                str(single_sensor_data_dict["pressure"]) + "," +
-                str(single_sensor_data_dict["pressure_a"]) + "," +
-                str(single_sensor_data_dict["pressure_b"]) + "\n"
+                str(single_sensor_data_dict["data_time_stamp"])
+                + ","
+                + str(single_sensor_data_dict["sensor_index"])
+                + ","
+                + str(single_sensor_data_dict["humidity"])
+                + ","
+                + str(single_sensor_data_dict["humidity_a"])
+                + ","
+                + str(single_sensor_data_dict["humidity_b"])
+                + ","
+                + str(single_sensor_data_dict["temperature"])
+                + ","
+                + str(single_sensor_data_dict["temperature_a"])
+                + ","
+                + str(single_sensor_data_dict["temperature_b"])
+                + ","
+                + str(single_sensor_data_dict["pressure"])
+                + ","
+                + str(single_sensor_data_dict["pressure_a"])
+                + ","
+                + str(single_sensor_data_dict["pressure_b"])
+                + "\n"
             )
 
             miscellaneous_fields_file_stream.write(
-                str(single_sensor_data_dict["data_time_stamp"]) + "," +
-                str(single_sensor_data_dict["sensor_index"]) + "," +
-                str(single_sensor_data_dict["voc"]) + "," +
-                str(single_sensor_data_dict["voc_a"]) + "," +
-                str(single_sensor_data_dict["voc_b"]) + "," +
-                str(single_sensor_data_dict["ozone1"]) + "," +
-                str(single_sensor_data_dict["analog_input"]) + "\n"
+                str(single_sensor_data_dict["data_time_stamp"])
+                + ","
+                + str(single_sensor_data_dict["sensor_index"])
+                + ","
+                + str(single_sensor_data_dict["voc"])
+                + ","
+                + str(single_sensor_data_dict["voc_a"])
+                + ","
+                + str(single_sensor_data_dict["voc_b"])
+                + ","
+                + str(single_sensor_data_dict["ozone1"])
+                + ","
+                + str(single_sensor_data_dict["analog_input"])
+                + "\n"
             )
 
             pm1_0_fields_file_stream.write(
-                str(single_sensor_data_dict["data_time_stamp"]) + "," +
-                str(single_sensor_data_dict["sensor_index"]) + "," +
-                str(single_sensor_data_dict["pm1.0"]) + "," +
-                str(single_sensor_data_dict["pm1.0_a"]) + "," +
-                str(single_sensor_data_dict["pm1.0_b"]) + "," +
-                str(single_sensor_data_dict["pm1.0_atm"]) + "," +
-                str(single_sensor_data_dict["pm1.0_atm_a"]) + "," +
-                str(single_sensor_data_dict["pm1.0_atm_b"]) + "," +
-                str(single_sensor_data_dict["pm1.0_cf_1"]) + "," +
-                str(single_sensor_data_dict["pm1.0_cf_1_a"]) + "," +
-                str(single_sensor_data_dict["pm1.0_cf_1_b"]) + "\n"
+                str(single_sensor_data_dict["data_time_stamp"])
+                + ","
+                + str(single_sensor_data_dict["sensor_index"])
+                + ","
+                + str(single_sensor_data_dict["pm1.0"])
+                + ","
+                + str(single_sensor_data_dict["pm1.0_a"])
+                + ","
+                + str(single_sensor_data_dict["pm1.0_b"])
+                + ","
+                + str(single_sensor_data_dict["pm1.0_atm"])
+                + ","
+                + str(single_sensor_data_dict["pm1.0_atm_a"])
+                + ","
+                + str(single_sensor_data_dict["pm1.0_atm_b"])
+                + ","
+                + str(single_sensor_data_dict["pm1.0_cf_1"])
+                + ","
+                + str(single_sensor_data_dict["pm1.0_cf_1_a"])
+                + ","
+                + str(single_sensor_data_dict["pm1.0_cf_1_b"])
+                + "\n"
             )
 
             pm2_5_fields_file_stream.write(
-                str(single_sensor_data_dict["data_time_stamp"]) + "," +
-                str(single_sensor_data_dict["sensor_index"]) + "," +
-                str(single_sensor_data_dict["pm2.5_alt"]) + "," +
-                str(single_sensor_data_dict["pm2.5_alt_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_alt_b"]) + "," +
-                str(single_sensor_data_dict["pm2.5"]) + "," +
-                str(single_sensor_data_dict["pm2.5_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_b"]) + "," +
-                str(single_sensor_data_dict["pm2.5_atm"]) + "," +
-                str(single_sensor_data_dict["pm2.5_atm_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_atm_b"]) + "," +
-                str(single_sensor_data_dict["pm2.5_cf_1"]) + "," +
-                str(single_sensor_data_dict["pm2.5_cf_1_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_cf_1_b"]) + "\n"
+                str(single_sensor_data_dict["data_time_stamp"])
+                + ","
+                + str(single_sensor_data_dict["sensor_index"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_alt"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_alt_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_alt_b"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_b"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_atm"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_atm_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_atm_b"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_cf_1"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_cf_1_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_cf_1_b"])
+                + "\n"
             )
 
             pm2_5_pseudo_average_fields_file_stream.write(
-                str(single_sensor_data_dict["data_time_stamp"]) + "," +
-                str(single_sensor_data_dict["sensor_index"]) + "," +
-                str(single_sensor_data_dict["pm2.5_10minute"]) + "," +
-                str(single_sensor_data_dict["pm2.5_10minute_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_10minute_b"]) + "," +
-                str(single_sensor_data_dict["pm2.5_30minute"]) + "," +
-                str(single_sensor_data_dict["pm2.5_30minute_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_30minute_b"]) + "," +
-                str(single_sensor_data_dict["pm2.5_60minute"]) + "," +
-                str(single_sensor_data_dict["pm2.5_60minute_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_60minute_b"]) + "," +
-                str(single_sensor_data_dict["pm2.5_6hour"]) + "," +
-                str(single_sensor_data_dict["pm2.5_6hour_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_6hour_b"]) + "," +
-                str(single_sensor_data_dict["pm2.5_24hour"]) + "," +
-                str(single_sensor_data_dict["pm2.5_24hour_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_24hour_b"]) + "," +
-                str(single_sensor_data_dict["pm2.5_1week"]) + "," +
-                str(single_sensor_data_dict["pm2.5_1week_a"]) + "," +
-                str(single_sensor_data_dict["pm2.5_1week_b"]) + "\n"
+                str(single_sensor_data_dict["data_time_stamp"])
+                + ","
+                + str(single_sensor_data_dict["sensor_index"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_10minute"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_10minute_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_10minute_b"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_30minute"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_30minute_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_30minute_b"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_60minute"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_60minute_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_60minute_b"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_6hour"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_6hour_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_6hour_b"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_24hour"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_24hour_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_24hour_b"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_1week"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_1week_a"])
+                + ","
+                + str(single_sensor_data_dict["pm2.5_1week_b"])
+                + "\n"
             )
 
             pm10_0_fields_file_stream.write(
-                str(single_sensor_data_dict["data_time_stamp"]) + "," +
-                str(single_sensor_data_dict["sensor_index"]) + "," +
-                str(single_sensor_data_dict["pm10.0"]) + "," +
-                str(single_sensor_data_dict["pm10.0_a"]) + "," +
-                str(single_sensor_data_dict["pm10.0_b"]) + "," +
-                str(single_sensor_data_dict["pm10.0_atm"]) + "," +
-                str(single_sensor_data_dict["pm10.0_atm_a"]) + "," +
-                str(single_sensor_data_dict["pm10.0_atm_b"]) + "," +
-                str(single_sensor_data_dict["pm10.0_cf_1"]) + "," +
-                str(single_sensor_data_dict["pm10.0_cf_1_a"]) + "," +
-                str(single_sensor_data_dict["pm10.0_cf_1_b"]) + "\n"
+                str(single_sensor_data_dict["data_time_stamp"])
+                + ","
+                + str(single_sensor_data_dict["sensor_index"])
+                + ","
+                + str(single_sensor_data_dict["pm10.0"])
+                + ","
+                + str(single_sensor_data_dict["pm10.0_a"])
+                + ","
+                + str(single_sensor_data_dict["pm10.0_b"])
+                + ","
+                + str(single_sensor_data_dict["pm10.0_atm"])
+                + ","
+                + str(single_sensor_data_dict["pm10.0_atm_a"])
+                + ","
+                + str(single_sensor_data_dict["pm10.0_atm_b"])
+                + ","
+                + str(single_sensor_data_dict["pm10.0_cf_1"])
+                + ","
+                + str(single_sensor_data_dict["pm10.0_cf_1_a"])
+                + ","
+                + str(single_sensor_data_dict["pm10.0_cf_1_b"])
+                + "\n"
             )
 
             particle_count_fields_file_stream.write(
-                str(single_sensor_data_dict["data_time_stamp"]) + "," +
-                str(single_sensor_data_dict["sensor_index"]) + "," +
-                str(single_sensor_data_dict["0.3_um_count"]) + "," +
-                str(single_sensor_data_dict["0.3_um_count_a"]) + "," +
-                str(single_sensor_data_dict["0.3_um_count_b"]) + "," +
-                str(single_sensor_data_dict["0.5_um_count"]) + "," +
-                str(single_sensor_data_dict["0.5_um_count_a"]) + "," +
-                str(single_sensor_data_dict["0.5_um_count_b"]) + "," +
-                str(single_sensor_data_dict["1.0_um_count"]) + "," +
-                str(single_sensor_data_dict["1.0_um_count_a"]) + "," +
-                str(single_sensor_data_dict["1.0_um_count_b"]) + "," +
-                str(single_sensor_data_dict["2.5_um_count"]) + "," +
-                str(single_sensor_data_dict["2.5_um_count_a"]) + "," +
-                str(single_sensor_data_dict["2.5_um_count_b"]) + "," +
-                str(single_sensor_data_dict["5.0_um_count"]) + "," +
-                str(single_sensor_data_dict["5.0_um_count_a"]) + "," +
-                str(single_sensor_data_dict["5.0_um_count_b"]) + "," +
-                str(single_sensor_data_dict["10.0_um_count"]) + "," +
-                str(single_sensor_data_dict["10.0_um_count_a"]) + "," +
-                str(single_sensor_data_dict["10.0_um_count_b"]) + "\n"
+                str(single_sensor_data_dict["data_time_stamp"])
+                + ","
+                + str(single_sensor_data_dict["sensor_index"])
+                + ","
+                + str(single_sensor_data_dict["0.3_um_count"])
+                + ","
+                + str(single_sensor_data_dict["0.3_um_count_a"])
+                + ","
+                + str(single_sensor_data_dict["0.3_um_count_b"])
+                + ","
+                + str(single_sensor_data_dict["0.5_um_count"])
+                + ","
+                + str(single_sensor_data_dict["0.5_um_count_a"])
+                + ","
+                + str(single_sensor_data_dict["0.5_um_count_b"])
+                + ","
+                + str(single_sensor_data_dict["1.0_um_count"])
+                + ","
+                + str(single_sensor_data_dict["1.0_um_count_a"])
+                + ","
+                + str(single_sensor_data_dict["1.0_um_count_b"])
+                + ","
+                + str(single_sensor_data_dict["2.5_um_count"])
+                + ","
+                + str(single_sensor_data_dict["2.5_um_count_a"])
+                + ","
+                + str(single_sensor_data_dict["2.5_um_count_b"])
+                + ","
+                + str(single_sensor_data_dict["5.0_um_count"])
+                + ","
+                + str(single_sensor_data_dict["5.0_um_count_a"])
+                + ","
+                + str(single_sensor_data_dict["5.0_um_count_b"])
+                + ","
+                + str(single_sensor_data_dict["10.0_um_count"])
+                + ","
+                + str(single_sensor_data_dict["10.0_um_count_a"])
+                + ","
+                + str(single_sensor_data_dict["10.0_um_count_b"])
+                + "\n"
             )
 
             thingspeak_fields_file_stream.write(
-                str(single_sensor_data_dict["data_time_stamp"]) + "," +
-                str(single_sensor_data_dict["sensor_index"]) + "," +
-                str(single_sensor_data_dict["primary_id_a"]) + "," +
-                str(single_sensor_data_dict["primary_key_a"]) + "," +
-                str(single_sensor_data_dict["secondary_id_a"]) + "," +
-                str(single_sensor_data_dict["secondary_key_a"]) + "," +
-                str(single_sensor_data_dict["primary_id_b"]) + "," +
-                str(single_sensor_data_dict["primary_key_b"]) + "," +
-                str(single_sensor_data_dict["secondary_id_b"]) + "," +
-                str(single_sensor_data_dict["secondary_key_b"]) + "\n"
+                str(single_sensor_data_dict["data_time_stamp"])
+                + ","
+                + str(single_sensor_data_dict["sensor_index"])
+                + ","
+                + str(single_sensor_data_dict["primary_id_a"])
+                + ","
+                + str(single_sensor_data_dict["primary_key_a"])
+                + ","
+                + str(single_sensor_data_dict["secondary_id_a"])
+                + ","
+                + str(single_sensor_data_dict["secondary_key_a"])
+                + ","
+                + str(single_sensor_data_dict["primary_id_b"])
+                + ","
+                + str(single_sensor_data_dict["primary_key_b"])
+                + ","
+                + str(single_sensor_data_dict["secondary_id_b"])
+                + ","
+                + str(single_sensor_data_dict["secondary_key_b"])
+                + "\n"
             )
 
         except UnicodeEncodeError as except_err:
@@ -317,13 +473,13 @@ def store_sensor_data(self, single_sensor_data_dict):
             print(f"Error is {except_err} \n")
 
         self._close_and_flush_csv_file(
-            station_information_and_status_fields_file_stream)
+            station_information_and_status_fields_file_stream
+        )
         self._close_and_flush_csv_file(environmental_fields_file_steam)
         self._close_and_flush_csv_file(miscellaneous_fields_file_stream)
         self._close_and_flush_csv_file(pm1_0_fields_file_stream)
         self._close_and_flush_csv_file(pm2_5_fields_file_stream)
-        self._close_and_flush_csv_file(
-            pm2_5_pseudo_average_fields_file_stream)
+        self._close_and_flush_csv_file(pm2_5_pseudo_average_fields_file_stream)
         self._close_and_flush_csv_file(pm10_0_fields_file_stream)
         self._close_and_flush_csv_file(particle_count_fields_file_stream)
         self._close_and_flush_csv_file(thingspeak_fields_file_stream)
@@ -331,19 +487,42 @@ def store_sensor_data(self, single_sensor_data_dict):
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
-        description="Collect data from PurpleAir sensors and store it in CSV files!")
-    parser.add_argument("-save_file_path",  required=True,
-                        dest="save_file_path", type=str, help="""The path to save CSV files in.""")
-    parser.add_argument("-paa_read_key",  required=True,
-                        dest="paa_read_key", type=str, help="""The PurpleAirAPI Read key""")
-    parser.add_argument("-paa_single_sensor_request_json_file",  required=False, default=None,
-                        dest="paa_single_sensor_request_json_file", type=str, help="""The
+        description="Collect data from PurpleAir sensors and store it in CSV files!"
+    )
+    parser.add_argument(
+        "-save_file_path",
+        required=True,
+        dest="save_file_path",
+        type=str,
+        help="""The path to save CSV files in.""",
+    )
+    parser.add_argument(
+        "-paa_read_key",
+        required=True,
+        dest="paa_read_key",
+        type=str,
+        help="""The PurpleAirAPI Read key""",
+    )
+    parser.add_argument(
+        "-paa_single_sensor_request_json_file",
+        required=False,
+        default=None,
+        dest="paa_single_sensor_request_json_file",
+        type=str,
+        help="""The
                         path to a json file containing the parameters to send a single
-                        sensor request.""")
-    parser.add_argument("-paa_multiple_sensor_request_json_file",  required=False, default=None,
-                        dest="paa_multiple_sensor_request_json_file", type=str, help="""The
+                        sensor request.""",
+    )
+    parser.add_argument(
+        "-paa_multiple_sensor_request_json_file",
+        required=False,
+        default=None,
+        dest="paa_multiple_sensor_request_json_file",
+        type=str,
+        help="""The
                         path to a json file containing the parameters to send a multiple
-                        sensor request.""")
+                        sensor request.""",
+    )
 
     args = parser.parse_args()
 
@@ -353,8 +532,11 @@ def store_sensor_data(self, single_sensor_data_dict):
 
     # Second make an instance our our data logger
     the_paa_csv_data_logger = PurpleAirCSVDataLogger(
-        args.paa_read_key, args.save_file_path)
+        args.paa_read_key, args.save_file_path
+    )
 
     # Third choose what run method to execute depending on paa_multiple_sensor_request_json_file/paa_single_sensor_request_json_file
     the_paa_csv_data_logger.validate_parameters_and_run(
-        args.paa_multiple_sensor_request_json_file, args.paa_single_sensor_request_json_file)
+        args.paa_multiple_sensor_request_json_file,
+        args.paa_single_sensor_request_json_file,
+    )
diff --git a/purpleair_data_logger/PurpleAirCSVDataLoggerConstants.py b/purpleair_data_logger/PurpleAirCSVDataLoggerConstants.py
index b45cb25..ea2e0fd 100644
--- a/purpleair_data_logger/PurpleAirCSVDataLoggerConstants.py
+++ b/purpleair_data_logger/PurpleAirCSVDataLoggerConstants.py
@@ -6,188 +6,193 @@
 """
 
 #: Standard file name for -
-STATION_INFORMATION_AND_STATUS_FIELDS_FILE_NAME = """station_information_and_status_fields.csv"""
+STATION_INFORMATION_AND_STATUS_FIELDS_FILE_NAME = (
+    """station_information_and_status_fields.csv"""
+)
 
 #: Standard CSV header for -
-STATION_INFORMATION_AND_STATUS_FIELDS_HEADER = \
-    "data_time_stamp,"\
-    "sensor_index,"\
-    "name,"\
-    "icon,"\
-    "model,"\
-    "hardware,"\
-    "location_type,"\
-    "private,"\
-    "latitude,"\
-    "longitude,"\
-    "altitude,"\
-    "position_rating,"\
-    "led_brightness,"\
-    "firmware_version,"\
-    "firmware_upgrade,"\
-    "rssi,"\
-    "uptime,"\
-    "pa_latency,"\
-    "memory,"\
-    "last_seen,"\
-    "last_modified,"\
-    "date_created,"\
-    "channel_state,"\
-    "channel_flags,"\
-    "channel_flags_manual,"\
-    "channel_flags_auto,"\
-    "confidence,"\
-    "confidence_manual,"\
+STATION_INFORMATION_AND_STATUS_FIELDS_HEADER = (
+    "data_time_stamp,"
+    "sensor_index,"
+    "name,"
+    "icon,"
+    "model,"
+    "hardware,"
+    "location_type,"
+    "private,"
+    "latitude,"
+    "longitude,"
+    "altitude,"
+    "position_rating,"
+    "led_brightness,"
+    "firmware_version,"
+    "firmware_upgrade,"
+    "rssi,"
+    "uptime,"
+    "pa_latency,"
+    "memory,"
+    "last_seen,"
+    "last_modified,"
+    "date_created,"
+    "channel_state,"
+    "channel_flags,"
+    "channel_flags_manual,"
+    "channel_flags_auto,"
+    "confidence,"
+    "confidence_manual,"
     "confidence_auto"
+)
 
 #: Standard file name for -
 ENVIRONMENTAL_FIELDS_FILE_NAME = """environmental_fields.csv"""
 
 #: Standard CSV header for -
-ENVIRONMENTAL_FIELDS_HEADER = \
-    "data_time_stamp,"\
-    "sensor_index,"\
-    "humidity,"\
-    "humidity_a,"\
-    "humidity_b,"\
-    "temperature,"\
-    "temperature_a,"\
-    "temperature_b,"\
-    "pressure,"\
-    "pressure_a,"\
+ENVIRONMENTAL_FIELDS_HEADER = (
+    "data_time_stamp,"
+    "sensor_index,"
+    "humidity,"
+    "humidity_a,"
+    "humidity_b,"
+    "temperature,"
+    "temperature_a,"
+    "temperature_b,"
+    "pressure,"
+    "pressure_a,"
     "pressure_b"
+)
 
 #: Standard file name for -
 MISCELLANEOUS_FIELDS_FILE_NAME = """miscellaneous_fields.csv"""
 
 #: Standard CSV header for -
-MISCELLANEOUS_FIELDS_HEADER = \
-    "data_time_stamp,"\
-    "sensor_index,"\
-    "voc,"\
-    "voc_a,"\
-    "voc_b,"\
-    "ozone1,"\
-    "analog_input"
+MISCELLANEOUS_FIELDS_HEADER = (
+    "data_time_stamp," "sensor_index," "voc," "voc_a," "voc_b," "ozone1," "analog_input"
+)
 
 #: Standard file name for -
 PM1_0_FIELDS_FILE_NAME = """pm1.0_fields.csv"""
 
 #: Standard CSV header for -
-PM1_0_FIELDS_HEADER = \
-    "data_time_stamp,"\
-    "sensor_index,"\
-    "pm1.0,"\
-    "pm1.0_a,"\
-    "pm1.0_b,"\
-    "pm1.0_atm,"\
-    "pm1.0_atm_a,"\
-    "pm1.0_atm_b,"\
-    "pm1.0_cf_1,"\
-    "pm1.0_cf_1_a,"\
+PM1_0_FIELDS_HEADER = (
+    "data_time_stamp,"
+    "sensor_index,"
+    "pm1.0,"
+    "pm1.0_a,"
+    "pm1.0_b,"
+    "pm1.0_atm,"
+    "pm1.0_atm_a,"
+    "pm1.0_atm_b,"
+    "pm1.0_cf_1,"
+    "pm1.0_cf_1_a,"
     "pm1.0_cf_1_b"
+)
 
 #: Standard file name for -
 PM2_5_FIELDS_FILE_NAME = """pm2.5_fields.csv"""
 
 #: Standard CSV header for -
-PM2_5_FIELDS_HEADER = \
-    "data_time_stamp,"\
-    "sensor_index,"\
-    "pm2.5_alt,"\
-    "pm2.5_alt_a,"\
-    "pm2.5_alt_b,"\
-    "pm2.5,"\
-    "pm2.5_a,"\
-    "pm2.5_b,"\
-    "pm2.5_atm,"\
-    "pm2.5_atm_a,"\
-    "pm2.5_atm_b,"\
-    "pm2.5_cf_1,"\
-    "pm2.5_cf_1_a,"\
+PM2_5_FIELDS_HEADER = (
+    "data_time_stamp,"
+    "sensor_index,"
+    "pm2.5_alt,"
+    "pm2.5_alt_a,"
+    "pm2.5_alt_b,"
+    "pm2.5,"
+    "pm2.5_a,"
+    "pm2.5_b,"
+    "pm2.5_atm,"
+    "pm2.5_atm_a,"
+    "pm2.5_atm_b,"
+    "pm2.5_cf_1,"
+    "pm2.5_cf_1_a,"
     "pm2.5_cf_1_b"
+)
 
 #: Standard file name for -
 PM2_5_PSEUDO_AVERAGE_FIELDS_FILE_NAME = """pm2.5_pseudo_average_fields.csv"""
 
 #: Standard CSV header for -
-PM2_5_PSEUDO_AVERAGE_FIELDS_HEADER = \
-    "data_time_stamp,"\
-    "sensor_index,"\
-    "pm2.5_10minute,"\
-    "pm2.5_10minute_a,"\
-    "pm2.5_10minute_b,"\
-    "pm2.5_30minute,"\
-    "pm2.5_30minute_a,"\
-    "pm2.5_30minute_b,"\
-    "pm2.5_60minute,"\
-    "pm2.5_60minute_a,"\
-    "pm2.5_60minute_b,"\
-    "pm2.5_6hour,"\
-    "pm2.5_6hour_a,"\
-    "pm2.5_6hour_b,"\
-    "pm2.5_24hour,"\
-    "pm2.5_24hour_a,"\
-    "pm2.5_24hour_b,"\
-    "pm2.5_1week,"\
-    "pm2.5_1week_a,"\
+PM2_5_PSEUDO_AVERAGE_FIELDS_HEADER = (
+    "data_time_stamp,"
+    "sensor_index,"
+    "pm2.5_10minute,"
+    "pm2.5_10minute_a,"
+    "pm2.5_10minute_b,"
+    "pm2.5_30minute,"
+    "pm2.5_30minute_a,"
+    "pm2.5_30minute_b,"
+    "pm2.5_60minute,"
+    "pm2.5_60minute_a,"
+    "pm2.5_60minute_b,"
+    "pm2.5_6hour,"
+    "pm2.5_6hour_a,"
+    "pm2.5_6hour_b,"
+    "pm2.5_24hour,"
+    "pm2.5_24hour_a,"
+    "pm2.5_24hour_b,"
+    "pm2.5_1week,"
+    "pm2.5_1week_a,"
     "pm2.5_1week_b"
+)
 
 #: Standard file name for -
 PM10_0_FIELDS_FILE_NAME = """pm10.0_fields.csv"""
 
 #: Standard CSV header for -
-PM10_0_FIELDS_HEADER = \
-    "data_time_stamp,"\
-    "sensor_index,"\
-    "pm10.0,"\
-    "pm10.0_a,"\
-    "pm10.0_b,"\
-    "pm10.0_atm,"\
-    "pm10.0_atm_a,"\
-    "pm10.0_atm_b,"\
-    "pm10.0_cf_1,"\
-    "pm10.0_cf_1_a,"\
+PM10_0_FIELDS_HEADER = (
+    "data_time_stamp,"
+    "sensor_index,"
+    "pm10.0,"
+    "pm10.0_a,"
+    "pm10.0_b,"
+    "pm10.0_atm,"
+    "pm10.0_atm_a,"
+    "pm10.0_atm_b,"
+    "pm10.0_cf_1,"
+    "pm10.0_cf_1_a,"
     "pm10.0_cf_1_b"
+)
 
 #: Standard file name for -
 PARTICLE_COUNT_FIELDS_FILE_NAME = """particle_count_fields.csv"""
 
 #: Standard CSV header for -
-PARTICLE_COUNT_FIELDS_HEADER = \
-    "data_time_stamp,"\
-    "sensor_index,"\
-    "0.3_um_count,"\
-    "0.3_um_count_a,"\
-    "0.3_um_count_b,"\
-    "0.5_um_count,"\
-    "0.5_um_count_a,"\
-    "0.5_um_count_b,"\
-    "1.0_um_count,"\
-    "1.0_um_count_a,"\
-    "1.0_um_count_b,"\
-    "2.5_um_count,"\
-    "2.5_um_count_a,"\
-    "2.5_um_count_b,"\
-    "5.0_um_count,"\
-    "5.0_um_count_a,"\
-    "5.0_um_count_b,"\
-    "10.0_um_count,"\
-    "10.0_um_count_a,"\
+PARTICLE_COUNT_FIELDS_HEADER = (
+    "data_time_stamp,"
+    "sensor_index,"
+    "0.3_um_count,"
+    "0.3_um_count_a,"
+    "0.3_um_count_b,"
+    "0.5_um_count,"
+    "0.5_um_count_a,"
+    "0.5_um_count_b,"
+    "1.0_um_count,"
+    "1.0_um_count_a,"
+    "1.0_um_count_b,"
+    "2.5_um_count,"
+    "2.5_um_count_a,"
+    "2.5_um_count_b,"
+    "5.0_um_count,"
+    "5.0_um_count_a,"
+    "5.0_um_count_b,"
+    "10.0_um_count,"
+    "10.0_um_count_a,"
     "10.0_um_count_b"
+)
 
 #: Standard file name for -
 THINGSPEAK_FIELDS_FILE_NAME = """thingspeak_fields.csv"""
 
 #: Standard CSV header for -
-THINGSPEAK_FIELDS_HEADER = \
-    "data_time_stamp,"\
-    "sensor_index,"\
-    "primary_id_a,"\
-    "primary_key_a,"\
-    "secondary_id_a,"\
-    "secondary_key_a,"\
-    "primary_id_b,"\
-    "primary_key_b,"\
-    "secondary_id_b,"\
+THINGSPEAK_FIELDS_HEADER = (
+    "data_time_stamp,"
+    "sensor_index,"
+    "primary_id_a,"
+    "primary_key_a,"
+    "secondary_id_a,"
+    "secondary_key_a,"
+    "primary_id_b,"
+    "primary_key_b,"
+    "secondary_id_b,"
     "secondary_key_b"
+)
diff --git a/purpleair_data_logger/PurpleAirDataLogger.py b/purpleair_data_logger/PurpleAirDataLogger.py
index e5e9a58..f088f0e 100644
--- a/purpleair_data_logger/PurpleAirDataLogger.py
+++ b/purpleair_data_logger/PurpleAirDataLogger.py
@@ -12,8 +12,8 @@
 
 
 class PurpleAirDataLoggerError(Exception):
-    """ 
-        Custom Exception for our PurpleAirDataLogger class.
+    """
+    Custom Exception for our PurpleAirDataLogger class.
     """
 
     def __init__(self, message_string):
@@ -21,22 +21,21 @@ def __init__(self, message_string):
         super().__init__(self.message)
 
 
-class PurpleAirDataLogger():
+class PurpleAirDataLogger:
     """
-        The Base Data Logger class. Will define common methods used by other data loggers. For
-        example, PSQLDataLogger and CSVDataLogger. Inheritors of this class will only need to define
-        their own 'store_sensor_data' method.
+    The Base Data Logger class. Will define common methods used by other data loggers. For
+    example, PSQLDataLogger and CSVDataLogger. Inheritors of this class will only need to define
+    their own 'store_sensor_data' method.
     """
 
     def __init__(self, PurpleAirAPIReadKey):
         """
-            :param str PurpleAirAPIReadKey: A valid PurpleAirAPI Read key
-            :param object psql_db_conn: A valid PG8000 database connection
+        :param str PurpleAirAPIReadKey: A valid PurpleAirAPI Read key
+        :param object psql_db_conn: A valid PG8000 database connection
         """
 
         # Make one instance of our PurpleAirAPI class
-        self._purple_air_api_obj = PurpleAirAPI(
-            your_api_read_key=PurpleAirAPIReadKey)
+        self._purple_air_api_obj = PurpleAirAPI(your_api_read_key=PurpleAirAPIReadKey)
 
         # Define how often we send requests
         self._send_request_every_x_seconds = 65
@@ -44,8 +43,8 @@ def __init__(self, PurpleAirAPIReadKey):
     @property
     def send_request_every_x_seconds(self):
         """
-            Return the current value of send_request_every_x_seconds.
-            This value is how often we send requests to the Purple Air API. (PAA)
+        Return the current value of send_request_every_x_seconds.
+        This value is how often we send requests to the Purple Air API. (PAA)
         """
 
         return self._send_request_every_x_seconds
@@ -53,9 +52,9 @@ def send_request_every_x_seconds(self):
     @send_request_every_x_seconds.setter
     def send_request_every_x_seconds(self, new_value):
         """
-            Set the current value of send_request_every_x_seconds.
-            This value is how often we send requests to the Purple Air API. (PAA)
-            Value shall be greater than or equal to 60. The value is in seconds.
+        Set the current value of send_request_every_x_seconds.
+        This value is how often we send requests to the Purple Air API. (PAA)
+        Value shall be greater than or equal to 60. The value is in seconds.
         """
 
         if new_value >= 60:
@@ -63,58 +62,67 @@ def send_request_every_x_seconds(self, new_value):
 
         else:
             raise PurpleAirDataLoggerError(
-                f"new_value ({new_value}) shall not be less than 60.")
+                f"new_value ({new_value}) shall not be less than 60."
+            )
 
     def store_sensor_data(self, single_sensor_data_dict):
         """
-            Insert the sensor data into the database.
+        Insert the sensor data into the database.
 
-            :param dict single_sensor_data_dict: A python dictionary containing all fields
-                                                 for insertion. If a sensor doesn't support
-                                                 a certain field make sure it is NULL and part
-                                                 of the dictionary. This method does no type
-                                                 or error checking. That is upto the caller.
+        :param dict single_sensor_data_dict: A python dictionary containing all fields
+                                             for insertion. If a sensor doesn't support
+                                             a certain field make sure it is NULL and part
+                                             of the dictionary. This method does no type
+                                             or error checking. That is upto the caller.
         """
 
         raise NotImplementedError(
-            "Must be implemented by class that is inheriting PurpleAirDataLogger!")
+            "Must be implemented by class that is inheriting PurpleAirDataLogger!"
+        )
 
     def _validate_sensor_data_before_insert(self, the_modified_sensor_data):
         """
-            Before we store the data, we must make sure all fields have been included
-            Our psql/sqlite store statements expect all fields regardless of what we request.
+        Before we store the data, we must make sure all fields have been included
+        Our psql/sqlite store statements expect all fields regardless of what we request.
 
-            :param dict the_modified_sensor_data: A single layer dictionary containing a single sensors data.
+        :param dict the_modified_sensor_data: A single layer dictionary containing a single sensors data.
 
-            return A dictionary with all the data fields filled out.
+        return A dictionary with all the data fields filled out.
         """
 
         # Make a copy first
         temp_the_modified_sensor_data = the_modified_sensor_data
         for field in ACCEPTED_FIELD_NAMES_DICT.keys():
             if field not in temp_the_modified_sensor_data.keys():
-                temp_the_modified_sensor_data[str(
-                    field)] = ACCEPTED_FIELD_NAMES_DICT[field]
+                temp_the_modified_sensor_data[str(field)] = ACCEPTED_FIELD_NAMES_DICT[
+                    field
+                ]
 
         # Then return the modified copy
         return temp_the_modified_sensor_data
 
     def _run_loop_for_storing_single_sensor_data(self, the_json_file):
         """
-            A method containing the run loop for inserting a single sensors' data into the db.
+        A method containing the run loop for inserting a single sensors' data into the db.
 
-            :param dict json_config_file: A dictionary object of the json config file using json load.
+        :param dict json_config_file: A dictionary object of the json config file using json load.
         """
 
         while True:
             print(
-                "_run_loop_for_storing_single_sensor_data - Beep boop I am alive...\n\n")
+                "_run_loop_for_storing_single_sensor_data - Beep boop I am alive...\n\n"
+            )
             # We will request data once every 65 seconds.
-            debug_log(f"""Requesting new data from a sensor with index
-                      {the_json_file['sensor_index']}...""")
+            debug_log(
+                f"""Requesting new data from a sensor with index
+                      {the_json_file['sensor_index']}..."""
+            )
 
             sensor_data = self._purple_air_api_obj.request_sensor_data(
-                the_json_file["sensor_index"], the_json_file["read_key"], the_json_file["fields"])
+                the_json_file["sensor_index"],
+                the_json_file["read_key"],
+                the_json_file["fields"],
+            )
 
             # Let's make it easier on ourselves by making the sensor data one level deep.
             # Instead of json["sensor"]["KEYS..."] and json["sensor"]["stats_a"]["KEYS..."] etc
@@ -137,50 +145,70 @@ def _run_loop_for_storing_single_sensor_data(self, the_json_file):
 
                 elif key in ["stats_a", "stats_b"]:
                     the_modified_sensor_data[f"pm2.5_{key[-1]}"] = val["pm2.5"]
-                    the_modified_sensor_data[f"pm2.5_10minute_{key[-1]}"] = val["pm2.5_10minute"]
-                    the_modified_sensor_data[f"pm2.5_30minute_{key[-1]}"] = val["pm2.5_30minute"]
-                    the_modified_sensor_data[f"pm2.5_60minute_{key[-1]}"] = val["pm2.5_60minute"]
-                    the_modified_sensor_data[f"pm2.5_6hour_{key[-1]}"] = val["pm2.5_6hour"]
-                    the_modified_sensor_data[f"pm2.5_24hour_{key[-1]}"] = val["pm2.5_24hour"]
-                    the_modified_sensor_data[f"pm2.5_1week_{key[-1]}"] = val["pm2.5_1week"]
-                    the_modified_sensor_data[f"time_stamp_{key[-1]}"] = val["time_stamp"]
+                    the_modified_sensor_data[f"pm2.5_10minute_{key[-1]}"] = val[
+                        "pm2.5_10minute"
+                    ]
+                    the_modified_sensor_data[f"pm2.5_30minute_{key[-1]}"] = val[
+                        "pm2.5_30minute"
+                    ]
+                    the_modified_sensor_data[f"pm2.5_60minute_{key[-1]}"] = val[
+                        "pm2.5_60minute"
+                    ]
+                    the_modified_sensor_data[f"pm2.5_6hour_{key[-1]}"] = val[
+                        "pm2.5_6hour"
+                    ]
+                    the_modified_sensor_data[f"pm2.5_24hour_{key[-1]}"] = val[
+                        "pm2.5_24hour"
+                    ]
+                    the_modified_sensor_data[f"pm2.5_1week_{key[-1]}"] = val[
+                        "pm2.5_1week"
+                    ]
+                    the_modified_sensor_data[f"time_stamp_{key[-1]}"] = val[
+                        "time_stamp"
+                    ]
 
                 else:
                     the_modified_sensor_data[key] = val
 
             the_modified_sensor_data = self._validate_sensor_data_before_insert(
-                the_modified_sensor_data)
+                the_modified_sensor_data
+            )
             self.store_sensor_data(the_modified_sensor_data)
-            debug_log(f"""Waiting {self._send_request_every_x_seconds} seconds before
-                  requesting new data again...""")
+            debug_log(
+                f"""Waiting {self._send_request_every_x_seconds} seconds before
+                  requesting new data again..."""
+            )
             sleep(self._send_request_every_x_seconds)
 
     def _run_loop_for_storing_multiple_sensors_data(self, json_config_file):
         """
-            A method containing the run loop for inserting a multiple sensors' data into the db.
+        A method containing the run loop for inserting a multiple sensors' data into the db.
 
-            :param dict json_config_file: A dictionary object of the json config file using json load.
+        :param dict json_config_file: A dictionary object of the json config file using json load.
         """
 
         while True:
             print(
-                "_run_loop_for_storing_multiple_sensors_data - Beep boop I am alive...\n\n")
+                "_run_loop_for_storing_multiple_sensors_data - Beep boop I am alive...\n\n"
+            )
             # We will request data once every 65 seconds.
-            debug_log(f"""Requesting new data from multiple sensors with fields
-                      {json_config_file["fields"]}...""")
-
-            sensors_data = self._purple_air_api_obj.request_multiple_sensors_data(fields=json_config_file["fields"],
-                                                                                  location_type=json_config_file[
-                                                                                      "location_type"],
-                                                                                  read_keys=json_config_file["read_keys"],
-                                                                                  show_only=json_config_file["show_only"],
-                                                                                  modified_since=json_config_file[
-                                                                                      "modified_since"],
-                                                                                  max_age=json_config_file["max_age"],
-                                                                                  nwlng=json_config_file["nwlng"],
-                                                                                  nwlat=json_config_file["nwlat"],
-                                                                                  selng=json_config_file["selng"],
-                                                                                  selat=json_config_file["selat"])
+            debug_log(
+                f"""Requesting new data from multiple sensors with fields
+                      {json_config_file["fields"]}..."""
+            )
+
+            sensors_data = self._purple_air_api_obj.request_multiple_sensors_data(
+                fields=json_config_file["fields"],
+                location_type=json_config_file["location_type"],
+                read_keys=json_config_file["read_keys"],
+                show_only=json_config_file["show_only"],
+                modified_since=json_config_file["modified_since"],
+                max_age=json_config_file["max_age"],
+                nwlng=json_config_file["nwlng"],
+                nwlat=json_config_file["nwlat"],
+                selng=json_config_file["selng"],
+                selat=json_config_file["selat"],
+            )
 
             # The sensors data will look something like this:
             # {'api_version': 'V1.0.11-0.0.34', 'time_stamp': 1659710288, 'data_time_stamp': 1659710232,
@@ -200,51 +228,70 @@ def _run_loop_for_storing_multiple_sensors_data(self, json_config_file):
                 # Start making our modified sensor data object that will be passed to the
                 # self.store_sensor_data() method
                 the_modified_sensor_data = {}
-                the_modified_sensor_data["data_time_stamp"] = sensors_data["data_time_stamp"]
+                the_modified_sensor_data["data_time_stamp"] = sensors_data[
+                    "data_time_stamp"
+                ]
                 for data_index, data_item in enumerate(data_list):
-                    the_modified_sensor_data[str(
-                        extracted_fields[data_index])] = data_item
+                    the_modified_sensor_data[
+                        str(extracted_fields[data_index])
+                    ] = data_item
 
                 the_modified_sensor_data = self._validate_sensor_data_before_insert(
-                    the_modified_sensor_data)
+                    the_modified_sensor_data
+                )
 
                 # Store the current data
                 self.store_sensor_data(the_modified_sensor_data)
 
-            debug_log(f"""Waiting {self._send_request_every_x_seconds} seconds before
-                  requesting new data again...""")
+            debug_log(
+                f"""Waiting {self._send_request_every_x_seconds} seconds before
+                  requesting new data again..."""
+            )
             sleep(self._send_request_every_x_seconds)
 
-    def validate_parameters_and_run(self, paa_multiple_sensor_request_json_file=None, paa_single_sensor_request_json_file=None):
+    def validate_parameters_and_run(
+        self,
+        paa_multiple_sensor_request_json_file=None,
+        paa_single_sensor_request_json_file=None,
+    ):
         """
-            A method to choose what run method to execute based on what config file is being used.
-            This shall be considered the main entry point for and PurpleAirDataLogger.
+        A method to choose what run method to execute based on what config file is being used.
+        This shall be considered the main entry point for and PurpleAirDataLogger.
 
-            :param str paa_multiple_sensor_request_json_file: The path to a json file containing
-                                                              the parameters to send a single sensor request.
-            :param str paa_single_sensor_request_json_file: The path to a json file containing
-                                                            the parameters to send a multiple sensor request.
+        :param str paa_multiple_sensor_request_json_file: The path to a json file containing
+                                                          the parameters to send a single sensor request.
+        :param str paa_single_sensor_request_json_file: The path to a json file containing
+                                                        the parameters to send a multiple sensor request.
         """
 
         # Third choose what run method to execute depending on paa_multiple_sensor_request_json_file/paa_single_sensor_request_json_file
-        if paa_multiple_sensor_request_json_file is not None and paa_single_sensor_request_json_file is None:
+        if (
+            paa_multiple_sensor_request_json_file is not None
+            and paa_single_sensor_request_json_file is None
+        ):
             # Now load up that json file
             file_obj = open(paa_multiple_sensor_request_json_file, "r")
             the_json_file = json.load(file_obj)
-            self._run_loop_for_storing_multiple_sensors_data(
-                the_json_file)
+            self._run_loop_for_storing_multiple_sensors_data(the_json_file)
 
-        elif paa_multiple_sensor_request_json_file is None and paa_single_sensor_request_json_file is not None:
+        elif (
+            paa_multiple_sensor_request_json_file is None
+            and paa_single_sensor_request_json_file is not None
+        ):
             # Now load up that json file
             file_obj = open(paa_single_sensor_request_json_file, "r")
             the_json_file = json.load(file_obj)
-            self._run_loop_for_storing_single_sensor_data(
-                the_json_file)
+            self._run_loop_for_storing_single_sensor_data(the_json_file)
 
-        elif paa_multiple_sensor_request_json_file is None and paa_single_sensor_request_json_file is None:
+        elif (
+            paa_multiple_sensor_request_json_file is None
+            and paa_single_sensor_request_json_file is None
+        ):
             raise PurpleAirDataLoggerError(
-                """Neither '-paa_multiple_sensor_request_json_file' or '-paa_single_sensor_request_json_file' were provided. Please provide at least one!""")
+                """Neither '-paa_multiple_sensor_request_json_file' or '-paa_single_sensor_request_json_file' were provided. Please provide at least one!"""
+            )
 
         else:
             raise PurpleAirDataLoggerError(
-                """One parameter '-paa_multiple_sensor_request_json_file' or '-paa_single_sensor_request_json_file' must be provided. Not both!""")
+                """One parameter '-paa_multiple_sensor_request_json_file' or '-paa_single_sensor_request_json_file' must be provided. Not both!"""
+            )
diff --git a/purpleair_data_logger/PurpleAirPSQLDataLogger.py b/purpleair_data_logger/PurpleAirPSQLDataLogger.py
index 5040e38..ff59f35 100644
--- a/purpleair_data_logger/PurpleAirPSQLDataLogger.py
+++ b/purpleair_data_logger/PurpleAirPSQLDataLogger.py
@@ -14,15 +14,28 @@
 """
 
 from purpleair_data_logger.PurpleAirDataLogger import PurpleAirDataLogger
-from purpleair_data_logger.PurpleAirPSQLQueryStatements import (PSQL_INSERT_STATEMENT_ENVIRONMENTAL_FIELDS, PSQL_INSERT_STATEMENT_MISCELLANEOUS_FIELDS,
-                                                                PSQL_INSERT_STATEMENT_PARTICLE_COUNT_FIELDS, PSQL_INSERT_STATEMENT_PM10_0_FIELDS,
-                                                                PSQL_INSERT_STATEMENT_PM1_0_FIELDS, PSQL_INSERT_STATEMENT_PM2_5_FIELDS,
-                                                                PSQL_INSERT_STATEMENT_PM2_5_PSEUDO_AVERAGE_FIELDS, PSQL_INSERT_STATEMENT_STATION_INFORMATION_AND_STATUS_FIELDS,
-                                                                PSQL_INSERT_STATEMENT_THINGSPEAK_FIELDS, CREATE_PARTICLE_COUNT_FIELDS,
-                                                                CREATE_PM10_0_FIELDS, CREATE_PM1_0_FIELDS, CREATE_PM2_5_FIELDS, CREATE_PM2_5_PSEUDO_AVERAGE_FIELDS,
-                                                                CREATE_ENVIRONMENTAL_FIELDS_TABLE, CREATE_MISCELLANEOUS_FIELDS, CREATE_STATION_INFORMATION_AND_STATUS_FIELDS_TABLE,
-                                                                CREATE_THINGSPEAK_FIELDS, PSQL_DROP_ALL_TABLES,
-                                                                PSQL_GET_LIST_OF_ACTIVE_COMPRESSION_POLICIES)
+from purpleair_data_logger.PurpleAirPSQLQueryStatements import (
+    PSQL_INSERT_STATEMENT_ENVIRONMENTAL_FIELDS,
+    PSQL_INSERT_STATEMENT_MISCELLANEOUS_FIELDS,
+    PSQL_INSERT_STATEMENT_PARTICLE_COUNT_FIELDS,
+    PSQL_INSERT_STATEMENT_PM10_0_FIELDS,
+    PSQL_INSERT_STATEMENT_PM1_0_FIELDS,
+    PSQL_INSERT_STATEMENT_PM2_5_FIELDS,
+    PSQL_INSERT_STATEMENT_PM2_5_PSEUDO_AVERAGE_FIELDS,
+    PSQL_INSERT_STATEMENT_STATION_INFORMATION_AND_STATUS_FIELDS,
+    PSQL_INSERT_STATEMENT_THINGSPEAK_FIELDS,
+    CREATE_PARTICLE_COUNT_FIELDS,
+    CREATE_PM10_0_FIELDS,
+    CREATE_PM1_0_FIELDS,
+    CREATE_PM2_5_FIELDS,
+    CREATE_PM2_5_PSEUDO_AVERAGE_FIELDS,
+    CREATE_ENVIRONMENTAL_FIELDS_TABLE,
+    CREATE_MISCELLANEOUS_FIELDS,
+    CREATE_STATION_INFORMATION_AND_STATUS_FIELDS_TABLE,
+    CREATE_THINGSPEAK_FIELDS,
+    PSQL_DROP_ALL_TABLES,
+    PSQL_GET_LIST_OF_ACTIVE_COMPRESSION_POLICIES,
+)
 import pg8000
 import argparse
 from datetime import datetime, timezone
@@ -31,14 +44,14 @@
 
 class PurpleAirPSQLDataLogger(PurpleAirDataLogger):
     """
-        The logger class. For now we will ingest data into a TimeScaleDB PostgreSQL
-        database. Then we will use Grafana to visualize said data.
+    The logger class. For now we will ingest data into a TimeScaleDB PostgreSQL
+    database. Then we will use Grafana to visualize said data.
     """
 
     def __init__(self, PurpleAirAPIReadKey, psql_db_conn):
         """
-            :param str PurpleAirAPIReadKey: A valid PurpleAirAPI Read key
-            :param object psql_db_conn: A valid PG8000 database connection
+        :param str PurpleAirAPIReadKey: A valid PurpleAirAPI Read key
+        :param object psql_db_conn: A valid PG8000 database connection
         """
 
         # Inherit everything from the parent base class: PurpleAirDataLogger
@@ -57,7 +70,7 @@ def __init__(self, PurpleAirAPIReadKey, psql_db_conn):
             "pm2_5_pseudo_average_fields",
             "pm10_0_fields",
             "particle_count_fields",
-            "thingspeak_fields"
+            "thingspeak_fields",
         ]
 
         # Make our PSQL Tables
@@ -75,21 +88,21 @@ def __init__(self, PurpleAirAPIReadKey, psql_db_conn):
     @property
     def get_acceptable_table_names_string_list(self):
         """
-            A getter method that will simply return the contents of
-            the acceptable_table_names_string_list. This is a list
-            of all the tables that this DataLogger uses and knows about.
+        A getter method that will simply return the contents of
+        the acceptable_table_names_string_list. This is a list
+        of all the tables that this DataLogger uses and knows about.
         """
 
         return self._acceptable_table_names_string_list
 
     def _create_psql_db_tables(self):
         """
-            Create the PSQL database tables if they don't exist already
+        Create the PSQL database tables if they don't exist already
 
-            We will create one table for different data groups. Simply following the
-            official PurpleAir documentation. Think Station information and status fields,
-            Environmental fields, etc. See website for more information.
-            https://api.purpleair.com/#api-sensors-get-sensor-data
+        We will create one table for different data groups. Simply following the
+        official PurpleAir documentation. Think Station information and status fields,
+        Environmental fields, etc. See website for more information.
+        https://api.purpleair.com/#api-sensors-get-sensor-data
         """
 
         self._db_conn.run(CREATE_STATION_INFORMATION_AND_STATUS_FIELDS_TABLE)
@@ -104,22 +117,22 @@ def _create_psql_db_tables(self):
 
     def _convert_psql_tables_to_hyper_tables(self):
         """
-            A method to convert our PSQL tables to TimeScaleDB hyper tables.
+        A method to convert our PSQL tables to TimeScaleDB hyper tables.
         """
 
         for table_name in self._acceptable_table_names_string_list:
             self._db_conn.run(
-                f"""SELECT create_hypertable('{table_name}', 'data_time_stamp', if_not_exists => TRUE)""")
+                f"""SELECT create_hypertable('{table_name}', 'data_time_stamp', if_not_exists => TRUE)"""
+            )
 
     def _configure_data_compression_policies(self):
         """
-            A method to set TimescaleDB data compression policies. More information
-            can be found here: https://docs.timescale.com/api/latest/compression/add_compression_policy/#add-compression-policy
+        A method to set TimescaleDB data compression policies. More information
+        can be found here: https://docs.timescale.com/api/latest/compression/add_compression_policy/#add-compression-policy
         """
 
         # Before we do anything let's get a list of all the current active compression policies
-        query_result = self._db_conn.run(
-            PSQL_GET_LIST_OF_ACTIVE_COMPRESSION_POLICIES)
+        query_result = self._db_conn.run(PSQL_GET_LIST_OF_ACTIVE_COMPRESSION_POLICIES)
 
         # Convert our tuple query_result into a list
         compression_policy_list = []
@@ -130,18 +143,20 @@ def _configure_data_compression_policies(self):
             if table_name not in compression_policy_list:
                 self._db_conn.run(
                     f"""ALTER TABLE {table_name} SET (timescaledb.compress, timescaledb.compress_orderby = 'data_time_stamp',
-                        timescaledb.compress_segmentby = 'sensor_index')""")
+                        timescaledb.compress_segmentby = 'sensor_index')"""
+                )
 
                 self._db_conn.run(
-                    f"""SELECT add_compression_policy('{table_name}', INTERVAL '14d', if_not_exists => TRUE)""")
+                    f"""SELECT add_compression_policy('{table_name}', INTERVAL '14d', if_not_exists => TRUE)"""
+                )
 
     def _convert_unix_epoch_timestamp_to_psql_timestamp(self, unix_epoch_timestamp):
         """
-            A method to covert a unix epoch timestamp to a psql timestamp.
+        A method to covert a unix epoch timestamp to a psql timestamp.
 
-            :param int unix_epoch_timestamp: A valid unix epoch timestamp
+        :param int unix_epoch_timestamp: A valid unix epoch timestamp
 
-            :return A valid psql UTC timestamp or None.
+        :return A valid psql UTC timestamp or None.
         """
 
         if unix_epoch_timestamp is None:
@@ -152,20 +167,21 @@ def _convert_unix_epoch_timestamp_to_psql_timestamp(self, unix_epoch_timestamp):
 
     def store_sensor_data(self, single_sensor_data_dict):
         """
-            Insert the sensor data into the database.
+        Insert the sensor data into the database.
 
-            :param dict single_sensor_data_dict: A python dictionary containing all fields
-                                                 for insertion. If a sensor doesn't support
-                                                 a certain field make sure it is NULL and part
-                                                 of the dictionary. This method does no type
-                                                 or error checking. That is upto the caller.
+        :param dict single_sensor_data_dict: A python dictionary containing all fields
+                                             for insertion. If a sensor doesn't support
+                                             a certain field make sure it is NULL and part
+                                             of the dictionary. This method does no type
+                                             or error checking. That is upto the caller.
         """
 
         # Run the queries
         self._db_conn.run(
             PSQL_INSERT_STATEMENT_STATION_INFORMATION_AND_STATUS_FIELDS,
             data_time_stamp=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["data_time_stamp"]),
+                single_sensor_data_dict["data_time_stamp"]
+            ),
             sensor_index=single_sensor_data_dict["sensor_index"],
             name=single_sensor_data_dict["name"],
             icon=single_sensor_data_dict["icon"],
@@ -185,24 +201,28 @@ def store_sensor_data(self, single_sensor_data_dict):
             pa_latency=single_sensor_data_dict["pa_latency"],
             memory=single_sensor_data_dict["memory"],
             last_seen=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["last_seen"]),
+                single_sensor_data_dict["last_seen"]
+            ),
             last_modified=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["last_modified"]),
+                single_sensor_data_dict["last_modified"]
+            ),
             date_created=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["date_created"]),
+                single_sensor_data_dict["date_created"]
+            ),
             channel_state=single_sensor_data_dict["channel_state"],
             channel_flags=single_sensor_data_dict["channel_flags"],
             channel_flags_manual=single_sensor_data_dict["channel_flags_manual"],
             channel_flags_auto=single_sensor_data_dict["channel_flags_auto"],
             confidence=single_sensor_data_dict["confidence"],
             confidence_manual=single_sensor_data_dict["confidence_manual"],
-            confidence_auto=single_sensor_data_dict["confidence_auto"]
+            confidence_auto=single_sensor_data_dict["confidence_auto"],
         )
 
         self._db_conn.run(
             PSQL_INSERT_STATEMENT_ENVIRONMENTAL_FIELDS,
             data_time_stamp=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["data_time_stamp"]),
+                single_sensor_data_dict["data_time_stamp"]
+            ),
             sensor_index=single_sensor_data_dict["sensor_index"],
             humidity=single_sensor_data_dict["humidity"],
             humidity_a=single_sensor_data_dict["humidity_a"],
@@ -212,25 +232,27 @@ def store_sensor_data(self, single_sensor_data_dict):
             temperature_b=single_sensor_data_dict["temperature_b"],
             pressure=single_sensor_data_dict["pressure"],
             pressure_a=single_sensor_data_dict["pressure_a"],
-            pressure_b=single_sensor_data_dict["pressure_b"]
+            pressure_b=single_sensor_data_dict["pressure_b"],
         )
 
         self._db_conn.run(
             PSQL_INSERT_STATEMENT_MISCELLANEOUS_FIELDS,
             data_time_stamp=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["data_time_stamp"]),
+                single_sensor_data_dict["data_time_stamp"]
+            ),
             sensor_index=single_sensor_data_dict["sensor_index"],
             voc=single_sensor_data_dict["voc"],
             voc_a=single_sensor_data_dict["voc_a"],
             voc_b=single_sensor_data_dict["voc_b"],
             ozone1=single_sensor_data_dict["ozone1"],
-            analog_input=single_sensor_data_dict["analog_input"]
+            analog_input=single_sensor_data_dict["analog_input"],
         )
 
         self._db_conn.run(
             PSQL_INSERT_STATEMENT_PM1_0_FIELDS,
             data_time_stamp=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["data_time_stamp"]),
+                single_sensor_data_dict["data_time_stamp"]
+            ),
             sensor_index=single_sensor_data_dict["sensor_index"],
             pm1_0=single_sensor_data_dict["pm1.0"],
             pm1_0_a=single_sensor_data_dict["pm1.0_a"],
@@ -240,13 +262,14 @@ def store_sensor_data(self, single_sensor_data_dict):
             pm1_0_atm_b=single_sensor_data_dict["pm1.0_atm_b"],
             pm1_0_cf_1=single_sensor_data_dict["pm1.0_cf_1"],
             pm1_0_cf_1_a=single_sensor_data_dict["pm1.0_cf_1_a"],
-            pm1_0_cf_1_b=single_sensor_data_dict["pm1.0_cf_1_b"]
+            pm1_0_cf_1_b=single_sensor_data_dict["pm1.0_cf_1_b"],
         )
 
         self._db_conn.run(
             PSQL_INSERT_STATEMENT_PM2_5_FIELDS,
             data_time_stamp=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["data_time_stamp"]),
+                single_sensor_data_dict["data_time_stamp"]
+            ),
             sensor_index=single_sensor_data_dict["sensor_index"],
             pm2_5_alt=single_sensor_data_dict["pm2.5_alt"],
             pm2_5_alt_a=single_sensor_data_dict["pm2.5_alt_a"],
@@ -259,13 +282,14 @@ def store_sensor_data(self, single_sensor_data_dict):
             pm2_5_atm_b=single_sensor_data_dict["pm2.5_atm_b"],
             pm2_5_cf_1=single_sensor_data_dict["pm2.5_cf_1"],
             pm2_5_cf_1_a=single_sensor_data_dict["pm2.5_cf_1_a"],
-            pm2_5_cf_1_b=single_sensor_data_dict["pm2.5_cf_1_b"]
+            pm2_5_cf_1_b=single_sensor_data_dict["pm2.5_cf_1_b"],
         )
 
         self._db_conn.run(
             PSQL_INSERT_STATEMENT_PM2_5_PSEUDO_AVERAGE_FIELDS,
             data_time_stamp=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["data_time_stamp"]),
+                single_sensor_data_dict["data_time_stamp"]
+            ),
             sensor_index=single_sensor_data_dict["sensor_index"],
             pm2_5_10minute=single_sensor_data_dict["pm2.5_10minute"],
             pm2_5_10minute_a=single_sensor_data_dict["pm2.5_10minute_a"],
@@ -284,13 +308,14 @@ def store_sensor_data(self, single_sensor_data_dict):
             pm2_5_24hour_b=single_sensor_data_dict["pm2.5_24hour_b"],
             pm2_5_1week=single_sensor_data_dict["pm2.5_1week"],
             pm2_5_1week_a=single_sensor_data_dict["pm2.5_1week_a"],
-            pm2_5_1week_b=single_sensor_data_dict["pm2.5_1week_b"]
+            pm2_5_1week_b=single_sensor_data_dict["pm2.5_1week_b"],
         )
 
         self._db_conn.run(
             PSQL_INSERT_STATEMENT_PM10_0_FIELDS,
             data_time_stamp=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["data_time_stamp"]),
+                single_sensor_data_dict["data_time_stamp"]
+            ),
             sensor_index=single_sensor_data_dict["sensor_index"],
             pm10_0=single_sensor_data_dict["pm10.0"],
             pm10_0_a=single_sensor_data_dict["pm10.0_a"],
@@ -300,13 +325,14 @@ def store_sensor_data(self, single_sensor_data_dict):
             pm10_0_atm_b=single_sensor_data_dict["pm10.0_atm_b"],
             pm10_0_cf_1=single_sensor_data_dict["pm10.0_cf_1"],
             pm10_0_cf_1_a=single_sensor_data_dict["pm10.0_cf_1_a"],
-            pm10_0_cf_1_b=single_sensor_data_dict["pm10.0_cf_1_b"]
+            pm10_0_cf_1_b=single_sensor_data_dict["pm10.0_cf_1_b"],
         )
 
         self._db_conn.run(
             PSQL_INSERT_STATEMENT_PARTICLE_COUNT_FIELDS,
             data_time_stamp=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["data_time_stamp"]),
+                single_sensor_data_dict["data_time_stamp"]
+            ),
             sensor_index=single_sensor_data_dict["sensor_index"],
             um_count_0_3=single_sensor_data_dict["0.3_um_count"],
             um_count_a_0_3=single_sensor_data_dict["0.3_um_count_a"],
@@ -325,13 +351,14 @@ def store_sensor_data(self, single_sensor_data_dict):
             um_count_b_5_0=single_sensor_data_dict["5.0_um_count_b"],
             um_count_10_0=single_sensor_data_dict["10.0_um_count"],
             um_count_a_10_0=single_sensor_data_dict["10.0_um_count_a"],
-            um_count_b_10_0=single_sensor_data_dict["10.0_um_count_b"]
+            um_count_b_10_0=single_sensor_data_dict["10.0_um_count_b"],
         )
 
         self._db_conn.run(
             PSQL_INSERT_STATEMENT_THINGSPEAK_FIELDS,
             data_time_stamp=self._convert_unix_epoch_timestamp_to_psql_timestamp(
-                single_sensor_data_dict["data_time_stamp"]),
+                single_sensor_data_dict["data_time_stamp"]
+            ),
             sensor_index=single_sensor_data_dict["sensor_index"],
             primary_id_a=single_sensor_data_dict["primary_id_a"],
             primary_key_a=single_sensor_data_dict["primary_key_a"],
@@ -340,7 +367,7 @@ def store_sensor_data(self, single_sensor_data_dict):
             primary_id_b=single_sensor_data_dict["primary_id_b"],
             primary_key_b=single_sensor_data_dict["primary_key_b"],
             secondary_id_b=single_sensor_data_dict["secondary_id_b"],
-            secondary_key_b=single_sensor_data_dict["secondary_key_b"]
+            secondary_key_b=single_sensor_data_dict["secondary_key_b"],
         )
 
         # Commit to the db
@@ -349,32 +376,79 @@ def store_sensor_data(self, single_sensor_data_dict):
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
-        description="Collect data from PurpleAir sensors and insert into a database!")
-    parser.add_argument("-db_drop_all_tables",  action="store_true", required=False,
-                        dest="db_drop_all_tables", help="""Set this flag if you wish to drop all
+        description="Collect data from PurpleAir sensors and insert into a database!"
+    )
+    parser.add_argument(
+        "-db_drop_all_tables",
+        action="store_true",
+        required=False,
+        dest="db_drop_all_tables",
+        help="""Set this flag if you wish to drop all
                         tables before loading in new data. Useful if a database change has happened.
                         Note: Make sure to provide a db_usr with DROP rights.
-                        WARNING: ALL COLLECTED DATA WILL BE LOST!""")
-    parser.add_argument("-db_usr",  required=True, dest="db_usr",
-                        type=str, help="""The PSQL database user""")
-    parser.add_argument("-db_host", required=False, default="localhost",
-                        dest="db_host", type=str, help="""The PSQL database host""")
-    parser.add_argument("-db", required=True, dest="db",
-                        type=str, help="""The PSQL database name""")
-    parser.add_argument("-db_port", required=False, default=5432,
-                        dest="db_port", type=str, help="""The PSQL database port number""")
-    parser.add_argument("-db_pwd",  required=False, default=None,
-                        dest="db_pwd", type=str, help="""The PSQL database password""")
-    parser.add_argument("-paa_read_key",  required=True,
-                        dest="paa_read_key", type=str, help="""The PurpleAirAPI Read key""")
-    parser.add_argument("-paa_single_sensor_request_json_file",  required=False, default=None,
-                        dest="paa_single_sensor_request_json_file", type=str, help="""The
+                        WARNING: ALL COLLECTED DATA WILL BE LOST!""",
+    )
+    parser.add_argument(
+        "-db_usr",
+        required=True,
+        dest="db_usr",
+        type=str,
+        help="""The PSQL database user""",
+    )
+    parser.add_argument(
+        "-db_host",
+        required=False,
+        default="localhost",
+        dest="db_host",
+        type=str,
+        help="""The PSQL database host""",
+    )
+    parser.add_argument(
+        "-db", required=True, dest="db", type=str, help="""The PSQL database name"""
+    )
+    parser.add_argument(
+        "-db_port",
+        required=False,
+        default=5432,
+        dest="db_port",
+        type=str,
+        help="""The PSQL database port number""",
+    )
+    parser.add_argument(
+        "-db_pwd",
+        required=False,
+        default=None,
+        dest="db_pwd",
+        type=str,
+        help="""The PSQL database password""",
+    )
+    parser.add_argument(
+        "-paa_read_key",
+        required=True,
+        dest="paa_read_key",
+        type=str,
+        help="""The PurpleAirAPI Read key""",
+    )
+    parser.add_argument(
+        "-paa_single_sensor_request_json_file",
+        required=False,
+        default=None,
+        dest="paa_single_sensor_request_json_file",
+        type=str,
+        help="""The
                         path to a json file containing the parameters to send a single
-                        sensor request.""")
-    parser.add_argument("-paa_multiple_sensor_request_json_file",  required=False, default=None,
-                        dest="paa_multiple_sensor_request_json_file", type=str, help="""The
+                        sensor request.""",
+    )
+    parser.add_argument(
+        "-paa_multiple_sensor_request_json_file",
+        required=False,
+        default=None,
+        dest="paa_multiple_sensor_request_json_file",
+        type=str,
+        help="""The
                         path to a json file containing the parameters to send a multiple
-                        sensor request.""")
+                        sensor request.""",
+    )
 
     args = parser.parse_args()
 
@@ -388,12 +462,15 @@ def store_sensor_data(self, single_sensor_data_dict):
         host=args.db_host,
         database=args.db,
         port=args.db_port,
-        password=args.db_pwd)
+        password=args.db_pwd,
+    )
 
     # Before doing step three, check if we wish to drop all tables.
     if args.db_drop_all_tables:
-        print("""Are you sure you wish to continue? This operation will drop all tables from the database!
-        ALL COLLECTED DATA WILL BE LOST!""")
+        print(
+            """Are you sure you wish to continue? This operation will drop all tables from the database!
+        ALL COLLECTED DATA WILL BE LOST!"""
+        )
         user_input = input("""Type yes or no to continue: """)
         if "no" in str(user_input):
             sys.exit("""Stopping because you didn't want to continue...""")
@@ -402,12 +479,16 @@ def store_sensor_data(self, single_sensor_data_dict):
             the_psql_db_conn.run(PSQL_DROP_ALL_TABLES)
             the_psql_db_conn.commit()
             sys.exit(
-                """All database tables have been dropped. Please rerun with a db_usr who only has insert rights provided...""")
+                """All database tables have been dropped. Please rerun with a db_usr who only has insert rights provided..."""
+            )
 
     # Third make an instance our our data logger
     the_paa_psql_data_logger = PurpleAirPSQLDataLogger(
-        args.paa_read_key, the_psql_db_conn)
+        args.paa_read_key, the_psql_db_conn
+    )
 
     # Fourth choose what run method to execute depending on paa_multiple_sensor_request_json_file/paa_single_sensor_request_json_file
     the_paa_psql_data_logger.validate_parameters_and_run(
-        args.paa_multiple_sensor_request_json_file, args.paa_single_sensor_request_json_file)
+        args.paa_multiple_sensor_request_json_file,
+        args.paa_single_sensor_request_json_file,
+    )
diff --git a/purpleair_data_logger/PurpleAirSQLiteDataLogger.py b/purpleair_data_logger/PurpleAirSQLiteDataLogger.py
index f6b2c40..32aaca3 100644
--- a/purpleair_data_logger/PurpleAirSQLiteDataLogger.py
+++ b/purpleair_data_logger/PurpleAirSQLiteDataLogger.py
@@ -14,26 +14,39 @@
 """
 
 from purpleair_data_logger.PurpleAirDataLogger import PurpleAirDataLogger
-from purpleair_data_logger.PurpleAirSQLiteQueryStatements import (SQLITE_INSERT_STATEMENT_ENVIRONMENTAL_FIELDS, SQLITE_INSERT_STATEMENT_MISCELLANEOUS_FIELDS,
-                                                                  SQLITE_INSERT_STATEMENT_PARTICLE_COUNT_FIELDS, SQLITE_INSERT_STATEMENT_PM10_0_FIELDS,
-                                                                  SQLITE_INSERT_STATEMENT_PM1_0_FIELDS, SQLITE_INSERT_STATEMENT_PM2_5_FIELDS,
-                                                                  SQLITE_INSERT_STATEMENT_PM2_5_PSEUDO_AVERAGE_FIELDS, SQLITE_INSERT_STATEMENT_STATION_INFORMATION_AND_STATUS_FIELDS,
-                                                                  SQLITE_INSERT_STATEMENT_THINGSPEAK_FIELDS, CREATE_PARTICLE_COUNT_FIELDS,
-                                                                  CREATE_PM10_0_FIELDS, CREATE_PM1_0_FIELDS, CREATE_PM2_5_FIELDS, CREATE_PM2_5_PSEUDO_AVERAGE_FIELDS,
-                                                                  CREATE_ENVIRONMENTAL_FIELDS_TABLE, CREATE_MISCELLANEOUS_FIELDS, CREATE_STATION_INFORMATION_AND_STATUS_FIELDS_TABLE,
-                                                                  CREATE_THINGSPEAK_FIELDS, SQLITE_DROP_ALL_TABLES)
+from purpleair_data_logger.PurpleAirSQLiteQueryStatements import (
+    SQLITE_INSERT_STATEMENT_ENVIRONMENTAL_FIELDS,
+    SQLITE_INSERT_STATEMENT_MISCELLANEOUS_FIELDS,
+    SQLITE_INSERT_STATEMENT_PARTICLE_COUNT_FIELDS,
+    SQLITE_INSERT_STATEMENT_PM10_0_FIELDS,
+    SQLITE_INSERT_STATEMENT_PM1_0_FIELDS,
+    SQLITE_INSERT_STATEMENT_PM2_5_FIELDS,
+    SQLITE_INSERT_STATEMENT_PM2_5_PSEUDO_AVERAGE_FIELDS,
+    SQLITE_INSERT_STATEMENT_STATION_INFORMATION_AND_STATUS_FIELDS,
+    SQLITE_INSERT_STATEMENT_THINGSPEAK_FIELDS,
+    CREATE_PARTICLE_COUNT_FIELDS,
+    CREATE_PM10_0_FIELDS,
+    CREATE_PM1_0_FIELDS,
+    CREATE_PM2_5_FIELDS,
+    CREATE_PM2_5_PSEUDO_AVERAGE_FIELDS,
+    CREATE_ENVIRONMENTAL_FIELDS_TABLE,
+    CREATE_MISCELLANEOUS_FIELDS,
+    CREATE_STATION_INFORMATION_AND_STATUS_FIELDS_TABLE,
+    CREATE_THINGSPEAK_FIELDS,
+    SQLITE_DROP_ALL_TABLES,
+)
 import argparse
 import sqlite3
 
 
 class PurpleAirSQLiteDataLogger(PurpleAirDataLogger):
     """
-        The logger class. For now we will insert data into a SQLite3 database file.
+    The logger class. For now we will insert data into a SQLite3 database file.
     """
 
     def __init__(self, PurpleAirAPIReadKey, sqlite_data_base_name):
         """
-            :param str PurpleAirAPIReadKey: A valid PurpleAirAPI Read key
+        :param str PurpleAirAPIReadKey: A valid PurpleAirAPI Read key
         """
 
         # Inherit everything from the parent base class: PurpleAirDataLogger
@@ -46,16 +59,15 @@ def __init__(self, PurpleAirAPIReadKey, sqlite_data_base_name):
 
     def _create_sqlite_db_tables(self):
         """
-            Create the SQLITE database tables if they don't exist already
+        Create the SQLITE database tables if they don't exist already
 
-            We will create one table for different data groups. Simply following the
-            official PurpleAir documentation. Think Station information and status fields,
-            Environmental fields, etc. See website for more information.
-            https://api.purpleair.com/#api-sensors-get-sensor-data
+        We will create one table for different data groups. Simply following the
+        official PurpleAir documentation. Think Station information and status fields,
+        Environmental fields, etc. See website for more information.
+        https://api.purpleair.com/#api-sensors-get-sensor-data
         """
 
-        self._db_conn.execute(
-            CREATE_STATION_INFORMATION_AND_STATUS_FIELDS_TABLE)
+        self._db_conn.execute(CREATE_STATION_INFORMATION_AND_STATUS_FIELDS_TABLE)
         self._db_conn.execute(CREATE_ENVIRONMENTAL_FIELDS_TABLE)
         self._db_conn.execute(CREATE_MISCELLANEOUS_FIELDS)
         self._db_conn.execute(CREATE_PM1_0_FIELDS)
@@ -67,183 +79,201 @@ def _create_sqlite_db_tables(self):
 
     def store_sensor_data(self, single_sensor_data_dict):
         """
-            Insert the sensor data into the database.
+        Insert the sensor data into the database.
 
-            :param dict single_sensor_data_dict: A python dictionary containing all fields
-                                                 for insertion. If a sensor doesn't support
-                                                 a certain field make sure it is NULL and part
-                                                 of the dictionary. This method does no type
-                                                 or error checking. That is upto the caller.
+        :param dict single_sensor_data_dict: A python dictionary containing all fields
+                                             for insertion. If a sensor doesn't support
+                                             a certain field make sure it is NULL and part
+                                             of the dictionary. This method does no type
+                                             or error checking. That is upto the caller.
         """
 
         # Run the queries
         self._db_conn.execute(
             SQLITE_INSERT_STATEMENT_STATION_INFORMATION_AND_STATUS_FIELDS,
-            (single_sensor_data_dict["data_time_stamp"],
-             single_sensor_data_dict["sensor_index"],
-             single_sensor_data_dict["name"],
-             single_sensor_data_dict["icon"],
-             single_sensor_data_dict["model"],
-             single_sensor_data_dict["hardware"],
-             single_sensor_data_dict["location_type"],
-             single_sensor_data_dict["private"],
-             single_sensor_data_dict["latitude"],
-             single_sensor_data_dict["longitude"],
-             single_sensor_data_dict["altitude"],
-             single_sensor_data_dict["position_rating"],
-             single_sensor_data_dict["led_brightness"],
-             single_sensor_data_dict["firmware_version"],
-             single_sensor_data_dict["firmware_upgrade"],
-             single_sensor_data_dict["rssi"],
-             single_sensor_data_dict["uptime"],
-             single_sensor_data_dict["pa_latency"],
-             single_sensor_data_dict["memory"],
-             single_sensor_data_dict["last_seen"],
-             single_sensor_data_dict["last_modified"],
-             single_sensor_data_dict["date_created"],
-             single_sensor_data_dict["channel_state"],
-             single_sensor_data_dict["channel_flags"],
-             single_sensor_data_dict["channel_flags_manual"],
-             single_sensor_data_dict["channel_flags_auto"],
-             single_sensor_data_dict["confidence"],
-             single_sensor_data_dict["confidence_manual"],
-             single_sensor_data_dict["confidence_auto"])
+            (
+                single_sensor_data_dict["data_time_stamp"],
+                single_sensor_data_dict["sensor_index"],
+                single_sensor_data_dict["name"],
+                single_sensor_data_dict["icon"],
+                single_sensor_data_dict["model"],
+                single_sensor_data_dict["hardware"],
+                single_sensor_data_dict["location_type"],
+                single_sensor_data_dict["private"],
+                single_sensor_data_dict["latitude"],
+                single_sensor_data_dict["longitude"],
+                single_sensor_data_dict["altitude"],
+                single_sensor_data_dict["position_rating"],
+                single_sensor_data_dict["led_brightness"],
+                single_sensor_data_dict["firmware_version"],
+                single_sensor_data_dict["firmware_upgrade"],
+                single_sensor_data_dict["rssi"],
+                single_sensor_data_dict["uptime"],
+                single_sensor_data_dict["pa_latency"],
+                single_sensor_data_dict["memory"],
+                single_sensor_data_dict["last_seen"],
+                single_sensor_data_dict["last_modified"],
+                single_sensor_data_dict["date_created"],
+                single_sensor_data_dict["channel_state"],
+                single_sensor_data_dict["channel_flags"],
+                single_sensor_data_dict["channel_flags_manual"],
+                single_sensor_data_dict["channel_flags_auto"],
+                single_sensor_data_dict["confidence"],
+                single_sensor_data_dict["confidence_manual"],
+                single_sensor_data_dict["confidence_auto"],
+            ),
         )
 
         self._db_conn.execute(
             SQLITE_INSERT_STATEMENT_ENVIRONMENTAL_FIELDS,
-            (single_sensor_data_dict["data_time_stamp"],
-             single_sensor_data_dict["sensor_index"],
-             single_sensor_data_dict["humidity"],
-             single_sensor_data_dict["humidity_a"],
-             single_sensor_data_dict["humidity_b"],
-             single_sensor_data_dict["temperature"],
-             single_sensor_data_dict["temperature_a"],
-             single_sensor_data_dict["temperature_b"],
-             single_sensor_data_dict["pressure"],
-             single_sensor_data_dict["pressure_a"],
-             single_sensor_data_dict["pressure_b"])
+            (
+                single_sensor_data_dict["data_time_stamp"],
+                single_sensor_data_dict["sensor_index"],
+                single_sensor_data_dict["humidity"],
+                single_sensor_data_dict["humidity_a"],
+                single_sensor_data_dict["humidity_b"],
+                single_sensor_data_dict["temperature"],
+                single_sensor_data_dict["temperature_a"],
+                single_sensor_data_dict["temperature_b"],
+                single_sensor_data_dict["pressure"],
+                single_sensor_data_dict["pressure_a"],
+                single_sensor_data_dict["pressure_b"],
+            ),
         )
 
         self._db_conn.execute(
             SQLITE_INSERT_STATEMENT_MISCELLANEOUS_FIELDS,
-            (single_sensor_data_dict["data_time_stamp"],
-             single_sensor_data_dict["sensor_index"],
-             single_sensor_data_dict["voc"],
-             single_sensor_data_dict["voc_a"],
-             single_sensor_data_dict["voc_b"],
-             single_sensor_data_dict["ozone1"],
-             single_sensor_data_dict["analog_input"])
+            (
+                single_sensor_data_dict["data_time_stamp"],
+                single_sensor_data_dict["sensor_index"],
+                single_sensor_data_dict["voc"],
+                single_sensor_data_dict["voc_a"],
+                single_sensor_data_dict["voc_b"],
+                single_sensor_data_dict["ozone1"],
+                single_sensor_data_dict["analog_input"],
+            ),
         )
 
         self._db_conn.execute(
             SQLITE_INSERT_STATEMENT_PM1_0_FIELDS,
-            (single_sensor_data_dict["data_time_stamp"],
-             single_sensor_data_dict["sensor_index"],
-             single_sensor_data_dict["pm1.0"],
-             single_sensor_data_dict["pm1.0_a"],
-             single_sensor_data_dict["pm1.0_b"],
-             single_sensor_data_dict["pm1.0_atm"],
-             single_sensor_data_dict["pm1.0_atm_a"],
-             single_sensor_data_dict["pm1.0_atm_b"],
-             single_sensor_data_dict["pm1.0_cf_1"],
-             single_sensor_data_dict["pm1.0_cf_1_a"],
-             single_sensor_data_dict["pm1.0_cf_1_b"])
+            (
+                single_sensor_data_dict["data_time_stamp"],
+                single_sensor_data_dict["sensor_index"],
+                single_sensor_data_dict["pm1.0"],
+                single_sensor_data_dict["pm1.0_a"],
+                single_sensor_data_dict["pm1.0_b"],
+                single_sensor_data_dict["pm1.0_atm"],
+                single_sensor_data_dict["pm1.0_atm_a"],
+                single_sensor_data_dict["pm1.0_atm_b"],
+                single_sensor_data_dict["pm1.0_cf_1"],
+                single_sensor_data_dict["pm1.0_cf_1_a"],
+                single_sensor_data_dict["pm1.0_cf_1_b"],
+            ),
         )
 
         self._db_conn.execute(
             SQLITE_INSERT_STATEMENT_PM2_5_FIELDS,
-            (single_sensor_data_dict["data_time_stamp"],
-             single_sensor_data_dict["sensor_index"],
-             single_sensor_data_dict["pm2.5_alt"],
-             single_sensor_data_dict["pm2.5_alt_a"],
-             single_sensor_data_dict["pm2.5_alt_b"],
-             single_sensor_data_dict["pm2.5"],
-             single_sensor_data_dict["pm2.5_a"],
-             single_sensor_data_dict["pm2.5_b"],
-             single_sensor_data_dict["pm2.5_atm"],
-             single_sensor_data_dict["pm2.5_atm_a"],
-             single_sensor_data_dict["pm2.5_atm_b"],
-             single_sensor_data_dict["pm2.5_cf_1"],
-             single_sensor_data_dict["pm2.5_cf_1_a"],
-             single_sensor_data_dict["pm2.5_cf_1_b"])
+            (
+                single_sensor_data_dict["data_time_stamp"],
+                single_sensor_data_dict["sensor_index"],
+                single_sensor_data_dict["pm2.5_alt"],
+                single_sensor_data_dict["pm2.5_alt_a"],
+                single_sensor_data_dict["pm2.5_alt_b"],
+                single_sensor_data_dict["pm2.5"],
+                single_sensor_data_dict["pm2.5_a"],
+                single_sensor_data_dict["pm2.5_b"],
+                single_sensor_data_dict["pm2.5_atm"],
+                single_sensor_data_dict["pm2.5_atm_a"],
+                single_sensor_data_dict["pm2.5_atm_b"],
+                single_sensor_data_dict["pm2.5_cf_1"],
+                single_sensor_data_dict["pm2.5_cf_1_a"],
+                single_sensor_data_dict["pm2.5_cf_1_b"],
+            ),
         )
 
         self._db_conn.execute(
             SQLITE_INSERT_STATEMENT_PM2_5_PSEUDO_AVERAGE_FIELDS,
-            (single_sensor_data_dict["data_time_stamp"],
-             single_sensor_data_dict["sensor_index"],
-             single_sensor_data_dict["pm2.5_10minute"],
-             single_sensor_data_dict["pm2.5_10minute_a"],
-             single_sensor_data_dict["pm2.5_10minute_b"],
-             single_sensor_data_dict["pm2.5_30minute"],
-             single_sensor_data_dict["pm2.5_30minute_a"],
-             single_sensor_data_dict["pm2.5_30minute_b"],
-             single_sensor_data_dict["pm2.5_60minute"],
-             single_sensor_data_dict["pm2.5_60minute_a"],
-             single_sensor_data_dict["pm2.5_60minute_b"],
-             single_sensor_data_dict["pm2.5_6hour"],
-             single_sensor_data_dict["pm2.5_6hour_a"],
-             single_sensor_data_dict["pm2.5_6hour_b"],
-             single_sensor_data_dict["pm2.5_24hour"],
-             single_sensor_data_dict["pm2.5_24hour_a"],
-             single_sensor_data_dict["pm2.5_24hour_b"],
-             single_sensor_data_dict["pm2.5_1week"],
-             single_sensor_data_dict["pm2.5_1week_a"],
-             single_sensor_data_dict["pm2.5_1week_b"])
+            (
+                single_sensor_data_dict["data_time_stamp"],
+                single_sensor_data_dict["sensor_index"],
+                single_sensor_data_dict["pm2.5_10minute"],
+                single_sensor_data_dict["pm2.5_10minute_a"],
+                single_sensor_data_dict["pm2.5_10minute_b"],
+                single_sensor_data_dict["pm2.5_30minute"],
+                single_sensor_data_dict["pm2.5_30minute_a"],
+                single_sensor_data_dict["pm2.5_30minute_b"],
+                single_sensor_data_dict["pm2.5_60minute"],
+                single_sensor_data_dict["pm2.5_60minute_a"],
+                single_sensor_data_dict["pm2.5_60minute_b"],
+                single_sensor_data_dict["pm2.5_6hour"],
+                single_sensor_data_dict["pm2.5_6hour_a"],
+                single_sensor_data_dict["pm2.5_6hour_b"],
+                single_sensor_data_dict["pm2.5_24hour"],
+                single_sensor_data_dict["pm2.5_24hour_a"],
+                single_sensor_data_dict["pm2.5_24hour_b"],
+                single_sensor_data_dict["pm2.5_1week"],
+                single_sensor_data_dict["pm2.5_1week_a"],
+                single_sensor_data_dict["pm2.5_1week_b"],
+            ),
         )
 
         self._db_conn.execute(
             SQLITE_INSERT_STATEMENT_PM10_0_FIELDS,
-            (single_sensor_data_dict["data_time_stamp"],
-             single_sensor_data_dict["sensor_index"],
-             single_sensor_data_dict["pm10.0"],
-             single_sensor_data_dict["pm10.0_a"],
-             single_sensor_data_dict["pm10.0_b"],
-             single_sensor_data_dict["pm10.0_atm"],
-             single_sensor_data_dict["pm10.0_atm_a"],
-             single_sensor_data_dict["pm10.0_atm_b"],
-             single_sensor_data_dict["pm10.0_cf_1"],
-             single_sensor_data_dict["pm10.0_cf_1_a"],
-             single_sensor_data_dict["pm10.0_cf_1_b"])
+            (
+                single_sensor_data_dict["data_time_stamp"],
+                single_sensor_data_dict["sensor_index"],
+                single_sensor_data_dict["pm10.0"],
+                single_sensor_data_dict["pm10.0_a"],
+                single_sensor_data_dict["pm10.0_b"],
+                single_sensor_data_dict["pm10.0_atm"],
+                single_sensor_data_dict["pm10.0_atm_a"],
+                single_sensor_data_dict["pm10.0_atm_b"],
+                single_sensor_data_dict["pm10.0_cf_1"],
+                single_sensor_data_dict["pm10.0_cf_1_a"],
+                single_sensor_data_dict["pm10.0_cf_1_b"],
+            ),
         )
 
         self._db_conn.execute(
             SQLITE_INSERT_STATEMENT_PARTICLE_COUNT_FIELDS,
-            (single_sensor_data_dict["data_time_stamp"],
-             single_sensor_data_dict["sensor_index"],
-             single_sensor_data_dict["0.3_um_count"],
-             single_sensor_data_dict["0.3_um_count_a"],
-             single_sensor_data_dict["0.3_um_count_b"],
-             single_sensor_data_dict["0.5_um_count"],
-             single_sensor_data_dict["0.5_um_count_a"],
-             single_sensor_data_dict["0.5_um_count_b"],
-             single_sensor_data_dict["1.0_um_count"],
-             single_sensor_data_dict["1.0_um_count_a"],
-             single_sensor_data_dict["1.0_um_count_b"],
-             single_sensor_data_dict["2.5_um_count"],
-             single_sensor_data_dict["2.5_um_count_a"],
-             single_sensor_data_dict["2.5_um_count_b"],
-             single_sensor_data_dict["5.0_um_count"],
-             single_sensor_data_dict["5.0_um_count_a"],
-             single_sensor_data_dict["5.0_um_count_b"],
-             single_sensor_data_dict["10.0_um_count"],
-             single_sensor_data_dict["10.0_um_count_a"],
-             single_sensor_data_dict["10.0_um_count_b"])
+            (
+                single_sensor_data_dict["data_time_stamp"],
+                single_sensor_data_dict["sensor_index"],
+                single_sensor_data_dict["0.3_um_count"],
+                single_sensor_data_dict["0.3_um_count_a"],
+                single_sensor_data_dict["0.3_um_count_b"],
+                single_sensor_data_dict["0.5_um_count"],
+                single_sensor_data_dict["0.5_um_count_a"],
+                single_sensor_data_dict["0.5_um_count_b"],
+                single_sensor_data_dict["1.0_um_count"],
+                single_sensor_data_dict["1.0_um_count_a"],
+                single_sensor_data_dict["1.0_um_count_b"],
+                single_sensor_data_dict["2.5_um_count"],
+                single_sensor_data_dict["2.5_um_count_a"],
+                single_sensor_data_dict["2.5_um_count_b"],
+                single_sensor_data_dict["5.0_um_count"],
+                single_sensor_data_dict["5.0_um_count_a"],
+                single_sensor_data_dict["5.0_um_count_b"],
+                single_sensor_data_dict["10.0_um_count"],
+                single_sensor_data_dict["10.0_um_count_a"],
+                single_sensor_data_dict["10.0_um_count_b"],
+            ),
         )
 
         self._db_conn.execute(
             SQLITE_INSERT_STATEMENT_THINGSPEAK_FIELDS,
-            (single_sensor_data_dict["data_time_stamp"],
-             single_sensor_data_dict["sensor_index"],
-             single_sensor_data_dict["primary_id_a"],
-             single_sensor_data_dict["primary_key_a"],
-             single_sensor_data_dict["secondary_id_a"],
-             single_sensor_data_dict["secondary_key_a"],
-             single_sensor_data_dict["primary_id_b"],
-             single_sensor_data_dict["primary_key_b"],
-             single_sensor_data_dict["secondary_id_b"],
-             single_sensor_data_dict["secondary_key_b"])
+            (
+                single_sensor_data_dict["data_time_stamp"],
+                single_sensor_data_dict["sensor_index"],
+                single_sensor_data_dict["primary_id_a"],
+                single_sensor_data_dict["primary_key_a"],
+                single_sensor_data_dict["secondary_id_a"],
+                single_sensor_data_dict["secondary_key_a"],
+                single_sensor_data_dict["primary_id_b"],
+                single_sensor_data_dict["primary_key_b"],
+                single_sensor_data_dict["secondary_id_b"],
+                single_sensor_data_dict["secondary_key_b"],
+            ),
         )
 
         # Commit to the db
@@ -252,20 +282,43 @@ def store_sensor_data(self, single_sensor_data_dict):
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
-        description="Collect data from PurpleAir sensors and store it a SQLite3 database file!")
-    parser.add_argument("-db_name",  required=True,
-                        dest="db_name", type=str, help="""The path and name for the SQLite3 database
-                        file! i.e database_name.db""")
-    parser.add_argument("-paa_read_key",  required=True,
-                        dest="paa_read_key", type=str, help="""The PurpleAirAPI Read key""")
-    parser.add_argument("-paa_single_sensor_request_json_file",  required=False, default=None,
-                        dest="paa_single_sensor_request_json_file", type=str, help="""The
+        description="Collect data from PurpleAir sensors and store it a SQLite3 database file!"
+    )
+    parser.add_argument(
+        "-db_name",
+        required=True,
+        dest="db_name",
+        type=str,
+        help="""The path and name for the SQLite3 database
+                        file! i.e database_name.db""",
+    )
+    parser.add_argument(
+        "-paa_read_key",
+        required=True,
+        dest="paa_read_key",
+        type=str,
+        help="""The PurpleAirAPI Read key""",
+    )
+    parser.add_argument(
+        "-paa_single_sensor_request_json_file",
+        required=False,
+        default=None,
+        dest="paa_single_sensor_request_json_file",
+        type=str,
+        help="""The
                         path to a json file containing the parameters to send a single
-                        sensor request.""")
-    parser.add_argument("-paa_multiple_sensor_request_json_file",  required=False, default=None,
-                        dest="paa_multiple_sensor_request_json_file", type=str, help="""The
+                        sensor request.""",
+    )
+    parser.add_argument(
+        "-paa_multiple_sensor_request_json_file",
+        required=False,
+        default=None,
+        dest="paa_multiple_sensor_request_json_file",
+        type=str,
+        help="""The
                         path to a json file containing the parameters to send a multiple
-                        sensor request.""")
+                        sensor request.""",
+    )
 
     args = parser.parse_args()
 
@@ -275,8 +328,11 @@ def store_sensor_data(self, single_sensor_data_dict):
 
     # Second make an instance our our data logger
     the_paa_sqlite_data_logger = PurpleAirSQLiteDataLogger(
-        args.paa_read_key, args.db_name)
+        args.paa_read_key, args.db_name
+    )
 
     # Third choose what run method to execute depending on paa_multiple_sensor_request_json_file/paa_single_sensor_request_json_file
     the_paa_sqlite_data_logger.validate_parameters_and_run(
-        args.paa_multiple_sensor_request_json_file, args.paa_single_sensor_request_json_file)
+        args.paa_multiple_sensor_request_json_file,
+        args.paa_single_sensor_request_json_file,
+    )
diff --git a/setup.cfg b/setup.cfg
index 4b885ea..ab12e93 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -3,4 +3,4 @@ description-file=README.md
 license_files=LICENSE
 
 [options]
-python_requires = >=3.7
\ No newline at end of file
+python_requires = >=3.8
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 1afa732..e6be505 100644
--- a/setup.py
+++ b/setup.py
@@ -10,19 +10,23 @@ def read_file(filename):
 
 setup(
     name="purpleair_data_logger",
-    version="1.0.0",
+    version="1.1.0",
     license="MIT",
     author="Carlos Santos",
     author_email="27721404+carlkid1499@users.noreply.github.com",
-    long_description=read_file('README.md'),
-    long_description_content_type='text/markdown',
-    packages=['purpleair_data_logger'],
+    long_description=read_file("README.md"),
+    long_description_content_type="text/markdown",
+    packages=["purpleair_data_logger"],
     url="https://github.com/carlkid1499/purpleair_data_logger",
-    keywords=["purpleair_data_logger", "purpleair", "purpleair data logger",
-              "PurpleAirPSQLDataLogger", "PurpleAirCSVDataLogger"],
-    install_requires=[
-        "pg8000",
-        "requests"
+    keywords=[
+        "purpleair_data_logger",
+        "purple air",
+        "purple air data logger",
+        "PurpleAirPSQLDataLogger",
+        "PurpleAirCSVDataLogger",
+        "purple air api",
+        "PurpleAirSQLiteDataLogger",
     ],
-    platforms=["Windows 32/64", "Linux 32/64", "MacOS 32/64"]
+    install_requires=["pg8000", "requests"],
+    platforms=["Windows 32/64", "Linux 32/64", "MacOS 32/64"],
 )
diff --git a/sphinx_docs_build/source/conf.py b/sphinx_docs_build/source/conf.py
index db56282..f27ad03 100644
--- a/sphinx_docs_build/source/conf.py
+++ b/sphinx_docs_build/source/conf.py
@@ -12,17 +12,18 @@
 #
 import os
 import sys
-sys.path.insert(0, os.path.abspath('../../purpleair_data_logger/'))
+
+sys.path.insert(0, os.path.abspath("../../purpleair_data_logger/"))
 
 
 # -- Project information -----------------------------------------------------
 
-project = 'PurpleAir Data Logger(s)'
-copyright = '2022, carlkid1499'
-author = 'carlkid1499'
+project = "PurpleAir Data Logger(s)"
+copyright = "2022, carlkid1499"
+author = "carlkid1499"
 
 # The full version, including alpha/beta/rc tags
-release = 'V1.0.0'
+release = "V1.0.0"
 
 
 # -- General configuration ---------------------------------------------------
@@ -33,7 +34,7 @@
 extensions = ["sphinx.ext.autodoc"]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -46,9 +47,9 @@
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'sphinx_rtd_theme'
+html_theme = "sphinx_rtd_theme"
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
\ No newline at end of file
+html_static_path = ["_static"]


Test patch:
diff --git a/behave_tests/environment.py b/behave_tests/environment.py
index efc49b8..200be75 100644
--- a/behave_tests/environment.py
+++ b/behave_tests/environment.py
@@ -9,9 +9,10 @@
 from shutil import rmtree
 from platform import python_version, system
 
+
 def before_all(context):
     """
-        These run before and after the whole shooting match.
+    These run before and after the whole shooting match.
     """
 
     # Make a place to store logs. First remove then create
@@ -53,14 +54,14 @@ def before_all(context):
 
 def after_all(context):
     """
-        These run before and after the whole shooting match.
+    These run before and after the whole shooting match.
     """
     pass
 
 
 def before_step(context, step):
     """
-        These run before and after every step.
+    These run before and after every step.
     """
 
     pass
@@ -68,7 +69,7 @@ def before_step(context, step):
 
 def after_step(context, step):
     """
-        These run before and after every step.
+    These run before and after every step.
     """
 
     pass
@@ -76,7 +77,7 @@ def after_step(context, step):
 
 def before_scenario(context, scenario):
     """
-        These run before and after each scenario is run.
+    These run before and after each scenario is run.
     """
 
     context.test_settings_file_name = ""
@@ -85,7 +86,7 @@ def before_scenario(context, scenario):
 
 def after_scenario(context, scenario):
     """
-        These run before and after each scenario is run.
+    These run before and after each scenario is run.
     """
 
     context.test_settings_file_name = ""
@@ -94,7 +95,7 @@ def after_scenario(context, scenario):
 
 def before_feature(context, feature):
     """
-        These run before and after each feature file is exercised.
+    These run before and after each feature file is exercised.
     """
 
     context.test_settings_file_name = ""
@@ -103,7 +104,7 @@ def before_feature(context, feature):
 
 def after_feature(context, feature):
     """
-        These run before and after each feature file is exercised.
+    These run before and after each feature file is exercised.
     """
 
     context.test_settings_file_name = ""
@@ -112,17 +113,17 @@ def after_feature(context, feature):
 
 def before_tag(context, tag):
     """
-        These run before and after a section tagged with the given name.
-        They are invoked for each tag encountered in the order they’re found in the feature file.
-        See controlling things with tags.
+    These run before and after a section tagged with the given name.
+    They are invoked for each tag encountered in the order they’re found in the feature file.
+    See controlling things with tags.
     """
     pass
 
 
 def after_tag(context, tag):
     """
-        These run before and after a section tagged with the given name.
-        They are invoked for each tag encountered in the order they’re found in the feature file.
-        See controlling things with tags.
+    These run before and after a section tagged with the given name.
+    They are invoked for each tag encountered in the order they’re found in the feature file.
+    See controlling things with tags.
     """
     pass
diff --git a/behave_tests/steps/steps.py b/behave_tests/steps/steps.py
index 587df34..141144d 100644
--- a/behave_tests/steps/steps.py
+++ b/behave_tests/steps/steps.py
@@ -14,20 +14,28 @@
 SLEEP_BETWEEN_REPEATED_API_CALLS = 1.1 * 60  # mins * seconds
 
 
-@given("we do not provide {settings_field} in {config_file_type} sensor configuration file")
-def create_configuration_file_with_settings_field_omitted(context, config_file_type=None, settings_field=None):
+@given(
+    "we do not provide {settings_field} in {config_file_type} sensor configuration file"
+)
+def create_configuration_file_with_settings_field_omitted(
+    context, config_file_type=None, settings_field=None
+):
 
     if settings_field is None:
         raise ValueError(
-            "In step 'create_configuration_file_with_settings_field_omitted' parameter 'settings_field' can not be `None`!")
+            "In step 'create_configuration_file_with_settings_field_omitted' parameter 'settings_field' can not be `None`!"
+        )
 
     if config_file_type is None:
         raise ValueError(
-            "In step 'create_configuration_file_with_settings_field_omitted' parameter 'config_file_type' can not be `None`!")
+            "In step 'create_configuration_file_with_settings_field_omitted' parameter 'config_file_type' can not be `None`!"
+        )
 
     # Open up ../sample_json_config_files/sample_multiple_sensor_request_json_file.json
     read_file_obj = open(
-        f"../sample_json_config_files/sample_{config_file_type}_sensor_request_json_file.json", "r")
+        f"../sample_json_config_files/sample_{config_file_type}_sensor_request_json_file.json",
+        "r",
+    )
 
     # Read in the json file into a python3 dict
     json_file_contents = load(read_file_obj)
@@ -37,10 +45,13 @@ def create_configuration_file_with_settings_field_omitted(context, config_file_t
     del json_file_contents[str(settings_field)]
 
     # Write new file to disk
-    context.test_settings_file_name = f"{config_file_type}_settings_file_with_{settings_field}_removed.json"
+    context.test_settings_file_name = (
+        f"{config_file_type}_settings_file_with_{settings_field}_removed.json"
+    )
     context.settings_field_being_removed = settings_field
-    context.test_settings_file_name_and_path = context.logs_path + \
-        f"/{context.test_settings_file_name}"
+    context.test_settings_file_name_and_path = (
+        context.logs_path + f"/{context.test_settings_file_name}"
+    )
     json_file_contents = dumps(json_file_contents)
     write_file_obj = open(context.test_settings_file_name_and_path, "x")
     write_file_obj.write(json_file_contents)
@@ -48,41 +59,65 @@ def create_configuration_file_with_settings_field_omitted(context, config_file_t
     write_file_obj.close()
 
 
-@when("we start the CSVDatalogger using above {config_file_type} sensor configuration file")
+@when(
+    "we start the CSVDatalogger using above {config_file_type} sensor configuration file"
+)
 def start_the_csv_data_logger(context, config_file_type=None):
 
     if config_file_type is None:
         raise ValueError(
-            "In step 'start_the_csv_data_logger' parameter 'config_file_type' can not be `None`!")
+            "In step 'start_the_csv_data_logger' parameter 'config_file_type' can not be `None`!"
+        )
 
     # Launch the CSVDataLogger with test_settings_file_name_and_path
-    context.csvdatalogger_save_file_path = context.logs_path + \
-        "/" + "csvdatalogger_outputs"
+    context.csvdatalogger_save_file_path = (
+        context.logs_path + "/" + "csvdatalogger_outputs"
+    )
 
     if config_file_type == "single":
-        command_args = ["python3", "-m", "purpleair_data_logger.PurpleAirCSVDataLogger",
-                        "-save_file_path", f"{context.csvdatalogger_save_file_path}",
-                        "-paa_read_key", f"{context.config.userdata['PAA_API_READ_KEY']}",
-                        "-paa_single_sensor_request_json_file", f"{context.test_settings_file_name_and_path}"]
+        command_args = [
+            "python3",
+            "-m",
+            "purpleair_data_logger.PurpleAirCSVDataLogger",
+            "-save_file_path",
+            f"{context.csvdatalogger_save_file_path}",
+            "-paa_read_key",
+            f"{context.config.userdata['PAA_API_READ_KEY']}",
+            "-paa_single_sensor_request_json_file",
+            f"{context.test_settings_file_name_and_path}",
+        ]
 
     elif config_file_type == "multiple":
-        command_args = ["python3", "-m", "purpleair_data_logger.PurpleAirCSVDataLogger",
-                        "-save_file_path", f"{context.csvdatalogger_save_file_path}",
-                        "-paa_read_key", f"{context.config.userdata['PAA_API_READ_KEY']}",
-                        "-paa_multiple_sensor_request_json_file", f"{context.test_settings_file_name_and_path}"]
+        command_args = [
+            "python3",
+            "-m",
+            "purpleair_data_logger.PurpleAirCSVDataLogger",
+            "-save_file_path",
+            f"{context.csvdatalogger_save_file_path}",
+            "-paa_read_key",
+            f"{context.config.userdata['PAA_API_READ_KEY']}",
+            "-paa_multiple_sensor_request_json_file",
+            f"{context.test_settings_file_name_and_path}",
+        ]
 
     else:
         raise ValueError(
-            "Invalid option for 'start_the_csv_data_logger' parameter 'config_file_type'!")
+            "Invalid option for 'start_the_csv_data_logger' parameter 'config_file_type'!"
+        )
 
     # Create stdout and stderr files
     context.stdout_file_obj = open(
-        f"{context.test_settings_file_name_and_path}.stdout", "x")
+        f"{context.test_settings_file_name_and_path}.stdout", "x"
+    )
     context.stderr_file_obj = open(
-        f"{context.test_settings_file_name_and_path}.stderr", "x")
+        f"{context.test_settings_file_name_and_path}.stderr", "x"
+    )
 
     context.subproc_for_datalogger = subprocess.Popen(
-        args=command_args, stdout=context.stdout_file_obj, stderr=context.stderr_file_obj)
+        args=command_args,
+        stdout=context.stdout_file_obj,
+        stderr=context.stderr_file_obj,
+    )
 
     sleep(SLEEP_BETWEEN_REPEATED_API_CALLS)
 
@@ -92,11 +127,13 @@ def check_started_data_logger(context, expected_outcome=None, error_message=None
 
     if expected_outcome is None:
         raise ValueError(
-            "In step 'check_started_data_logger' parameter 'expected_outcome' can not be `None`!")
+            "In step 'check_started_data_logger' parameter 'expected_outcome' can not be `None`!"
+        )
 
     if error_message is None:
         raise ValueError(
-            "In step 'check_started_data_logger' parameter 'error_message' can not be `None`!")
+            "In step 'check_started_data_logger' parameter 'error_message' can not be `None`!"
+        )
 
     # Now kill the proc, we are done with it
     context.stdout_file_obj.flush()
@@ -105,73 +142,106 @@ def check_started_data_logger(context, expected_outcome=None, error_message=None
     context.stdout_file_obj.close()
     context.stderr_file_obj.close()
 
-    file_err_obj = open(
-        f"{context.test_settings_file_name_and_path}.stderr", "r")
+    file_err_obj = open(f"{context.test_settings_file_name_and_path}.stderr", "r")
     file_err_contents = file_err_obj.read()
     file_err_obj.close()
 
-    file_out_obj = open(
-        f"{context.test_settings_file_name_and_path}.stdout", "r")
+    file_out_obj = open(f"{context.test_settings_file_name_and_path}.stdout", "r")
     file_out_contents = file_out_obj.read()
     file_out_obj.close()
 
     file_out_contents = str(file_out_contents)
     file_err_contents = str(file_err_contents)
-    multi_run_loop_msg = "_run_loop_for_storing_multiple_sensors_data - Beep boop I am alive..."
-    single_run_loop_msg = "_run_loop_for_storing_single_sensor_data - Beep boop I am alive..."
+    multi_run_loop_msg = (
+        "_run_loop_for_storing_multiple_sensors_data - Beep boop I am alive..."
+    )
+    single_run_loop_msg = (
+        "_run_loop_for_storing_single_sensor_data - Beep boop I am alive..."
+    )
 
     if expected_outcome == "not start":
 
         if "single" in context.test_settings_file_name_and_path:
-            assert_that(single_run_loop_msg, is_in(file_out_contents),
-                        "Checking contents of stdout file...")
+            assert_that(
+                single_run_loop_msg,
+                is_in(file_out_contents),
+                "Checking contents of stdout file...",
+            )
 
         elif "multiple" in context.test_settings_file_name_and_path:
-            assert_that(multi_run_loop_msg, is_in(file_out_contents),
-                        "Checking contents of stdout file...")
+            assert_that(
+                multi_run_loop_msg,
+                is_in(file_out_contents),
+                "Checking contents of stdout file...",
+            )
         else:
-            raise ValueError(
-                "Invalid file. Only `single` or `multiple` supported!")
+            raise ValueError("Invalid file. Only `single` or `multiple` supported!")
 
         if error_message != "None":
-            assert_that(error_message, is_in(file_err_contents),
-                        "Checking contents of stderr file...")
-
-        assert_that(context.subproc_for_datalogger.returncode,
-                    equal_to(1), "Checking subproc return code...")
+            assert_that(
+                error_message,
+                is_in(file_err_contents),
+                "Checking contents of stderr file...",
+            )
+
+        assert_that(
+            context.subproc_for_datalogger.returncode,
+            equal_to(1),
+            "Checking subproc return code...",
+        )
 
     elif expected_outcome == "start":
         # This if statement here is to please tests when ran under python 3.9/10 on windows.
-        if context.python_version_list[0] == "3" and \
-           (context.python_version_list[1] == "9" or context.python_version_list[1] == "10") and \
-           context.operating_system == "windows" and \
-           context.test_settings_file_name_and_path == "settings_file_with_custom_fields_value_2.json":
+        if (
+            context.python_version_list[0] == "3"
+            and (
+                context.python_version_list[1] == "9"
+                or context.python_version_list[1] == "10"
+            )
+            and context.operating_system == "windows"
+            and context.test_settings_file_name_and_path
+            == "settings_file_with_custom_fields_value_2.json"
+        ):
 
             if "single" in context.test_settings_file_name_and_path:
-                assert_that(single_run_loop_msg, is_in(file_out_contents),
-                            "Checking contents of stdout file...")
+                assert_that(
+                    single_run_loop_msg,
+                    is_in(file_out_contents),
+                    "Checking contents of stdout file...",
+                )
 
             elif "multiple" in context.test_settings_file_name_and_path:
-                assert_that(multi_run_loop_msg, is_in(file_out_contents),
-                            "Checking contents of stdout file...")
+                assert_that(
+                    multi_run_loop_msg,
+                    is_in(file_out_contents),
+                    "Checking contents of stdout file...",
+                )
             else:
-                raise ValueError(
-                    "Invalid file. Only `single` or `multiple` supported!")
+                raise ValueError("Invalid file. Only `single` or `multiple` supported!")
 
-            assert_that("We weren't able to write the current data!", is_in(file_out_contents),
-                        "Checking contents of stdout file...")
+            assert_that(
+                "We weren't able to write the current data!",
+                is_in(file_out_contents),
+                "Checking contents of stdout file...",
+            )
 
-            assert_that(file_err_contents, is_(""),
-                        "Checking contents of stderr file...")
+            assert_that(
+                file_err_contents, is_(""), "Checking contents of stderr file..."
+            )
 
         else:
-            assert_that(file_out_contents, is_(""),
-                        "Checking contents of stdout file...")
-            assert_that(file_err_contents, is_(""),
-                        "Checking contents of stderr file...")
-
-        assert_that(context.subproc_for_datalogger.returncode,
-                    equal_to(None), "Checking subproc return code...")
+            assert_that(
+                file_out_contents, is_(""), "Checking contents of stdout file..."
+            )
+            assert_that(
+                file_err_contents, is_(""), "Checking contents of stderr file..."
+            )
+
+        assert_that(
+            context.subproc_for_datalogger.returncode,
+            equal_to(None),
+            "Checking subproc return code...",
+        )
 
     else:
         raise ValueError(f"{expected_outcome} is not a valid case!")
@@ -182,19 +252,24 @@ def set_field_in_json_to_value(context, field=None, config_file_type=None, value
 
     if field is None:
         raise ValueError(
-            "In step 'set_field_in_json_to_value' parameter 'field' can not be `None`!")
+            "In step 'set_field_in_json_to_value' parameter 'field' can not be `None`!"
+        )
 
     if config_file_type is None:
         raise ValueError(
-            "In step 'set_field_in_json_to_value' parameter 'config_file_type' can not be `None`!")
+            "In step 'set_field_in_json_to_value' parameter 'config_file_type' can not be `None`!"
+        )
 
     if value is None:
         raise ValueError(
-            "In step 'set_field_in_json_to_value' parameter 'value' can not be `None`!")
+            "In step 'set_field_in_json_to_value' parameter 'value' can not be `None`!"
+        )
 
     # Open up ../sample_json_config_files/sample_multiple_sensor_request_json_file.json
     read_file_obj = open(
-        f"../sample_json_config_files/sample_{config_file_type}_sensor_request_json_file.json", "r")
+        f"../sample_json_config_files/sample_{config_file_type}_sensor_request_json_file.json",
+        "r",
+    )
 
     # Read in the json file into a python3 dict
     json_file_contents = load(read_file_obj)
@@ -209,12 +284,12 @@ def set_field_in_json_to_value(context, field=None, config_file_type=None, value
     while did_we_write_a_new_file == False:
         try:
             context.test_settings_file_name = f"{config_file_type}_settings_file_with_custom_{field}_value_{file_creation_counter}.json"
-            context.test_settings_file_name_and_path = context.logs_path + \
-                f"/{context.test_settings_file_name}"
+            context.test_settings_file_name_and_path = (
+                context.logs_path + f"/{context.test_settings_file_name}"
+            )
             json_file_contents_out = None
             json_file_contents_out = dumps(json_file_contents)
-            write_file_obj = open(
-                context.test_settings_file_name_and_path, "x")
+            write_file_obj = open(context.test_settings_file_name_and_path, "x")
             write_file_obj.write(json_file_contents_out)
             write_file_obj.flush()
             write_file_obj.close()