MindsDB 25.8.2.0__py3-none-any.whl → 25.9.1.0__py3-none-any.whl

mindsdb/integrations/handlers/google_search_handler/google_search_handler.py

@@ -19,9 +19,10 @@ logger = log.getLogger(__name__)
 
 class GoogleSearchConsoleHandler(APIHandler):
     """
-        A class for handling connections and interactions with the Google Search Console API.
+    A class for handling connections and interactions with the Google Search Console API.
     """
-    name = 'google_search'
+
+    name = "google_search"
 
     def __init__(self, name: str, **kwargs):
         """
@@ -33,19 +34,21 @@ class GoogleSearchConsoleHandler(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.connection_data = kwargs.get("connection_data", {})
+        self.fs_storage = kwargs["file_storage"]
+        self.credentials_file = self.connection_data.get("credentials", None)
         self.credentials = None
-        self.scopes = ['https://www.googleapis.com/auth/webmasters.readonly',
-                       'https://www.googleapis.com/auth/webmasters']
+        self.scopes = [
+            "https://www.googleapis.com/auth/webmasters.readonly",
+            "https://www.googleapis.com/auth/webmasters",
+        ]
         self.is_connected = False
         analytics = SearchAnalyticsTable(self)
         self.analytics = analytics
-        self._register_table('Analytics', analytics)
+        self._register_table("Analytics", analytics)
         sitemaps = SiteMapsTable(self)
         self.sitemaps = sitemaps
-        self._register_table('Sitemaps', sitemaps)
+        self._register_table("Sitemaps", sitemaps)
 
     def connect(self):
         """
@@ -59,7 +62,7 @@ class GoogleSearchConsoleHandler(APIHandler):
             return self.service
         if self.credentials_file:
             try:
-                json_str_bytes = self.fs_storage.file_get('token_search.json')
+                json_str_bytes = self.fs_storage.file_get("token_search.json")
                 json_str = json_str_bytes.decode()
                 self.credentials = Credentials.from_authorized_user_info(info=json.loads(json_str), scopes=self.scopes)
             except Exception:
@@ -69,13 +72,12 @@ class GoogleSearchConsoleHandler(APIHandler):
                 if self.credentials and self.credentials.expired and self.credentials.refresh_token:
                     self.credentials.refresh(Request())
                 else:
