MindsDB 25.8.3.0__py3-none-any.whl → 25.9.1.1__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/lightfm_handler/requirements.txt

@@ -1,2 +1,2 @@
 lightfm==1.17
-dataprep_ml==24.5.1.2
+dataprep_ml==0.0.25

mindsdb/integrations/handlers/lightwood_handler/requirements.txt

@@ -1,4 +1,4 @@
-lightwood>=25.7.5.1
-lightwood[extra]>=25.7.5.1
-lightwood[xai]>=25.7.5.1
-type_infer==0.0.23
+lightwood>=25.9.1.0
+lightwood[extra]>=25.9.1.0
+lightwood[xai]>=25.9.1.0
+type_infer==0.0.25

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)