MindsDB 25.8.3.0__py3-none-any.whl → 25.9.1.1__py3-none-any.whl

mindsdb/integrations/handlers/google_content_shopping_handler/google_content_shopping_handler.py

@@ -20,9 +20,10 @@ logger = log.getLogger(__name__)
 
 class GoogleContentShoppingHandler(APIHandler):
     """
-        A class for handling connections and interactions with the Google Content API for Shopping.
+    A class for handling connections and interactions with the Google Content API for Shopping.
     """
-    name = 'google_content_shopping'
+
+    name = "google_content_shopping"
 
     def __init__(self, name: str, **kwargs):
         """
@@ -34,22 +35,22 @@ class GoogleContentShoppingHandler(APIHandler):
         super().__init__(name)
         self.token = None
         self.service = None
-        self.connection_data = kwargs.get('connection_data', {})
-        self.fs_storage = kwargs['file_storage']
-        self.credentials_file = self.connection_data.get('credentials', None)
-        self.merchant_id = self.connection_data.get('merchant_id', None)
+        self.connection_data = kwargs.get("connection_data", {})
+        self.fs_storage = kwargs["file_storage"]
+        self.credentials_file = self.connection_data.get("credentials", None)
+        self.merchant_id = self.connection_data.get("merchant_id", None)
         self.credentials = None
-        self.scopes = ['https://www.googleapis.com/auth/content']
+        self.scopes = ["https://www.googleapis.com/auth/content"]
         self.is_connected = False
         accounts = AccountsTable(self)
         self.accounts = accounts
-        self._register_table('Accounts', accounts)
+        self._register_table("Accounts", accounts)
         orders = OrdersTable(self)
         self.orders = orders
-        self._register_table('Orders', orders)
+        self._register_table("Orders", orders)
         products = ProductsTable(self)
         self.products = products
-        self._register_table('Products', products)
+        self._register_table("Products", products)
 
     def connect(self):
         """
@@ -63,7 +64,7 @@ class GoogleContentShoppingHandler(APIHandler):
             return self.service
         if self.credentials_file:
             try:
-                json_str_bytes = self.fs_storage.file_get('token_content.json')
+                json_str_bytes = self.fs_storage.file_get("token_content.json")
                 json_str = json_str_bytes.decode()
                 self.credentials = Credentials.from_authorized_user_info(info=json.loads(json_str), scopes=self.scopes)
             except Exception:
@@ -73,11 +74,12 @@ class GoogleContentShoppingHandler(APIHandler):
                     self.credentials.refresh(Request())
                 else:
                     self.credentials = service_account.Credentials.from_service_account_file(
-                        self.credentials_file, scopes=self.scopes)
+                        self.credentials_file, scopes=self.scopes
+                    )
             # Save the credentials for the next run
             json_str = self.credentials.to_json()
-            self.fs_storage.file_set('token_content.json', json_str.encode())
-            self.service = build('content', 'v2.1', credentials=self.credentials)
+            self.fs_storage.file_set("token_content.json", json_str.encode())
+            self.service = build("content", "v2.1", credentials=self.credentials)
         return self.service
 
     def check_connection(self) -> StatusResponse:
@@ -92,7 +94,7 @@ class GoogleContentShoppingHandler(APIHandler):
             self.connect()
             response.success = True
         except Exception as e:
-            logger.error(f'Error connecting to Google Content API for Shopping: {e}!')
+            logger.error(f"Error connecting to Google Content API for Shopping: {e}!")
             response.error_message = e
 
         self.is_connected = response.success
@@ -103,7 +105,7 @@ class GoogleContentShoppingHandler(APIHandler):
         Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
-                dict for mongo, api's json etc)
+                api's json etc)
         Returns:
             HandlerResponse
         """
@@ -111,10 +113,7 @@ class GoogleContentShoppingHandler(APIHandler):
 
         df = self.call_application_api(method_name, params)
 
-        return Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=df
-        )
+        return Response(RESPONSE_TYPE.TABLE, data_frame=df)
 
     def get_accounts(self, params: dict = None) -> DataFrame:
         """
@@ -127,33 +126,32 @@ class GoogleContentShoppingHandler(APIHandler):
         service = self.connect()
         page_token = None
         accounts = pd.DataFrame(columns=self.accounts.get_columns())