-                    self.credentials = Credentials.from_authorized_user_file(
-                        self.credentials_file, scopes=self.scopes)
+                    self.credentials = Credentials.from_authorized_user_file(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_search.json', json_str.encode())
+            self.fs_storage.file_set("token_search.json", json_str.encode())
 
-            self.service = build('webmasters', 'v3', credentials=self.credentials)
+            self.service = build("webmasters", "v3", credentials=self.credentials)
         return self.service
 
     def check_connection(self) -> StatusResponse:
@@ -90,7 +92,7 @@ class GoogleSearchConsoleHandler(APIHandler):
             self.connect()
             response.success = True
         except Exception as e:
-            logger.error(f'Error connecting to Google Search Console API: {e}!')
+            logger.error(f"Error connecting to Google Search Console API: {e}!")
             response.error_message = e
 
         self.is_connected = response.success
@@ -101,7 +103,7 @@ class GoogleSearchConsoleHandler(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
         """
@@ -109,10 +111,7 @@ class GoogleSearchConsoleHandler(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_traffic_data(self, params: dict = None) -> DataFrame:
         """
@@ -123,14 +122,14 @@ class GoogleSearchConsoleHandler(APIHandler):
             DataFrame
         """
         service = self.connect()
-        accepted_params = ['start_date', 'end_date', 'dimensions', 'row_limit', 'aggregation_type']
+        accepted_params = ["start_date", "end_date", "dimensions", "row_limit", "aggregation_type"]
         search_analytics_query_request = {
             key: value for key, value in params.items() if key in accepted_params and value is not None
         }
-        response = service.searchanalytics(). \
-            query(siteUrl=params['siteUrl'], body=search_analytics_query_request). \
-            execute()
-        df = pd.DataFrame(response['rows'], columns=self.analytics.get_columns())
+        response = (
+            service.searchanalytics().query(siteUrl=params["siteUrl"], body=search_analytics_query_request).execute()
+        )
+        df = pd.DataFrame(response["rows"], columns=self.analytics.get_columns())
         return df
 
     def get_sitemaps(self, params: dict = None) -> DataFrame:
@@ -142,18 +141,18 @@ class GoogleSearchConsoleHandler(APIHandler):
             DataFrame
         """
         service = self.connect()
-        if params['sitemapIndex']:
-            response = service.sitemaps().list(siteUrl=params['siteUrl'], sitemapIndex=params['sitemapIndex']).execute()
+        if params["sitemapIndex"]:
+            response = service.sitemaps().list(siteUrl=params["siteUrl"], sitemapIndex=params["sitemapIndex"]).execute()
         else:
-            response = service.sitemaps().list(siteUrl=params['siteUrl']).execute()
-        df = pd.DataFrame(response['sitemap'], columns=self.sitemaps.get_columns())
+            response = service.sitemaps().list(siteUrl=params["siteUrl"]).execute()
+        df = pd.DataFrame(response["sitemap"], columns=self.sitemaps.get_columns())
 
         # Get as many sitemaps as indicated by the row_limit parameter
-        if params['row_limit']:
-            if params['row_limit'] > len(df):
+        if params["row_limit"]:
+            if params["row_limit"] > len(df):
                 row_limit = len(df)
             else:
-                row_limit = params['row_limit']
+                row_limit = params["row_limit"]
 
             df = df[:row_limit]
 
@@ -168,7 +167,7 @@ class GoogleSearchConsoleHandler(APIHandler):
             DataFrame
         """
         service = self.connect()
-        response = service.sitemaps().submit(siteUrl=params['siteUrl'], feedpath=params['feedpath']).execute()
+        response = service.sitemaps().submit(siteUrl=params["siteUrl"], feedpath=params["feedpath"]).execute()
         df = pd.DataFrame(response, columns=self.sitemaps.get_columns())
         return df
 
@@ -181,7 +180,7 @@ class GoogleSearchConsoleHandler(APIHandler):
             DataFrame
         """
         service = self.connect()
-        response = service.sitemaps().delete(siteUrl=params['siteUrl'], feedpath=params['feedpath']).execute()
+        response = service.sitemaps().delete(siteUrl=params["siteUrl"], feedpath=params["feedpath"]).execute()
         df = pd.DataFrame(response, columns=self.sitemaps.get_columns())
         return df
 
@@ -194,13 +193,13 @@ class GoogleSearchConsoleHandler(APIHandler):
         Returns:
             DataFrame
         """
-        if method_name == 'get_traffic_data':
+        if method_name == "get_traffic_data":
             return self.get_traffic_data(params)
-        elif method_name == 'get_sitemaps':
+        elif method_name == "get_sitemaps":
             return self.get_sitemaps(params)
-        elif method_name == 'submit_sitemap':
+        elif method_name == "submit_sitemap":
             return self.submit_sitemap(params)
-        elif method_name == 'delete_sitemap':
+        elif method_name == "delete_sitemap":
             return self.delete_sitemap(params)
         else:
-            raise NotImplementedError(f'Unknown method {method_name}')
+            raise NotImplementedError(f"Unknown method {method_name}")

mindsdb/integrations/handlers/informix_handler/informix_handler.py

@@ -21,7 +21,6 @@ logger = log.getLogger(__name__)
 
 
 class InformixHandler(DatabaseHandler):
-
     name = "informix"
 
     def __init__(self, name: str, connection_data: Optional[dict], **kwargs):
@@ -35,11 +34,7 @@ class InformixHandler(DatabaseHandler):
 
         self.kwargs = kwargs
         self.parser = parse_sql
-        self.loging_enabled = (
-            connection_data["loging_enabled"]
-            if "loging_enabled" in connection_data
-            else True
-        )
+        self.loging_enabled = connection_data["loging_enabled"] if "loging_enabled" in connection_data else True
         self.server = connection_data["server"]
         self.database = connection_data["database"]
         self.user = connection_data["user"]
@@ -47,9 +42,7 @@ class InformixHandler(DatabaseHandler):
         self.schemaName = connection_data["schema_name"]
         self.host = connection_data["host"]
         self.port = connection_data["port"]
-        self.connString = (
-            "SERVER={0};" "DATABASE={1};" "HOST={2};" "PORT={3};" "UID={4};" "PWD={5};"
-        ).format(
+        self.connString = ("SERVER={0};DATABASE={1};HOST={2};PORT={3};UID={4};PWD={5};").format(
             self.server, self.database, self.host, self.port, self.user, self.password
         )
 
@@ -115,7 +108,7 @@ class InformixHandler(DatabaseHandler):
         """Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
-                dict for mongo, etc)
+                etc)
         Returns:
             HandlerResponse
         """
@@ -129,9 +122,7 @@ class InformixHandler(DatabaseHandler):
                 result = cur.fetchall()
                 response = Response(
                     RESPONSE_TYPE.TABLE,
-                    data_frame=pd.DataFrame(
-                        result, columns=[x[0] for x in cur.description]
-                    ),
+                    data_frame=pd.DataFrame(result, columns=[x[0] for x in cur.description]),
                 )
             else:
                 response = Response(RESPONSE_TYPE.OK)
@@ -179,11 +170,7 @@ class InformixHandler(DatabaseHandler):
                 response = Response(
                     RESPONSE_TYPE.TABLE,
                     data_frame=pd.DataFrame(
-                        [
-                            x["TABLE_NAME"]
-                            for x in result
-                            if x["TABLE_SCHEM"] == self.schemaName
-                        ],
+                        [x["TABLE_NAME"] for x in result if x["TABLE_SCHEM"] == self.schemaName],
                         columns=["TABLE_NAME"],
                     ),
                 )

mindsdb/integrations/handlers/maxdb_handler/maxdb_handler.py

@@ -9,7 +9,8 @@ from mindsdb.utilities import log
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE, HandlerResponse
+    RESPONSE_TYPE,
+    HandlerResponse,
 )
 import pandas as pd
 import jaydebeapi as jd
@@ -19,13 +20,13 @@ logger = log.getLogger(__name__)
 
 class MaxDBHandler(DatabaseHandler):
     """
