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

mindsdb/integrations/handlers/derby_handler/derby_handler.py

@@ -6,7 +6,7 @@ from mindsdb_sql_parser import parse_sql
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 import pandas as pd
 import jaydebeapi as jdbcconnector
@@ -15,11 +15,10 @@ logger = log.getLogger(__name__)
 
 
 class DerbyHandler(DatabaseHandler):
-
-    name = 'derby'
+    name = "derby"
 
     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
@@ -29,16 +28,16 @@ class DerbyHandler(DatabaseHandler):
 
         self.kwargs = kwargs
         self.parser = parse_sql
-        self.database = connection_data['database']
+        self.database = connection_data["database"]
         self.connection_config = connection_data
-        self.host = connection_data['host']
-        self.port = connection_data['port']
-        self.schema = 'APP'
+        self.host = connection_data["host"]
+        self.port = connection_data["port"]
+        self.schema = "APP"
         self.connection = None
         self.is_connected = False
 
     def connect(self):
-        """ Set up any connections required by the handler
+        """Set up any connections required by the handler
         Should return output of check_connection() method after attempting
         connection. Should switch self.is_connected.
         Returns:
@@ -47,10 +46,10 @@ class DerbyHandler(DatabaseHandler):
         if self.is_connected is True:
             return self.connection
 
-        user = self.connection_config.get('user')
-        password = self.connection_config.get('password')
-        jdbc_class = self.connection_config.get('jdbcClass')
-        jar_location = self.connection_config.get('jdbcJarLocation')
+        user = self.connection_config.get("user")
+        password = self.connection_config.get("password")
+        jdbc_class = self.connection_config.get("jdbcClass")
+        jar_location = self.connection_config.get("jdbcJarLocation")
 
         jdbc_url = "jdbc:derby://" + self.host + ":" + self.port + "/" + self.database + ";"
 
@@ -62,11 +61,17 @@ class DerbyHandler(DatabaseHandler):
 
         try:
             if user and password and jar_location:
-                self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password], jars=jar_location.split(","))
+                self.connection = jdbcconnector.connect(
+                    jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password], jars=jar_location.split(",")
+                )
             elif user and password:
-                self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password])
+                self.connection = jdbcconnector.connect(
+                    jclassname=jdbc_class, url=jdbc_url, driver_args=[user, password]
+                )
             elif jar_location:
-                self.connection = jdbcconnector.connect(jclassname=jdbc_class, url=jdbc_url, jars=jar_location.split(","))
+                self.connection = jdbcconnector.connect(
+                    jclassname=jdbc_class, url=jdbc_url, jars=jar_location.split(",")
+                )
             else:
                 self.connection = jdbcconnector.connect(jdbc_class, jdbc_url)
         except Exception as e:
@@ -75,7 +80,7 @@ class DerbyHandler(DatabaseHandler):
         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:
@@ -89,7 +94,7 @@ class DerbyHandler(DatabaseHandler):
         return
 
     def check_connection(self) -> StatusResponse:
-        """ Check connection to the handler
+        """Check connection to the handler
         Returns:
             HandlerStatusResponse
         """
@@ -100,7 +105,7 @@ class DerbyHandler(DatabaseHandler):
             self.connect()
             responseCode.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}!")
             responseCode.error_message = str(e)
         finally:
             if responseCode.success is True and need_to_close:
@@ -114,7 +119,7 @@ class DerbyHandler(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
         """