-        if params['account_id']:
-            result = service.accounts().get(merchantId=self.merchant_id, accountId=params['account_id']).execute()
+        if params["account_id"]:
+            result = service.accounts().get(merchantId=self.merchant_id, accountId=params["account_id"]).execute()
             accounts = pd.DataFrame(result, columns=self.accounts.get_columns())
             return accounts
         while True:
             result = service.accounts().list(merchantId=self.merchant_id, page_token=page_token, **params).execute()
             accounts = pd.concat(
-                [accounts, pd.DataFrame(result['resources'], columns=self.accounts.get_columns())],
-                ignore_index=True
+                [accounts, pd.DataFrame(result["resources"], columns=self.accounts.get_columns())], ignore_index=True
             )
-            page_token = result.get('nextPageToken')
+            page_token = result.get("nextPageToken")
             if not page_token:
                 break
 
-        if params['startId'] and params['endId']:
-            start_id = int(params['startId'])
-            end_id = int(params['endId'])
-        elif params['startId']:
-            start_id = int(params['startId'])
+        if params["startId"] and params["endId"]:
+            start_id = int(params["startId"])
+            end_id = int(params["endId"])
+        elif params["startId"]:
+            start_id = int(params["startId"])
             end_id = start_id + 10
-        elif params['endId']:
-            end_id = int(params['endId'])
+        elif params["endId"]:
+            end_id = int(params["endId"])
             start_id = end_id - 10
         else:
-            raise Exception('startId or endId must be specified')
+            raise Exception("startId or endId must be specified")
 
-        accounts = accounts.drop(accounts[(accounts['id'] < start_id) | (accounts['id'] > end_id)].index)
+        accounts = accounts.drop(accounts[(accounts["id"] < start_id) | (accounts["id"] > end_id)].index)
 
         return accounts
 
@@ -167,25 +165,26 @@ class GoogleContentShoppingHandler(APIHandler):
         """
         service = self.connect()
         args = {}
-        if params['force']:
-            args = {'force': params['force']}
-        if params['accountId']:
-            result = service.accounts().delete(merchantId=self.merchant_id, accountId=params['accountId'],
-                                               **args).execute()
+        if params["force"]:
+            args = {"force": params["force"]}
+        if params["accountId"]:
+            result = (
+                service.accounts().delete(merchantId=self.merchant_id, accountId=params["accountId"], **args).execute()
+            )
             return result
         else:
-            df = pd.DataFrame(columns=['accountId', 'status'])
-            if not params['startId']:
-                start_id = int(params['endId']) - 10
-            elif not params['endId']:
-                end_id = int(params['startId']) + 10
+            df = pd.DataFrame(columns=["accountId", "status"])
+            if not params["startId"]:
+                start_id = int(params["endId"]) - 10
+            elif not params["endId"]:
+                end_id = int(params["startId"]) + 10
             else:
-                start_id = int(params['startId'])
-                end_id = int(params['endId'])
+                start_id = int(params["startId"])
+                end_id = int(params["endId"])
 
             for i in range(start_id, end_id):
                 service.accounts().delete(merchantId=self.merchant_id, accountId=i, **args).execute()
-                df = pd.concat([df, pd.DataFrame([{'accountId': str(i), 'status': 'deleted'}])], ignore_index=True)
+                df = pd.concat([df, pd.DataFrame([{"accountId": str(i), "status": "deleted"}])], ignore_index=True)
             return df
 
     def get_orders(self, params: dict = None) -> DataFrame:
@@ -200,41 +199,37 @@ class GoogleContentShoppingHandler(APIHandler):
         page_token = None
         orders = pd.DataFrame(columns=self.orders.get_columns())
         args = {
-            key: value for key, value in params.items() if key in ['maxResults',
-                                                                   'statuses',
-                                                                   'acknowledged',
-                                                                   'placedDateStart',
-                                                                   'placedDateEnd',
-                                                                   'orderBy']
+            key: value
+            for key, value in params.items()
+            if key in ["maxResults", "statuses", "acknowledged", "placedDateStart", "placedDateEnd", "orderBy"]
             and value is not None
         }
-        if params['order_id']:
-            result = service.orders().get(merchantId=self.merchant_id, orderId=params['order_id'], **args).execute()
+        if params["order_id"]:
+            result = service.orders().get(merchantId=self.merchant_id, orderId=params["order_id"], **args).execute()
             orders = pd.DataFrame(result, columns=self.orders.get_columns())
             return orders
         while True:
             result = service.orders().list(merchantId=self.merchant_id, page_token=page_token, **args).execute()
             orders = pd.concat(
-                [orders, pd.DataFrame(result['resources'], columns=self.orders.get_columns())],
-                ignore_index=True
+                [orders, pd.DataFrame(result["resources"], columns=self.orders.get_columns())], ignore_index=True
             )
-            page_token = result.get('nextPageToken')
+            page_token = result.get("nextPageToken")
             if not page_token:
                 break
 
-        if params['startId'] and params['endId']:
-            start_id = int(params['startId'])
-            end_id = int(params['endId'])
-        elif params['startId']:
-            start_id = int(params['startId'])
+        if params["startId"] and params["endId"]:
+            start_id = int(params["startId"])
+            end_id = int(params["endId"])
+        elif params["startId"]:
+            start_id = int(params["startId"])
             end_id = start_id + 10
-        elif params['endId']:
-            end_id = int(params['endId'])
+        elif params["endId"]:
+            end_id = int(params["endId"])
             start_id = end_id - 10
         else:
-            raise Exception('startId or endId must be specified')
+            raise Exception("startId or endId must be specified")
 
-        orders = orders.drop(orders[(orders['id'] < start_id) | (orders['id'] > end_id)].index)
+        orders = orders.drop(orders[(orders["id"] < start_id) | (orders["id"] > end_id)].index)
 
         return orders
 
@@ -247,22 +242,22 @@ class GoogleContentShoppingHandler(APIHandler):
             DataFrame
         """
         service = self.connect()