-       This handler handles connection and execution of the SAP MaxDB  statements.
-       """
+    This handler handles connection and execution of the SAP MaxDB  statements.
+    """
 
-    name = 'maxdb'
+    name = "maxdb"
 
     def __init__(self, name: str, connection_data: Optional[dict], **kwargs):
-        """ Initialize the handler
+        """Initialize the handler
         Args:
             name (str): name of particular handler instance
             connection_data (dict): parameters for connecting to the database
@@ -35,12 +36,12 @@ class MaxDBHandler(DatabaseHandler):
         self.kwargs = kwargs
         self.parser = parse_sql
         self.connection_config = connection_data
-        self.database = connection_data['database']
-        self.host = connection_data['host']
-        self.port = connection_data['port']
-        self.user = connection_data['user']
-        self.password = connection_data['password']
-        self.jdbc_location = connection_data['jdbc_location']
+        self.database = connection_data["database"]
+        self.host = connection_data["host"]
+        self.port = connection_data["port"]
+        self.user = connection_data["user"]
+        self.password = connection_data["password"]
+        self.jdbc_location = connection_data["jdbc_location"]
         self.connection = None
         self.is_connected = False
 
@@ -61,14 +62,14 @@ class MaxDBHandler(DatabaseHandler):
             return self.connection
 
         jdbc_url = f"jdbc:sapdb://{self.host}:{self.port}/{self.database}"
-        jdbc_class = 'com.sap.dbtech.jdbc.DriverSapDB'
+        jdbc_class = "com.sap.dbtech.jdbc.DriverSapDB"
 
         self.connection = jd.connect(jdbc_class, jdbc_url, [self.user, self.password], self.jdbc_location)
         self.is_connected = True
         return self.connection
 
     def disconnect(self):
-        """ Close any existing connections
+        """Close any existing connections
         Should switch self.is_connected.
         """
         if self.is_connected is False:
@@ -82,7 +83,7 @@ class MaxDBHandler(DatabaseHandler):
         return
 
     def check_connection(self) -> StatusResponse:
-        """ Check connection to the handler
+        """Check connection to the handler
         Returns:
             HandlerStatusResponse
         """
@@ -93,7 +94,7 @@ class MaxDBHandler(DatabaseHandler):
             self.connect()
             response.success = True
         except Exception as e:
-            logger.error(f'Error connecting to database {self.database}, {e}!')
+            logger.error(f"Error connecting to database {self.database}, {e}!")
             response.error_message = str(e)
         finally:
             if response.success is True and need_to_close:
@@ -107,7 +108,7 @@ class MaxDBHandler(DatabaseHandler):
         """Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
-                dict for mongo, etc)
+                etc)
         Returns:
             HandlerResponse
         """