@@ -126,21 +131,14 @@ class DerbyHandler(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:
@@ -173,12 +171,12 @@ class DerbyHandler(DatabaseHandler):
         Returns:
             Response: Names of the tables in the database.
         """
-        query = f'''
-        SELECT st.tablename FROM sys.systables st LEFT OUTER JOIN sys.sysschemas ss ON (st.schemaid = ss.schemaid) WHERE ss.schemaname ='{self.schema}' '''
+        query = f"""
+        SELECT st.tablename FROM sys.systables st LEFT OUTER JOIN sys.sysschemas ss ON (st.schemaid = ss.schemaid) WHERE ss.schemaname ='{self.schema}' """
 
         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) -> StatusResponse:
@@ -191,5 +189,5 @@ class DerbyHandler(DatabaseHandler):
             Response: Details of the table.
         """
 
-        query = f''' SELECT COLUMNNAME FROM SYS.SYSCOLUMNS INNER JOIN SYS.SYSTABLES ON SYS.SYSCOLUMNS.REFERENCEID=SYS.SYSTABLES.TABLEID WHERE TABLENAME='{table_name}' '''
+        query = f""" SELECT COLUMNNAME FROM SYS.SYSCOLUMNS INNER JOIN SYS.SYSTABLES ON SYS.SYSCOLUMNS.REFERENCEID=SYS.SYSTABLES.TABLEID WHERE TABLENAME='{table_name}' """
         return self.native_query(query)

mindsdb/integrations/handlers/documentdb_handler/requirements.txt

@@ -0,0 +1 @@
+-r mindsdb/integrations/handlers/mongodb_handler/requirements.txt

mindsdb/integrations/handlers/dummy_data_handler/dummy_data_handler.py

@@ -11,22 +11,22 @@ from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 
 
 class DummyHandler(DatabaseHandler):
-    name = 'dummy_data'
+    name = "dummy_data"
 
     def __init__(self, **kwargs):
-        super().__init__('dummy_data')
+        super().__init__("dummy_data")
         self.db_path = None
 
-        args = kwargs.get('connection_data', {})
-        if 'db_path' in args:
-            self.db_path = args['db_path']
+        args = kwargs.get("connection_data", {})
+        if "db_path" in args:
+            self.db_path = args["db_path"]
 
     def connect(self):
         """Set up any connections required by the handler"""
         return self.db_path is not None
 
     def disconnect(self):
-        """ Close any existing connections"""
+        """Close any existing connections"""
         return
 
     def check_connection(self) -> HandlerStatusResponse:
@@ -41,7 +41,7 @@ class DummyHandler(DatabaseHandler):
         """Receive raw query and act upon it somehow
 
         Args:
-            query (Any): query in native format (str for sql databases, dict for mongo, etc)
+            query (Any): query in native format (str for sql databases, etc)
             params (Optional[List])
 
         Returns:
@@ -49,7 +49,7 @@ class DummyHandler(DatabaseHandler):
         """
         con = duckdb.connect(self.db_path)
         if params is not None:
-            query = query.replace('%s', '?')
+            query = query.replace("%s", "?")
             cur = con.executemany(query, params)
             if cur.rowcount >= 0:
                 result_df = cur.fetchdf()
@@ -71,7 +71,7 @@ class DummyHandler(DatabaseHandler):
         Returns:
             HandlerResponse
         """
-        renderer = SqlalchemyRender('postgres')
+        renderer = SqlalchemyRender("postgres")
         query_str, params = renderer.get_exec_params(query, with_failback=True)
         return self.native_query(query_str, params)
 
@@ -81,10 +81,10 @@ class DummyHandler(DatabaseHandler):
         Returns:
             HandlerResponse: Names of the tables in the database
         """
-        q = 'SHOW TABLES;'
+        q = "SHOW TABLES;"
         result = self.native_query(q)
         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) -> HandlerResponse:
@@ -96,11 +96,10 @@ class DummyHandler(DatabaseHandler):
         Returns:
             HandlerResponse: Details of the table.
         """
-        query = f'DESCRIBE {table_name};'
+        query = f"DESCRIBE {table_name};"
         return self.native_query(query)
 
     def subscribe(self, stop_event, callback, table_name, columns=None, **kwargs):
-
         while True:
             if stop_event.is_set():
                 return

mindsdb/integrations/handlers/google_books_handler/google_books_handler.py

@@ -19,9 +19,10 @@ logger = log.getLogger(__name__)
 
 class GoogleBooksHandler(APIHandler):
     """
-        A class for handling connections and interactions with the Google Books API.
+    A class for handling connections and interactions with the Google Books API.
     """
-    name = 'google_books'
+
+    name = "google_books"
 
     def __init__(self, name: str, **kwargs):
         """
@@ -33,18 +34,18 @@ class GoogleBooksHandler(APIHandler):
         super().__init__(name)
         self.token = None
         self.service = None
-        self.connection_data = kwargs.get('connection_data', {})
-        self.credentials_file = self.connection_data.get('credentials', None)
+        self.connection_data = kwargs.get("connection_data", {})
+        self.credentials_file = self.connection_data.get("credentials", None)
         self.credentials = None
-        self.scopes = ['https://www.googleapis.com/auth/books']
+        self.scopes = ["https://www.googleapis.com/auth/books"]
         self.is_connected = False
         self.connection = None
         bookshelves = BookshelvesTable(self)
         self.bookshelves = bookshelves
-        self._register_table('bookshelves', bookshelves)
+        self._register_table("bookshelves", bookshelves)
         volumes = VolumesTable(self)
         self.volumes = volumes