-        if params['order_id']:
-            result = service.orders().delete(merchantId=self.merchant_id, orderId=params['order_id']).execute()
+        if params["order_id"]:
+            result = service.orders().delete(merchantId=self.merchant_id, orderId=params["order_id"]).execute()
             return result
         else:
-            df = pd.DataFrame(columns=['orderId', 'status'])
-            if not params['startId']:
-                start_id = int(params['endId']) - 10
-            elif not params['endId']:
-                end_id = int(params['startId']) + 10
+            df = pd.DataFrame(columns=["orderId", "status"])
+            if not params["startId"]:
+                start_id = int(params["endId"]) - 10
+            elif not params["endId"]:
+                end_id = int(params["startId"]) + 10
             else:
-                start_id = int(params['startId'])
-                end_id = int(params['endId'])
+                start_id = int(params["startId"])
+                end_id = int(params["endId"])
 
             for i in range(start_id, end_id):
                 service.orders().delete(merchantId=self.merchant_id, orderId=i).execute()
-                df = pd.concat([df, pd.DataFrame([{'orderId': str(i), 'status': 'deleted'}])], ignore_index=True)
+                df = pd.concat([df, pd.DataFrame([{"orderId": str(i), "status": "deleted"}])], ignore_index=True)
             return df
 
     def get_products(self, params: dict = None) -> DataFrame:
@@ -276,33 +271,32 @@ class GoogleContentShoppingHandler(APIHandler):
         service = self.connect()
         page_token = None
         products = pd.DataFrame(columns=self.products.get_columns())
-        if params['product_id']:
-            result = service.products().get(merchantId=self.merchant_id, productId=params['product_id']).execute()
+        if params["product_id"]:
+            result = service.products().get(merchantId=self.merchant_id, productId=params["product_id"]).execute()
             products = pd.DataFrame(result, columns=self.products.get_columns())
             return products
         while True:
             result = service.products().list(merchantId=self.merchant_id, page_token=page_token).execute()
             products = pd.concat(
-                [products, pd.DataFrame(result['resources'], columns=self.products.get_columns())],
-                ignore_index=True
+                [products, pd.DataFrame(result["resources"], columns=self.products.get_columns())], ignore_index=True
             )
-            page_token = result.get('nextPageToken')
+            page_token = result.get("nextPageToken")
             if not page_token:
                 break
 
-        if params['startId'] and params['endId']:
-            start_id = int(params['startId'])
-            end_id = int(params['endId'])
-        elif params['startId']:
-            start_id = int(params['startId'])
+        if params["startId"] and params["endId"]:
+            start_id = int(params["startId"])
+            end_id = int(params["endId"])
+        elif params["startId"]:
+            start_id = int(params["startId"])
             end_id = start_id + 10
-        elif params['endId']:
-            end_id = int(params['endId'])
+        elif params["endId"]:
+            end_id = int(params["endId"])
             start_id = end_id - 10
         else:
-            raise Exception('startId or endId must be specified')
+            raise Exception("startId or endId must be specified")
 
-        products = products.drop(products[(products['id'] < start_id) | (products['id'] > end_id)].index)
+        products = products.drop(products[(products["id"] < start_id) | (products["id"] > end_id)].index)
 
         return products
 
@@ -314,29 +308,36 @@ class GoogleContentShoppingHandler(APIHandler):
         Returns:
             DataFrame
         """
-        body = {
-            key: value for key, value in params.items() if key in self.products.get_columns()
-        }
+        body = {key: value for key, value in params.items() if key in self.products.get_columns()}
         service = self.connect()
-        if params['product_id']:
-            result = service.products().update(merchantId=self.merchant_id, productId=params['product_id'],
-                                               updateMask=params['updateMask'], body=body).execute()
+        if params["product_id"]:
+            result = (
+                service.products()
+                .update(
+                    merchantId=self.merchant_id,
+                    productId=params["product_id"],
+                    updateMask=params["updateMask"],
+                    body=body,
+                )
+                .execute()
+            )
 
             return result
         else:
-            df = pd.DataFrame(columns=['productId', 'status'])
-            if not params['startId']:
-                start_id = int(params['endId']) - 10
-            elif not params['endId']:
-                end_id = int(params['startId']) + 10
+            df = pd.DataFrame(columns=["productId", "status"])
+            if not params["startId"]:
+                start_id = int(params["endId"]) - 10
+            elif not params["endId"]:
+                end_id = int(params["startId"]) + 10
             else:
-                start_id = int(params['startId'])
-                end_id = int(params['endId'])
+                start_id = int(params["startId"])
+                end_id = int(params["endId"])
 
             for i in range(start_id, end_id):
-                service.products().update(merchantId=self.merchant_id, productId=i,
-                                          updateMask=params['updateMask'], body=body).execute()
-                df = pd.concat([df, pd.DataFrame([{'productId': str(i), 'status': 'updated'}])], ignore_index=True)
+                service.products().update(
+                    merchantId=self.merchant_id, productId=i, updateMask=params["updateMask"], body=body
+                ).execute()
+                df = pd.concat([df, pd.DataFrame([{"productId": str(i), "status": "updated"}])], ignore_index=True)
             return df
 
     def delete_products(self, params: dict = None) -> DataFrame:
@@ -348,26 +349,25 @@ class GoogleContentShoppingHandler(APIHandler):
             DataFrame
         """
         service = self.connect()
-        args = {
-            key: value for key, value in params.items() if key in ['feedId'] and value is not None
-        }
-        if params['product_id']:
-            result = service.products().delete(merchantId=self.merchant_id, productId=params['product_id'],
-                                               **args).execute()
+        args = {key: value for key, value in params.items() if key in ["feedId"] and value is not None}
+        if params["product_id"]:
+            result = (
+                service.products().delete(merchantId=self.merchant_id, productId=params["product_id"], **args).execute()
+            )
             return result
         else:
-            df = pd.DataFrame(columns=['productId', 'status'])
-            if not params['startId']:
-                start_id = int(params['endId']) - 10
-            elif not params['endId']:
-                end_id = int(params['startId']) + 10
+            df = pd.DataFrame(columns=["productId", "status"])
+            if not params["startId"]:
+                start_id = int(params["endId"]) - 10
+            elif not params["endId"]:
+                end_id = int(params["startId"]) + 10
             else:
-                start_id = int(params['startId'])
-                end_id = int(params['endId'])
+                start_id = int(params["startId"])
+                end_id = int(params["endId"])
 
             for i in range(start_id, end_id):
                 service.products().delete(merchantId=self.merchant_id, productId=i, **args).execute()
-                df = pd.concat([df, pd.DataFrame([{'productId': str(i), 'status': 'deleted'}])], ignore_index=True)
+                df = pd.concat([df, pd.DataFrame([{"productId": str(i), "status": "deleted"}])], ignore_index=True)
             return df
 
     def call_application_api(self, method_name: str = None, params: dict = None) -> DataFrame:
@@ -379,19 +379,19 @@ class GoogleContentShoppingHandler(APIHandler):
         Returns:
             DataFrame
         """
-        if method_name == 'get_accounts':
+        if method_name == "get_accounts":
             return self.get_accounts(params)
-        elif method_name == 'delete_accounts':
+        elif method_name == "delete_accounts":
             return self.delete_accounts(params)
-        elif method_name == 'get_orders':
+        elif method_name == "get_orders":
             return self.get_orders(params)
-        elif method_name == 'delete_orders':
+        elif method_name == "delete_orders":
             return self.delete_orders(params)
-        elif method_name == 'get_products':
+        elif method_name == "get_products":
             return self.get_products(params)
-        elif method_name == 'update_products':
+        elif method_name == "update_products":
             return self.update_products(params)
-        elif method_name == 'delete_products':
+        elif method_name == "delete_products":
             return self.delete_products(params)
         else:
-            raise NotImplementedError(f'Unknown method {method_name}')
+            raise NotImplementedError(f"Unknown method {method_name}")

mindsdb/integrations/handlers/google_fit_handler/google_fit_handler.py

@@ -21,37 +21,41 @@ from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,
 )
 
-SCOPES = ['https://www.googleapis.com/auth/fitness.activity.read']
-DATE_FORMAT = '%Y-%m-%d'
+SCOPES = ["https://www.googleapis.com/auth/fitness.activity.read"]
+DATE_FORMAT = "%Y-%m-%d"
 
 logger = log.getLogger(__name__)
 
 
 class GoogleFitHandler(APIHandler):
-
     def __init__(self, name: str = None, **kwargs):
         super().__init__(name)
-        args = kwargs.get('connection_data', {})
+        args = kwargs.get("connection_data", {})
         self.connection_args = {}
         self.credentials_path = None
-        if 'service_account_file' in args:
-            if os.path.isfile(args['service_account_file']) is False:
+        if "service_account_file" in args:
+            if os.path.isfile(args["service_account_file"]) is False:
                 raise Exception("service_account_file must be a path to the credentials.json file")
-            self.credentials_path = args['service_account_file']
-        elif 'service_account_json' in args:
-            self.connection_args = args['service_account_json']
-            if not isinstance(self.connection_args, dict) or (('redirect_uris' not in self.connection_args.keys()) and len(self.connection_args) != 6) or ('redirect_uris' in self.connection_args.keys()) and len(self.connection_args) != 7:
+            self.credentials_path = args["service_account_file"]
+        elif "service_account_json" in args:
+            self.connection_args = args["service_account_json"]
+            if (
+                not isinstance(self.connection_args, dict)
+                or (("redirect_uris" not in self.connection_args.keys()) and len(self.connection_args) != 6)
+                or ("redirect_uris" in self.connection_args.keys())
+                and len(self.connection_args) != 7
+            ):
                 raise Exception("service_account_json has to be a dictionary with all 6 required fields")
-            self.connection_args['redirect_uris'] = ['http://localhost']
-            self.credentials_path = 'mindsdb/integrations/handlers/google_fit_handler/credentials.json'
+            self.connection_args["redirect_uris"] = ["http://localhost"]
+            self.credentials_path = "mindsdb/integrations/handlers/google_fit_handler/credentials.json"
         else:
-            raise Exception('Connection args have to content ether service_account_file or service_account_json')
+            raise Exception("Connection args have to content ether service_account_file or service_account_json")
 
         self.api = None
         self.is_connected = False
 
         aggregated_data = GoogleFitTable(self)
-        self._register_table('aggregated_data', aggregated_data)
+        self._register_table("aggregated_data", aggregated_data)
 
     def connect(self) -> Resource:
         if self.is_connected is True and self.api:
@@ -64,18 +68,19 @@ class GoogleFitHandler(APIHandler):
 
         creds = None
 
-        if os.path.isfile('mindsdb/integrations/handlers/google_fit_handler/token.json'):
-            creds = Credentials.from_authorized_user_file('mindsdb/integrations/handlers/google_fit_handler/token.json', SCOPES)
+        if os.path.isfile("mindsdb/integrations/handlers/google_fit_handler/token.json"):
+            creds = Credentials.from_authorized_user_file(
+                "mindsdb/integrations/handlers/google_fit_handler/token.json", SCOPES
+            )
         if not creds or not creds.valid:
             if creds and creds.expired and creds.refresh_token:
                 creds.refresh(Request())
             else:
-                flow = InstalledAppFlow.from_client_secrets_file(
-                    self.credentials_path, SCOPES)
+                flow = InstalledAppFlow.from_client_secrets_file(self.credentials_path, SCOPES)
                 creds = flow.run_local_server(port=0)
-            with open('mindsdb/integrations/handlers/google_fit_handler/token.json', 'w') as token:
+            with open("mindsdb/integrations/handlers/google_fit_handler/token.json", "w") as token:
                 token.write(creds.to_json())
-        self.api = build('fitness', 'v1', credentials=creds)
+        self.api = build("fitness", "v1", credentials=creds)
 
         self.is_connected = True
         return self.api
@@ -88,7 +93,7 @@ class GoogleFitHandler(APIHandler):
             response.success = True
 
         except Exception as e:
-            logger.error(f'Error connecting to Google Fit API: {e}!')
+            logger.error(f"Error connecting to Google Fit API: {e}!")
             response.error_message = e
 
         self.is_connected = response.success
@@ -96,15 +101,20 @@ class GoogleFitHandler(APIHandler):
 
     def retrieve_data(self, service, startTimeMillis, endTimeMillis, dataSourceId) -> dict:
         try:
-            return service.users().dataset().aggregate(userId="me", body={
-                "aggregateBy": [{
-                    "dataTypeName": "com.google.step_count.delta",
-                    "dataSourceId": dataSourceId
-                }],
-                "bucketByTime": {"durationMillis": 86400000},
-                "startTimeMillis": startTimeMillis,
-                "endTimeMillis": endTimeMillis
-            }).execute()
+            return (
+                service.users()
+                .dataset()
+                .aggregate(
+                    userId="me",
+                    body={
+                        "aggregateBy": [{"dataTypeName": "com.google.step_count.delta", "dataSourceId": dataSourceId}],
+                        "bucketByTime": {"durationMillis": 86400000},
+                        "startTimeMillis": startTimeMillis,
+                        "endTimeMillis": endTimeMillis,
+                    },
+                )
+                .execute()
+            )
         except HttpError:
             raise HttpError
 
@@ -112,7 +122,7 @@ class GoogleFitHandler(APIHandler):
         """Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