@@ -119,21 +120,14 @@ class MaxDBHandler(DatabaseHandler):
                 if cur.description:
                     result = cur.fetchall()
                     response = Response(
-                        RESPONSE_TYPE.TABLE,
-                        data_frame=pd.DataFrame(
-                            result,
-                            columns=[x[0] for x in cur.description]
-                        )
+                        RESPONSE_TYPE.TABLE, data_frame=pd.DataFrame(result, columns=[x[0] for x in cur.description])
                     )
                 else:
                     response = Response(RESPONSE_TYPE.OK)
                 self.connection.commit()
             except Exception as e:
-                logger.error(f'Error running query: {query} on {self.database}!')
-                response = Response(
-                    RESPONSE_TYPE.ERROR,
-                    error_message=str(e)
-                )
+                logger.error(f"Error running query: {query} on {self.database}!")
+                response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
                 self.connection.rollback()
 
         if need_to_close is True:
@@ -165,7 +159,7 @@ class MaxDBHandler(DatabaseHandler):
         query = f"SELECT TABLENAME FROM DOMAIN.TABLES WHERE TYPE = 'TABLE' AND SCHEMANAME = '{self.user}'"
         result = self.native_query(query)
         df = result.data_frame
-        result.data_frame = df.rename(columns={df.columns[0]: 'table_name'})
+        result.data_frame = df.rename(columns={df.columns[0]: "table_name"})
         return result
 
     def get_columns(self, table_name: str) -> Response:
@@ -182,5 +176,5 @@ class MaxDBHandler(DatabaseHandler):
         query = f"SELECT COLUMNNAME,DATATYPE FROM DOMAIN.COLUMNS WHERE TABLENAME ='{table_name}'"
         result = self.native_query(query)
         df = result.data_frame
-        result.data_frame = df.rename(columns={'name': 'column_name', 'type': 'data_type'})
+        result.data_frame = df.rename(columns={"name": "column_name", "type": "data_type"})
         return self.native_query(query)

mindsdb/integrations/handlers/monetdb_handler/monetdb_handler.py

@@ -35,9 +35,7 @@ class MonetDBHandler(DatabaseHandler):
         self.database = connection_data["database"]
         self.user = connection_data["user"]
         self.password = connection_data["password"]
-        self.schemaName = (
-            connection_data["schema_name"] if "schema_name" in connection_data else None
-        )
+        self.schemaName = connection_data["schema_name"] if "schema_name" in connection_data else None
         self.host = connection_data["host"]
         self.port = connection_data["port"]
 
@@ -109,7 +107,7 @@ class MonetDBHandler(DatabaseHandler):
         """Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
-                dict for mongo, etc)
+                etc)
         Returns:
             HandlerResponse
         """
@@ -123,9 +121,7 @@ class MonetDBHandler(DatabaseHandler):
                 result = cur.fetchall()
                 response = Response(
                     RESPONSE_TYPE.TABLE,
-                    data_frame=pd.DataFrame(
-                        result, columns=[x[0] for x in cur.description]
-                    ),
+                    data_frame=pd.DataFrame(result, columns=[x[0] for x in cur.description]),
                 )
             else:
                 response = Response(RESPONSE_TYPE.OK)

mindsdb/integrations/handlers/mongodb_handler/mongodb_handler.py

@@ -10,13 +10,13 @@ from pymongo import MongoClient
 from pymongo.errors import ServerSelectionTimeoutError, OperationFailure, ConfigurationError, InvalidURI
 from typing import Text, List, Dict, Any, Union
 
-from mindsdb.api.mongo.utilities.mongodb_query import MongoQuery
-from mindsdb.api.mongo.utilities.mongodb_parser import MongodbParser
+from mindsdb.integrations.handlers.mongodb_handler.utils.mongodb_query import MongoQuery
+from mindsdb.integrations.handlers.mongodb_handler.utils.mongodb_parser import MongodbParser
 from mindsdb.integrations.libs.base import DatabaseHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 from mindsdb.utilities import log
 from .utils.mongodb_render import MongodbRender
@@ -31,7 +31,7 @@ class MongoDBHandler(DatabaseHandler):
     """
 
     _SUBSCRIBE_SLEEP_INTERVAL = 0.5
-    name = 'mongodb'
+    name = "mongodb"
 
     def __init__(self, name: Text, **kwargs: Any) -> None:
         """