-        self._register_table('volumes', volumes)
+        self._register_table("volumes", volumes)
 
     def connect(self):
         """
@@ -58,18 +59,19 @@ class GoogleBooksHandler(APIHandler):
         if self.is_connected is True:
             return self.service
         if self.credentials_file:
-            if os.path.exists('token_books.json'):
-                self.credentials = Credentials.from_authorized_user_file('token_books.json', self.scopes)
+            if os.path.exists("token_books.json"):
+                self.credentials = Credentials.from_authorized_user_file("token_books.json", self.scopes)
             if not self.credentials or not self.credentials.valid:
                 if self.credentials and self.credentials.expired and self.credentials.refresh_token:
                     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
-            with open('token_books.json', 'w') as token:
+            with open("token_books.json", "w") as token:
                 token.write(self.credentials.to_json())
-            self.service = build('books', 'v1', credentials=self.credentials)
+            self.service = build("books", "v1", credentials=self.credentials)
         return self.service
 
     def check_connection(self) -> StatusResponse:
@@ -85,7 +87,7 @@ class GoogleBooksHandler(APIHandler):
             self.connect()
             response.success = True
         except Exception as e:
-            logger.error(f'Error connecting to Google Books API: {e}!')
+            logger.error(f"Error connecting to Google Books API: {e}!")
             response.error_message = e
 
         self.is_connected = response.success
@@ -96,7 +98,7 @@ class GoogleBooksHandler(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
         """
@@ -104,10 +106,7 @@ class GoogleBooksHandler(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_bookshelves(self, params: dict = None) -> DataFrame:
         """
@@ -120,35 +119,39 @@ class GoogleBooksHandler(APIHandler):
         service = self.connect()
         minShelf = None
         maxShelf = None
-        if params['shelf']:
-            shelf = int(params['shelf'])
-            if params['source']:
-                df = service.mylibrary().bookshelves().get(shelf=shelf, userid=params['userid'],
-                                                           source=params['source']).execute()
+        if params["shelf"]:
+            shelf = int(params["shelf"])
+            if params["source"]:
+                df = (
+                    service.mylibrary()
+                    .bookshelves()
+                    .get(shelf=shelf, userid=params["userid"], source=params["source"])
+                    .execute()
+                )
             else:
-                df = service.mylibrary().bookshelves().get(shelf=shelf, userid=params['userid']).execute()
+                df = service.mylibrary().bookshelves().get(shelf=shelf, userid=params["userid"]).execute()
 
             df = pd.DataFrame(df, columns=self.bookshelves.get_columns())
             return df
-        elif not params['minShelf'] and params['maxShelf']:
-            minShelf = int(params['maxShelf']) - 10
-            maxShelf = int(params['maxShelf'])
-        elif not params['maxShelf'] and params['minShelf']:
-            minShelf = int(params['minShelf'])
-            maxShelf = int(params['minShelf']) + 10
-        elif params['maxShelf'] and params['minShelf']:
-            minShelf = int(params['minShelf'])
-            maxShelf = int(params['maxShelf'])
+        elif not params["minShelf"] and params["maxShelf"]:
+            minShelf = int(params["maxShelf"]) - 10
+            maxShelf = int(params["maxShelf"])
+        elif not params["maxShelf"] and params["minShelf"]:
+            minShelf = int(params["minShelf"])
+            maxShelf = int(params["minShelf"]) + 10
+        elif params["maxShelf"] and params["minShelf"]:
+            minShelf = int(params["minShelf"])
+            maxShelf = int(params["maxShelf"])
 
         args = {
-            key: value for key, value in params.items() if key not in ['minShelf', 'maxShelf'] and value is not None
+            key: value for key, value in params.items() if key not in ["minShelf", "maxShelf"] and value is not None
         }
-        bookshelves = service.bookshelves().list(userid=params['userid'], **args).execute()
+        bookshelves = service.bookshelves().list(userid=params["userid"], **args).execute()
 
-        df = pd.DataFrame(bookshelves['items'], columns=self.bookshelves.get_columns())
+        df = pd.DataFrame(bookshelves["items"], columns=self.bookshelves.get_columns())
         if minShelf is not None or maxShelf is not None:
             # Drop bookshelves that are not in the id range
-            df = df.drop(df[(df['id'] < minShelf) | (df['id'] > maxShelf)].index)
+            df = df.drop(df[(df["id"] < minShelf) | (df["id"] > maxShelf)].index)
 
         return df
 
@@ -161,11 +164,9 @@ class GoogleBooksHandler(APIHandler):
             DataFrame
         """
         service = self.connect()
-        args = {
-            key: value for key, value in params.items() if value is not None
-        }
+        args = {key: value for key, value in params.items() if value is not None}
         volumes = service.volumes().list(**args).execute()
-        df = pd.DataFrame(volumes['items'], columns=self.volumes.get_columns())
+        df = pd.DataFrame(volumes["items"], columns=self.volumes.get_columns())
         return df
 
     def call_application_api(self, method_name: str = None, params: dict = None) -> DataFrame:
@@ -177,9 +178,9 @@ class GoogleBooksHandler(APIHandler):
         Returns:
             DataFrame
         """
-        if method_name == 'get_bookshelves':
+        if method_name == "get_bookshelves":
             return self.get_bookshelves(params)
-        elif method_name == 'get_volumes':
+        elif method_name == "get_volumes":
             return self.get_volumes(params)
         else:
-            raise NotImplementedError(f'Unknown method {method_name}')
+            raise NotImplementedError(f"Unknown method {method_name}")