-            dict for mongo, api's json etc)
+            api's json etc)
         Returns:
             HandlerResponse
         """
@@ -121,20 +131,26 @@ class GoogleFitHandler(APIHandler):
 
     def get_steps(self, start_time_millis, end_time_millis) -> pd.DataFrame:
         steps = {}
-        steps_data = self.retrieve_data(self.api, start_time_millis, end_time_millis, "derived:com.google.step_count.delta:com.google.android.gms:estimated_steps")
-        for daily_step_data in steps_data['bucket']:
-            local_date = datetime.fromtimestamp(int(daily_step_data['startTimeMillis']) / 1000,
-                                                tz=pytz.timezone(str(get_localzone())))
+        steps_data = self.retrieve_data(
+            self.api,
+            start_time_millis,
+            end_time_millis,
+            "derived:com.google.step_count.delta:com.google.android.gms:estimated_steps",
+        )
+        for daily_step_data in steps_data["bucket"]:
+            local_date = datetime.fromtimestamp(
+                int(daily_step_data["startTimeMillis"]) / 1000, tz=pytz.timezone(str(get_localzone()))
+            )
             local_date_str = local_date.strftime(DATE_FORMAT)
 
-            data_point = daily_step_data['dataset'][0]['point']
+            data_point = daily_step_data["dataset"][0]["point"]
             if data_point:
-                count = data_point[0]['value'][0]['intVal']
-                data_source_id = data_point[0]['originDataSourceId']
-                steps[local_date_str] = {'steps': count, 'originDataSourceId': data_source_id}
+                count = data_point[0]["value"][0]["intVal"]
+                data_source_id = data_point[0]["originDataSourceId"]
+                steps[local_date_str] = {"steps": count, "originDataSourceId": data_source_id}
         ret = pd.DataFrame.from_dict(steps)
         ret = ret.T
-        ret = ret.drop('originDataSourceId', axis=1)
+        ret = ret.drop("originDataSourceId", axis=1)
         ret = ret.reset_index(drop=False)
         return ret
 
@@ -147,7 +163,7 @@ class GoogleFitHandler(APIHandler):
             DataFrame
         """
         self.connect()
-        if method_name == 'get_steps':
-            val = self.get_steps(params['start_time'], params['end_time'])
+        if method_name == "get_steps":
+            val = self.get_steps(params["start_time"], params["end_time"])
             return val
-        raise NotImplementedError('Method name {} not supported by Google Fit Handler'.format(method_name))
+        raise NotImplementedError("Method name {} not supported by Google Fit Handler".format(method_name))