MindsDB 25.4.5.0__py3-none-any.whl → 25.5.4.0__py3-none-any.whl

mindsdb/integrations/handlers/sqreamdb_handler/sqreamdb_handler.py

@@ -14,15 +14,14 @@ from mindsdb.integrations.libs.response import (
 import pandas as pd
 import pysqream as db
 
-from pysqream_sqlalchemy.dialect import SqreamDialect 
+from pysqream_sqlalchemy.dialect import SqreamDialect
 
 logger = log.getLogger(__name__)
 
 
 class SQreamDBHandler(DatabaseHandler):
 
-
-    name= 'sqreamdb'
+    name = 'sqreamdb'
 
     def __init__(self, name: str, connection_data: Optional[dict], **kwargs):
         """ Initialize the handler
@@ -32,34 +31,30 @@ class SQreamDBHandler(DatabaseHandler):
             **kwargs: arbitrary keyword arguments.
         """
         super().__init__(name)
-        
-        
+
         self.connection_data = connection_data
 
         self.connection = None
         self.is_connected = False
-          
- 
+
     def connect(self):
         """
         Handles the connection to a YugabyteSQL database insance.
         """
         if self.is_connected is True:
             return self.connection
-        
-        args={
+
+        args = {
             "database": self.connection_data.get('database'),
             "host": self.connection_data.get('host'),
             "port": self.connection_data.get('port'),
             "username": self.connection_data.get('user'),
             "password": self.connection_data.get('password'),
-            "clustered":self.connection_data.get('clustered',False),
-            "use_ssl":self.connection_data.get('use_ssl',False), 
-            "service":self.connection_data.get('service','sqream')
+            "clustered": self.connection_data.get('clustered', False),
+            "use_ssl": self.connection_data.get('use_ssl', False),
+            "service": self.connection_data.get('service', 'sqream')
         }
 
-
-
         connection = db.connect(**args)
 
         self.is_connected = True
@@ -103,9 +98,9 @@ class SQreamDBHandler(DatabaseHandler):
         with conn.cursor() as cur:
             try:
                 cur.execute(query)
-                   
-                if cur.rowcount >0 and query.upper().startswith('SELECT') :
-                    result = cur.fetchall() 
+
+                if cur.rowcount > 0 and query.upper().startswith('SELECT'):
+                    result = cur.fetchall()
                     response = Response(
                         RESPONSE_TYPE.TABLE,
                         data_frame=pd.DataFrame(
@@ -139,7 +134,7 @@ class SQreamDBHandler(DatabaseHandler):
 
     def get_tables(self) -> Response:
         """
-        List all tables in SQreamDB stored in 'sqream_catalog' 
+        List all tables in SQreamDB stored in 'sqream_catalog'
         """
 
         query = "SELECT table_name FROM sqream_catalog.tables"
@@ -147,8 +142,8 @@ class SQreamDBHandler(DatabaseHandler):
         return self.query(query)
 
     def get_columns(self, table_name):
-        query = f"""SELECT column_name, type_name 
-        FROM sqream_catalog.columns 
+        query = f"""SELECT column_name, type_name
+        FROM sqream_catalog.columns
         WHERE table_name = '{table_name}';
         """
         return self.query(query)

mindsdb/integrations/handlers/sqreamdb_handler/tests/test_sqreamdb_handler.py

@@ -31,15 +31,15 @@ class SQreamDBHandlerTest(unittest.TestCase):
     def test_3_get_tables(self):
         tables = self.handler.get_tables()
         assert tables.type is not RESPONSE_TYPE.ERROR
- 
+
     def test_4_select_query(self):
         query = "SELECT * FROM AUTHORS"
         result = self.handler.native_query(query)
         assert result.type is RESPONSE_TYPE.TABLE
 
     def test_5_check_connection(self):
-         self.handler.check_connection()
+        self.handler.check_connection()
+
 
-        
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

mindsdb/integrations/handlers/stabilityai_handler/__init__.py

@@ -16,4 +16,4 @@ permanent = False
 
 __all__ = [
     'Handler', 'version', 'name', 'type', 'title', 'description', 'import_error', 'icon_path'
-]
+]

mindsdb/integrations/handlers/starrocks_handler/starrocks_handler.py

@@ -15,7 +15,6 @@ class StarRocksHandler(MysqlHandler):
         super().__init__(name, **kwargs)
 
 
-
 connection_args = OrderedDict(
     user={
         'type': ARG_TYPE.STR,

mindsdb/integrations/handlers/starrocks_handler/tests/test_starrocks_handler.py

@@ -2,6 +2,7 @@ import unittest
 from mindsdb.integrations.handlers.starrocks_handler.starrocks_handler import StarRocksHandler
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
 
+
 class StarRocksHandlerTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -21,36 +22,33 @@ class StarRocksHandlerTest(unittest.TestCase):
 
     def test_1_connect(self):
         assert self.handler.connect()
-    
+
     def test_2_create_table(self):
         query = "CREATE Table IF NOT EXISTS Lover(name varchar(101));"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_3_insert(self):
         query = "INSERT INTO LOVER VALUES('Shiv Shakti');"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
 
     def test_4_native_query_select(self):
         query = "SELECT * FROM LOVER;"
         result = self.handler.query(query)
-        assert result.type is RESPONSE_TYPE.TABLE 
+        assert result.type is RESPONSE_TYPE.TABLE
 
     def test_5_get_tables(self):
         tables = self.handler.get_tables()
-        assert tables.type is  RESPONSE_TYPE.TABLE
+        assert tables.type is RESPONSE_TYPE.TABLE
 
     def test_6_get_columns(self):
         columns = self.handler.get_columns('LOVER')
-        
+
         query = "DROP Table IF  EXISTS Lover;"
-        result = self.handler.query(query)
+        self.handler.query(query)
         assert columns.type is not RESPONSE_TYPE.ERROR
 
 
 if __name__ == '__main__':
     unittest.main()
-
-
-    

mindsdb/integrations/handlers/statsforecast_handler/statsforecast_handler.py

@@ -99,7 +99,7 @@ class StatsForecastHandler(BaseMLEngine):
         time_settings = args["timeseries_settings"]
         using_args = args["using"]
         assert time_settings["is_timeseries"], "Specify time series settings in your query"
-        ###### store model args and time series settings in the model folder
+        # store model args and time series settings in the model folder
         model_args = {}
         model_args.update(using_args)
         model_args["target"] = target
@@ -130,7 +130,7 @@ class StatsForecastHandler(BaseMLEngine):
         sf = StatsForecast([model], freq=model_args["frequency"], df=training_df)
         fitted_models = sf.fit().fitted_
 
-        ###### persist changes to handler folder
+        # persist changes to handler folder
         self.model_storage.json_set("model_args", model_args)
         self.model_storage.file_set("training_df", dill.dumps(training_df))
         self.model_storage.file_set("fitted_models", dill.dumps(fitted_models))

mindsdb/integrations/handlers/strava_handler/strava_handler.py

@@ -7,9 +7,6 @@ from mindsdb.integrations.libs.response import (
 from mindsdb.utilities import log
 from mindsdb_sql_parser import parse_sql
 
-import requests
-import pandas as pd
-import json
 from collections import OrderedDict
 from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
 
@@ -17,6 +14,7 @@ from stravalib.client import Client
 
 logger = log.getLogger(__name__)
 
+
 class StravaHandler(APIHandler):
     """Strava handler implementation"""
 
@@ -39,7 +37,7 @@ class StravaHandler(APIHandler):
 
         strava_all_clubs_data = StravaAllClubsTable(self)
         self._register_table("all_clubs", strava_all_clubs_data)
-        
+
         strava_club_activites_data = StravaClubActivitesTable(self)
         self._register_table("club_activities", strava_club_activites_data)
 
@@ -54,7 +52,6 @@ class StravaHandler(APIHandler):
             return self.connection
 
         client = Client()
-        url = client.authorization_url(client_id=self.connection_data['strava_client_id'], redirect_uri='http://127.0.0.1:5000/authorization')
         client.access_token = self.connection_data['strava_access_token']
         self.connection = client
 
@@ -68,7 +65,6 @@ class StravaHandler(APIHandler):
             Status confirmation
         """
         response = StatusResponse(False)
-        need_to_close = self.is_connected is False
 
         try:
             self.connect()
@@ -108,6 +104,6 @@ connection_args = OrderedDict(
 )
 
 connection_args_example = OrderedDict(
-    strava_client_id ='<your-strava-client_id>',
-    strava_access_token ='<your-strava-api-token>'
+    strava_client_id='<your-strava-client_id>',
+    strava_access_token='<your-strava-api-token>'
 )

mindsdb/integrations/handlers/strava_handler/strava_tables.py

@@ -8,12 +8,10 @@ from mindsdb.utilities import log
 
 from mindsdb_sql_parser import ast
 
-import requests
-import pandas as pd
-import json
 
 logger = log.getLogger(__name__)
 
+
 class StravaAllClubsTable(APITable):
     """Strava List all Clubs Table implementation"""
 
@@ -32,7 +30,6 @@ class StravaAllClubsTable(APITable):
         ValueError
             If the query contains an unsupported condition
         """
-        conditions = extract_comparison_conditions(query.where)
 
         order_by_conditions = {}
 
@@ -42,7 +39,7 @@ class StravaAllClubsTable(APITable):
 
             for an_order in query.order_by:
                 if an_order.field.parts[0] != "id":
-                    next    
+                    next
                 if an_order.field.parts[1] in self.get_columns():
                     order_by_conditions["columns"].append(an_order.field.parts[1])
 
@@ -66,7 +63,6 @@ class StravaAllClubsTable(APITable):
             else:
                 raise ValueError(f"Unknown query target {type(target)}")
 
-
         if len(strava_clubs_df) == 0:
             strava_clubs_df = pd.DataFrame([], columns=selected_columns)
         else:
@@ -93,24 +89,24 @@ class StravaAllClubsTable(APITable):
             List of columns
         """
         return [
-        'id',
-        'name',
-        'sport_type',
-        'city',
-        'state',
-        'country',
-        'member_count',
+            'id',
+            'name',
+            'sport_type',
+            'city',
+            'state',
+            'country',
+            'member_count',
         ]
 
     def call_strava_allclubs_api(self):
         """Pulls all the records from the given and returns it select()
-    
+
         Returns
         -------
         pd.DataFrame of all the records of the "List Athlete Clubs" API end point
         """
 
-        clubs = self.handler.connect().get_athlete_clubs() 
+        clubs = self.handler.connect().get_athlete_clubs()
 
         club_cols = self.get_columns()
         data = []
@@ -153,7 +149,7 @@ class StravaClubActivitesTable(APITable):
 
             for an_order in query.order_by:
                 if an_order.field.parts[0] != "id":
-                    next    
+                    next
                 if an_order.field.parts[1] in self.get_columns():
                     order_by_conditions["columns"].append(an_order.field.parts[1])
 
@@ -165,7 +161,7 @@ class StravaClubActivitesTable(APITable):
                     raise ValueError(
                         f"Order by unknown column {an_order.field.parts[1]}"
                     )
-        
+
         for a_where in conditions:
             if a_where[1] == "strava_club_id":
                 if a_where[0] != "=":
@@ -174,7 +170,6 @@ class StravaClubActivitesTable(APITable):
             else:
                 raise ValueError(f"Unsupported where argument {a_where[1]}")
 
-
         strava_club_activities_df = self.call_strava_clubactivities_api(a_where[2])
 
         selected_columns = []
@@ -187,7 +182,6 @@ class StravaClubActivitesTable(APITable):
             else:
                 raise ValueError(f"Unknown query target {type(target)}")
 
-
         if len(strava_club_activities_df) == 0:
             strava_club_activities_df = pd.DataFrame([], columns=selected_columns)
         else:
@@ -214,18 +208,18 @@ class StravaClubActivitesTable(APITable):
             List of columns
         """
         return [
-        'name',
-        'distance',
-        'moving_time',	
-        'elapsed_time',
-        'total_elevation_gain',
-        'sport_type',
-        'athlete.firstname',
+            'name',
+            'distance',
+            'moving_time',
+            'elapsed_time',
+            'total_elevation_gain',
+            'sport_type',
+            'athlete.firstname',
         ]
 
-    def call_strava_clubactivities_api(self,club_id):
+    def call_strava_clubactivities_api(self, club_id):
         """Pulls all the records from the given and returns it select()
-    
+
         Returns
         -------
         pd.DataFrame of all the records of the "getClubActivitiesById" API end point
@@ -243,5 +237,3 @@ class StravaClubActivitesTable(APITable):
         all_strava_club_activities_df = pd.DataFrame(data, columns=club_cols)
 
         return all_strava_club_activities_df
-
-

mindsdb/integrations/handlers/stripe_handler/stripe_handler.py

@@ -10,6 +10,7 @@ from mindsdb_sql_parser import parse_sql
 
 logger = log.getLogger(__name__)
 
+
 class StripeHandler(APIHandler):
     """
     The Stripe handler implementation.
@@ -41,7 +42,7 @@ class StripeHandler(APIHandler):
 
         payment_intents_data = PaymentIntentsTable(self)
         self._register_table("payment_intents", payment_intents_data)
-        
+
         payouts_data = PayoutsTable(self)
         self._register_table("payouts", payouts_data)
 
@@ -80,7 +81,7 @@ class StripeHandler(APIHandler):
             stripe.Account.retrieve()
             response.success = True
         except Exception as e:
-            logger.error(f'Error connecting to Stripe!')
+            logger.error('Error connecting to Stripe!')
             response.error_message = str(e)
 
         self.is_connected = response.success

mindsdb/integrations/handlers/stripe_handler/stripe_tables.py

@@ -1,17 +1,11 @@
 import pandas as pd
-
 import stripe
 from typing import Text, List, Dict, Any
-from mindsdb_sql_parser import ast
-from mindsdb.integrations.libs.api_handler import APITable
-from mindsdb.integrations.utilities.handlers.query_utilities import INSERTQueryParser, DELETEQueryParser, UPDATEQueryParser, DELETEQueryExecutor, UPDATEQueryExecutor
 
 from mindsdb_sql_parser import ast
 from mindsdb.integrations.libs.api_handler import APITable
-
+from mindsdb.integrations.utilities.handlers.query_utilities import INSERTQueryParser, DELETEQueryParser, UPDATEQueryParser, DELETEQueryExecutor, UPDATEQueryExecutor
 from mindsdb.integrations.utilities.handlers.query_utilities.select_query_utilities import SELECTQueryParser, SELECTQueryExecutor
-
-
 from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
@@ -235,7 +229,7 @@ class ProductsTable(APITable):
 
 class PaymentIntentsTable(APITable):
     """The Stripe Payment Intents Table implementation"""
-    
+
     def select(self, query: ast.Select) -> pd.DataFrame:
         """
         Pulls Stripe Payment Intents data.
@@ -273,6 +267,7 @@ class PaymentIntentsTable(APITable):
         payment_intents_df = select_statement_executor.execute_query()
 
         return payment_intents_df
+
     def delete(self, query: ast.Delete) -> None:
         """
         Cancels Stripe Payment Intents and updates the local data.
@@ -307,22 +302,21 @@ class PaymentIntentsTable(APITable):
         payment_intent_ids = canceled_payment_intents_df['id'].tolist()
         self.cancel_payment_intents(payment_intent_ids)
 
-        
         self.payment_intents_df = self.payment_intents_df[~self.payment_intents_df['id'].isin(payment_intent_ids)]
 
     def cancel_payment_intents(self, payment_intent_ids: List[str]) -> None:
         stripe = self.handler.connect()
         for payment_intent_id in payment_intent_ids:
             try:
-              
+
                 payment_intent = stripe.PaymentIntent.retrieve(payment_intent_id)
                 if payment_intent.status in ['requires_payment_method', 'requires_capture', 'requires_confirmation', 'requires_action', 'processing']:
                     stripe.PaymentIntent.cancel(payment_intent_id)
                 else:
-                     logger.warning(f"Payment intent {payment_intent_id} is in status {payment_intent.status} and cannot be canceled.")
+                    logger.warning(f"Payment intent {payment_intent_id} is in status {payment_intent.status} and cannot be canceled.")
             except stripe.error.StripeError as e:
                 logger.error(f"Error cancelling payment intent {payment_intent_id}: {str(e)}")
-                
+
     def update(self, query: 'ast.Update') -> None:
         """
         Updates data in Stripe "POST /v1/payment_intents/:id" API endpoint.
@@ -358,16 +352,6 @@ class PaymentIntentsTable(APITable):
         for payment_intent_id in payment_intent_ids:
             stripe.PaymentIntent.modify(payment_intent_id, **values_to_update)
 
-
-    def get_columns(self) -> List[Text]:
-        return pd.json_normalize(self.get_payment_intents(limit=1)).columns.tolist()
-
-    def get_payment_intents(self, **kwargs) -> List[Dict]:
-        payment_intents = stripe.PaymentIntent.list(**kwargs)
-        return [payment_intent for payment_intent in payment_intents.data]
-
-    
-    
     def insert(self, query: 'ast.Insert') -> None:
         """
         Inserts data into Stripe "POST /v1/payment_intents" API endpoint.
@@ -398,7 +382,7 @@ class PaymentIntentsTable(APITable):
     def create_payment_intent(self, payment_intent_data: list) -> None:
         for data in payment_intent_data:
             stripe.PaymentIntent.create(**data)
-        
+
     def get_columns(self) -> List[Text]:
         return pd.json_normalize(self.get_payment_intents(limit=1)).columns.tolist()
 
@@ -407,7 +391,7 @@ class PaymentIntentsTable(APITable):
         payment_intents = stripe.PaymentIntent.list(**kwargs)
         return [payment_intent.to_dict() for payment_intent in payment_intents]
 
-      
+
 class RefundsTable(APITable):
     """The Stripe Refund Table implementation"""
 
@@ -455,9 +439,9 @@ class RefundsTable(APITable):
     def get_refunds(self, **kwargs) -> List[Dict]:
         stripe = self.handler.connect()
         refunds = stripe.Refund.list(**kwargs)
-        return [refund.to_dict() for refund in refunds ]
-     
-    
+        return [refund.to_dict() for refund in refunds]
+
+
 class PayoutsTable(APITable):
     """The Stripe Payouts Table implementation"""
 

mindsdb/integrations/handlers/supabase_handler/tests/test_supabase_handler.py

@@ -43,4 +43,4 @@ class SupabaseHandlerTest(unittest.TestCase):
 
     def test_7_select_query(self):
         query = "SELECT * FROM dt_test WHERE 'id'='a'"
-        result = self.handler.native_query(query)
+        self.handler.native_query(query)

mindsdb/integrations/handlers/surrealdb_handler/surrealdb_handler.py

@@ -1,4 +1,7 @@
 from typing import Optional
+import pysurrealdb as surreal
+import pandas as pd
+
 from mindsdb_sql_parser.ast.base import ASTNode
 from mindsdb.integrations.libs.base import DatabaseHandler
 from mindsdb.utilities import log
@@ -8,10 +11,7 @@ from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,
     RESPONSE_TYPE
 )
-from .utils.surreal_get_info import *
-
-import pysurrealdb as surreal
-import pandas as pd
+from .utils.surreal_get_info import table_names, column_info
 
 
 logger = log.getLogger(__name__)

mindsdb/integrations/handlers/tdengine_handler/tdengine_handler.py

@@ -18,6 +18,7 @@ from mindsdb.integrations.libs.response import (
 
 logger = log.getLogger(__name__)
 
+
 class TDEngineHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the TDEngine statements.
@@ -27,7 +28,7 @@ class TDEngineHandler(DatabaseHandler):
 
     def __init__(self, name, connection_data: Optional[dict], **kwargs):
         super().__init__(name)
-        
+
         self.parser = parse_sql
         self.dialect = 'tdengine'
         self.kwargs = kwargs
@@ -36,7 +37,6 @@ class TDEngineHandler(DatabaseHandler):
         self.connection = None
         self.is_connected = False
 
-
     def connect(self):
         if self.is_connected is True:
             return self.connection
@@ -44,8 +44,8 @@ class TDEngineHandler(DatabaseHandler):
         config = {
             'url': self.connection_data.get('url', "http://localhost:6041"),
             'token': self.connection_data.get('token'),
-            'user': self.connection_data.get('user','root'),
-            'password': self.connection_data.get('password','taosdata'),
+            'user': self.connection_data.get('user', 'root'),
+            'password': self.connection_data.get('password', 'taosdata'),
             'database': self.connection_data.get('database')
         }
 
@@ -62,7 +62,7 @@ class TDEngineHandler(DatabaseHandler):
         return
 
     def check_connection(self) -> StatusResponse:
-       
+
         result = StatusResponse(False)
         need_to_close = self.is_connected is False
 
@@ -90,29 +90,29 @@ class TDEngineHandler(DatabaseHandler):
         need_to_close = self.is_connected is False
 
         connection = self.connect()
-        cur = connection.cursor() 
+        cur = connection.cursor()
         try:
-                cur.execute(query)
-                
-                if cur.rowcount != 0:
-                    result = cur.fetchall()
-                    response = Response(
-                        RESPONSE_TYPE.TABLE,
-                        pd.DataFrame(
-                            result,
-                            columns=[x[0] for x in cur.description]
-                        )
-                    )
-                else:
-                    response = Response(RESPONSE_TYPE.OK)
-                connection.commit()
-        except Exception as e:
-                logger.error(f'Error running query: {query} on {self.connection_data["database"]}!')
+            cur.execute(query)
+
+            if cur.rowcount != 0:
+                result = cur.fetchall()
                 response = Response(
-                    RESPONSE_TYPE.ERROR,
-                    error_message=str(e)
+                    RESPONSE_TYPE.TABLE,
+                    pd.DataFrame(
+                        result,
+                        columns=[x[0] for x in cur.description]
+                    )
                 )
-                # connection.rollback()
+            else:
+                response = Response(RESPONSE_TYPE.OK)
+            connection.commit()
+        except Exception as e:
+            logger.error(f'Error running query: {query} on {self.connection_data["database"]}!')
+            response = Response(
+                RESPONSE_TYPE.ERROR,
+                error_message=str(e)
+            )
+            # connection.rollback()
         cur.close()
         if need_to_close is True:
             self.disconnect()
@@ -133,7 +133,6 @@ class TDEngineHandler(DatabaseHandler):
         """
         q = 'SHOW TABLES;'
 
-         
         return self.native_query(q)
 
     def get_columns(self, table_name) -> Response:
@@ -142,5 +141,4 @@ class TDEngineHandler(DatabaseHandler):
         """
         q = f'DESCRIBE {table_name};'
 
-        
         return self.native_query(q)