@@ -42,13 +42,13 @@ class MongoDBHandler(DatabaseHandler):
             kwargs: Arbitrary keyword arguments including the connection data.
         """
         super().__init__(name)
-        connection_data = kwargs['connection_data']
+        connection_data = kwargs["connection_data"]
         self.host = connection_data.get("host")
         self.port = int(connection_data.get("port") or 27017)
         self.user = connection_data.get("username")
         self.password = connection_data.get("password")
-        self.database = connection_data.get('database')
-        self.flatten_level = connection_data.get('flatten_level', 0)
+        self.database = connection_data.get("database")
+        self.flatten_level = connection_data.get("flatten_level", 0)
 
         self.connection = None
         self.is_connected = False
@@ -72,31 +72,27 @@ class MongoDBHandler(DatabaseHandler):
         """
         kwargs = {}
         if isinstance(self.user, str) and len(self.user) > 0:
-            kwargs['username'] = self.user
+            kwargs["username"] = self.user
 
         if isinstance(self.password, str) and len(self.password) > 0:
-            kwargs['password'] = self.password
+            kwargs["password"] = self.password
 
-        if re.match(r'/?.*tls=true', self.host.lower()):
-            kwargs['tls'] = True
+        if re.match(r"/?.*tls=true", self.host.lower()):
+            kwargs["tls"] = True
 
-        if re.match(r'/?.*tls=false', self.host.lower()):
-            kwargs['tls'] = False
+        if re.match(r"/?.*tls=false", self.host.lower()):
+            kwargs["tls"] = False
 
         try:
-            connection = MongoClient(
-                self.host,
-                port=self.port,
-                **kwargs
-            )
+            connection = MongoClient(self.host, port=self.port, **kwargs)
         except InvalidURI as invalid_uri_error:
-            logger.error(f'Invalid URI provided for MongoDB connection: {invalid_uri_error}!')
+            logger.error(f"Invalid URI provided for MongoDB connection: {invalid_uri_error}!")
             raise
         except ConfigurationError as config_error:
-            logger.error(f'Configuration error connecting to MongoDB: {config_error}!')
+            logger.error(f"Configuration error connecting to MongoDB: {config_error}!")
             raise
         except Exception as unknown_error:
-            logger.error(f'Unknown error connecting to MongoDB: {unknown_error}!')
+            logger.error(f"Unknown error connecting to MongoDB: {unknown_error}!")
             raise
 
         # Get the database name from the connection if it's not provided.
@@ -107,7 +103,9 @@ class MongoDBHandler(DatabaseHandler):
         self.connection = connection
         return self.connection
 
-    def subscribe(self, stop_event: threading.Event, callback: callable, table_name: Text, columns: List = None, **kwargs: Any) -> None:
+    def subscribe(
+        self, stop_event: threading.Event, callback: callable, table_name: Text, columns: List = None, **kwargs: Any
+    ) -> None:
         """
         Subscribes to changes in a MongoDB collection and calls the provided callback function when changes occur.
 
@@ -131,26 +129,26 @@ class MongoDBHandler(DatabaseHandler):
                 time.sleep(self._SUBSCRIBE_SLEEP_INTERVAL)
                 continue
 
-            _id = res['documentKey']['_id']
-            if res['operationType'] == 'insert':
+            _id = res["documentKey"]["_id"]
+            if res["operationType"] == "insert":
                 if columns is not None:
-                    updated_columns = set(res['fullDocument'].keys())
+                    updated_columns = set(res["fullDocument"].keys())
                     if not set(columns) & set(updated_columns):
                         # Do nothing.
                         continue
 
-                callback(row=res['fullDocument'], key={'_id': _id})
+                callback(row=res["fullDocument"], key={"_id": _id})
 
-            if res['operationType'] == 'update':
+            if res["operationType"] == "update":
                 if columns is not None:
-                    updated_columns = set(res['updateDescription']['updatedFields'].keys())
+                    updated_columns = set(res["updateDescription"]["updatedFields"].keys())
                     if not set(columns) & set(updated_columns):
                         # Do nothing.
                         continue
 
                 # Get the full document.
-                full_doc = con[self.database][table_name].find_one(res['documentKey'])
-                callback(row=full_doc, key={'_id': _id})
+                full_doc = con[self.database][table_name].find_one(res["documentKey"])
+                callback(row=full_doc, key={"_id": _id})
 
     def disconnect(self) -> None:
         """
@@ -178,14 +176,20 @@ class MongoDBHandler(DatabaseHandler):
 
             # Check if the database exists.
             if self.database not in con.list_database_names():
-                raise ValueError(f'Database {self.database} not found!')
+                raise ValueError(f"Database {self.database} not found!")
 
             response.success = True
-        except (InvalidURI, ServerSelectionTimeoutError, OperationFailure, ConfigurationError, ValueError) as known_error:
-            logger.error(f'Error connecting to MongoDB {self.database}, {known_error}!')
+        except (
+            InvalidURI,
+            ServerSelectionTimeoutError,
+            OperationFailure,
+            ConfigurationError,
+            ValueError,
+        ) as known_error:
+            logger.error(f"Error connecting to MongoDB {self.database}, {known_error}!")
             response.error_message = str(known_error)
         except Exception as unknown_error:
-            logger.error(f'Unknown error connecting to MongoDB {self.database}, {unknown_error}!')
+            logger.error(f"Unknown error connecting to MongoDB {self.database}, {unknown_error}!")
             response.error_message = str(unknown_error)
 
         if response.success and need_to_close:
@@ -211,13 +215,10 @@ class MongoDBHandler(DatabaseHandler):
 
         if isinstance(query, dict):
             # Fallback for the previous API.
-            mquery = MongoQuery(query['collection'])
+            mquery = MongoQuery(query["collection"])
 
-            for c in query['call']:
-                mquery.add_step({
-                    'method': c['method'],
-                    'args': c['args']
-                })
+            for c in query["call"]:
+                mquery.add_step({"method": c["method"], "args": c["args"]})
 
             query = mquery
 
@@ -229,16 +230,15 @@ class MongoDBHandler(DatabaseHandler):
         # Check if the collection exists.
         if collection not in con[database].list_collection_names():
             return Response(
-                RESPONSE_TYPE.ERROR,
-                error_message=f'Collection {collection} not found in database {database}!'
+                RESPONSE_TYPE.ERROR, error_message=f"Collection {collection} not found in database {database}!"
             )
 
         try:
             cursor = con[database][collection]
 
             for step in query.pipeline:
-                fnc = getattr(cursor, step['method'])
-                cursor = fnc(*step['args'])
+                fnc = getattr(cursor, step["method"])
+                cursor = fnc(*step["args"])
 
             result = []
             if not isinstance(cursor, pymongo.results.UpdateResult):
@@ -254,16 +254,10 @@ class MongoDBHandler(DatabaseHandler):
                 columns = list(self.get_columns(collection).data_frame.Field)
                 df = pd.DataFrame([], columns=columns)
 
-            response = Response(
-                RESPONSE_TYPE.TABLE,
-                df
-            )
+            response = Response(RESPONSE_TYPE.TABLE, df)
         except Exception as e:
-            logger.error(f'Error running query: {query} on {self.database}.{collection}!')
-            response = Response(
-                RESPONSE_TYPE.ERROR,
-                error_message=str(e)
-            )
+            logger.error(f"Error running query: {query} on {self.database}.{collection}!")
+            response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
 
         return response
 
@@ -289,7 +283,7 @@ class MongoDBHandler(DatabaseHandler):
             if level > 0:
                 if isinstance(v, dict):
                     for k2, v2 in self.flatten(v, level=level - 1).items():
-                        add[f'{k}.{k2}'] = v2
+                        add[f"{k}.{k2}"] = v2
                     del_keys.append(k)
 
         if add:
@@ -324,15 +318,10 @@ class MongoDBHandler(DatabaseHandler):
         """
         con = self.connect()
         collections = con[self.database].list_collection_names()
-        collections_ar = [
-            [i] for i in collections
-        ]
-        df = pd.DataFrame(collections_ar, columns=['table_name'])
+        collections_ar = [[i] for i in collections]
+        df = pd.DataFrame(collections_ar, columns=["table_name"])
 
-        response = Response(
-            RESPONSE_TYPE.TABLE,
-            df
-        )
+        response = Response(RESPONSE_TYPE.TABLE, df)
 
         return response
 
@@ -363,10 +352,7 @@ class MongoDBHandler(DatabaseHandler):
             for k, v in record.items():
                 data.append([k, type(v).__name__])
 
-        df = pd.DataFrame(data, columns=['Field', 'Type'])
+        df = pd.DataFrame(data, columns=["Field", "Type"])
 
-        response = Response(
-            RESPONSE_TYPE.TABLE,
-            df
-        )
+        response = Response(RESPONSE_TYPE.TABLE, df)
         return response

mindsdb/integrations/handlers/mongodb_handler/requirements.txt

@@ -0,0 +1 @@
+pymongo == 4.8.0