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

mindsdb/integrations/handlers/tdengine_handler/tests/test_tdengine_handler.py

@@ -7,9 +7,9 @@ class TDEngineHandlerTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.kwargs = {
-            "token":'<token_for_cloud>',
-            "url":"********.cloud.tdengine.com",
-            "database":"temp"
+            "token": '<token_for_cloud>',
+            "url": "********.cloud.tdengine.com",
+            "database": "temp"
         }
         cls.handler = TDEngineHandler('test_tdengine_handler', connection_data=cls.kwargs)
 
@@ -18,26 +18,26 @@ class TDEngineHandlerTest(unittest.TestCase):
 
     def test_1_connect(self):
         assert self.handler.connect()
-    
+
     def test_2_create_table(self):
         query = "CREATE Table `hari` USING `temp` (`id`) TAGS (0);"
         result = self.handler.query(query)
-        assert result.type is not RESPONSE_TYPE.ERROR 
+        assert result.type is not RESPONSE_TYPE.ERROR
         pass
 
     def test_3_insert(self):
         query = "INSERT INTO hari  VALUES (NOW, 12);"
         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 hari;"
         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('hari')

mindsdb/integrations/handlers/tidb_handler/tests/test_tidb_handler.py

@@ -1,5 +1,4 @@
 import unittest
-import pandas as pd
 from mindsdb.integrations.handlers.tidb_handler.tidb_handler import TiDBHandler
 
 
@@ -42,4 +41,4 @@ class TiDBHandlerTest(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/timegpt_handler/timegpt_handler.py

@@ -33,7 +33,7 @@ class TimeGPTHandler(BaseMLEngine):
         if mode == 'forecasting':
             assert time_settings["is_timeseries"], "Specify time series settings in your query"
 
-        timegpt_token =  get_api_key('timegpt', using_args, self.engine_storage, strict=True)
+        timegpt_token = get_api_key('timegpt', using_args, self.engine_storage, strict=True)
         timegpt = NixtlaClient(api_key=timegpt_token)
         assert timegpt.validate_api_key(), "Invalid TimeGPT token provided."
 
@@ -64,7 +64,7 @@ class TimeGPTHandler(BaseMLEngine):
             model_args['add_history'] = True
 
         assert isinstance(model_args["level"], list), "`level` must be a list of integers"
-        assert all([isinstance(l, int) for l in model_args["level"]]), "`level` must be a list of integers"
+        assert all([isinstance(level, int) for level in model_args["level"]]), "`level` must be a list of integers"
 
         self.model_storage.json_set("model_args", model_args)  # persist changes to handler folder
 
@@ -73,7 +73,7 @@ class TimeGPTHandler(BaseMLEngine):
         model_args = self.model_storage.json_get("model_args")
         args = args['predict_params']
         prediction_df = self._transform_to_nixtla_df(df, model_args)
-        
+
         timegpt = NixtlaClient(api_key=model_args['token'])
         assert timegpt.validate_api_key(), "Invalid TimeGPT token provided."
 
@@ -122,7 +122,7 @@ class TimeGPTHandler(BaseMLEngine):
         for i, level in enumerate(levels):
             if i == 0:
                 # NOTE: this should be simplified once we refactor the expected time series output within MindsDB
-                results_df['confidence'] = level/100  # we report the highest level as the overall confidence
+                results_df['confidence'] = level / 100  # we report the highest level as the overall confidence
                 results_df['lower'] = forecast_df[f'TimeGPT-lo-{level}']
                 results_df['upper'] = forecast_df[f'TimeGPT-hi-{level}']
             else:
@@ -171,7 +171,7 @@ class TimeGPTHandler(BaseMLEngine):
                 if mindate > pd.to_datetime('1970-01-01T00:00:00') and maxdate < pd.to_datetime('2050-12-31T23:59:59'):
                     unit = u
             df[date_column] = pd.to_datetime(df[date_column], unit=unit, origin='unix')
-        else: 
+        else:
             df[date_column] = pd.to_datetime(df[date_column])
         df[date_column] = df[date_column].dt.strftime('%Y-%m-%dT%H:%M:%S')  # convert to ISO 8601 format
         df[date_column] = pd.to_datetime(df[date_column])

mindsdb/integrations/handlers/tpot_handler/tpot_handler.py

@@ -1,4 +1,3 @@
-from typing import Optional
 import dill
 import pandas as pd
 from mindsdb.integrations.libs.base import BaseMLEngine
@@ -10,32 +9,30 @@ from sklearn.preprocessing import LabelEncoder
 
 class TPOTHandler(BaseMLEngine):
     name = "TPOT"
+
     def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
         if args is None:
             args = {}
-        type_of_cols=infer_types(df,0).dtypes
-        target_dtype=type_of_cols[target]
-
+        type_of_cols = infer_types(df, 0).dtypes
+        target_dtype = type_of_cols[target]
 
-        if target_dtype in ['binary','categorical','tags']:
+        if target_dtype in ['binary', 'categorical', 'tags']:
             model = TPOTClassifier(generations=args.get('generations', 10),
-                                       population_size=args.get('population_size', 100),
-                                       verbosity=0,
-                                       max_time_mins=args.get('max_time_mins', None),
-                                       n_jobs=args.get('n_jobs', -1))
-            
+                                   population_size=args.get('population_size', 100),
+                                   verbosity=0,
+                                   max_time_mins=args.get('max_time_mins', None),
+                                   n_jobs=args.get('n_jobs', -1))
 
-        elif target_dtype in ['integer','float','quantity'] :
+        elif target_dtype in ['integer', 'float', 'quantity']:
             model = TPOTRegressor(generations=args.get('generations', 10),
-                                      population_size=args.get('population_size', 100),
-                                      verbosity=0,
-                                      max_time_mins=args.get('max_time_mins', None),
-                                      n_jobs=args.get('n_jobs', -1))
-        
+                                  population_size=args.get('population_size', 100),
+                                  verbosity=0,
+                                  max_time_mins=args.get('max_time_mins', None),
+                                  n_jobs=args.get('n_jobs', -1))
 
         if df is not None:
             # Separate out the categorical and non-categorical columns
-            categorical_cols=[col for col, type_col in type_of_cols.items() if type_col in ('categorical', 'binary')]
+            categorical_cols = [col for col, type_col in type_of_cols.items() if type_col in ('categorical', 'binary')]
 
             # Fit a LabelEncoder for each categorical column and store it in a dictionary
             le_dict = {}
@@ -47,30 +44,28 @@ class TPOTHandler(BaseMLEngine):
                 # Encode the categorical column using the fitted LabelEncoder
                 df[col] = le.transform(df[col])
 
-
             model.fit(df.drop(columns=[target]), df[target])
             self.model_storage.json_set('args', args)
             self.model_storage.file_set('le_dict', dill.dumps(le_dict))
             self.model_storage.file_set('model', dill.dumps(model.fitted_pipeline_))
-        else :
+        else:
             raise Exception(
                 "Data is empty!!"
             )
-        
 
     def predict(self, df: pd.DataFrame, args: Optional[Dict] = None) -> pd.DataFrame:
 
-        model=dill.loads(self.model_storage.file_get("model"))
-        le_dict=dill.loads(self.model_storage.file_get("le_dict"))
-        target=self.model_storage.json_get('args').get("target")
+        model = dill.loads(self.model_storage.file_get("model"))
+        le_dict = dill.loads(self.model_storage.file_get("le_dict"))
+        target = self.model_storage.json_get('args').get("target")
 
-         # Encode the categorical columns in the input DataFrame using the saved LabelEncoders
+        # Encode the categorical columns in the input DataFrame using the saved LabelEncoders
         for col, le in le_dict.items():
             if col in df.columns:
                 df[col] = le.transform(df[col])
-                
+
         # Make predictions using the trained TPOT model
-        results=pd.DataFrame(model.predict(df),columns=[target])
+        results = pd.DataFrame(model.predict(df), columns=[target])
 
         # Decode the predicted categorical values back into their original values
         for col, le in le_dict.items():

mindsdb/integrations/handlers/trino_handler/trino_handler.py

@@ -1,9 +1,9 @@
 import re
 from typing import Dict
 import pandas as pd
-from pyhive import (trino, sqlalchemy_trino)
+from pyhive import sqlalchemy_trino
 from mindsdb_sql_parser import parse_sql, ASTNode
-from trino.auth import KerberosAuthentication, BasicAuthentication
+from trino.auth import BasicAuthentication
 from trino.dbapi import connect
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb.integrations.libs.base import DatabaseHandler
@@ -13,10 +13,10 @@ from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,
     RESPONSE_TYPE
 )
-from .trino_config_provider import TrinoConfigProvider
 
 logger = log.getLogger(__name__)
 
+
 class TrinoHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the Trino statements
@@ -59,24 +59,24 @@ class TrinoHandler(DatabaseHandler):
             return self.connection
 
         # option configuration
-        http_scheme='http'
-        auth=None
-        auth_config=None
-        password=None
+        http_scheme = 'http'
+        auth = None
+        auth_config = None
+        password = None
 
         if 'auth' in self.connection_data:
-            auth=self.connection_data['auth']
+            auth = self.connection_data['auth']
         if 'password' in self.connection_data:
-            password=self.connection_data['password']
+            password = self.connection_data['password']
         if 'http_scheme' in self.connection_data:
-           http_scheme=self.connection_data['http_scheme']
+            http_scheme = self.connection_data['http_scheme']
         if 'with' in self.connection_data:
-           self.with_clause=self.connection_data['with']
+            self.with_clause = self.connection_data['with']
 
-        if password and auth=='kerberos':
+        if password and auth == 'kerberos':
             raise Exception("Kerberos authorization doesn't support password.")
         elif password:
-            auth_config=BasicAuthentication(self.connection_data['user'], password)
+            auth_config = BasicAuthentication(self.connection_data['user'], password)
 
         if auth:
             conn = connect(
@@ -159,7 +159,7 @@ class TrinoHandler(DatabaseHandler):
         renderer = SqlalchemyRender(sqlalchemy_trino.TrinoDialect)
         query_str = renderer.get_string(query, with_failback=True)
         modified_query_str = re.sub(
-            "(?is)(CREATE.+TABLE.+\(.*\))",
+            r"(?is)(CREATE.+TABLE.+\(.*\))",
             f"\\1 {self.with_clause}",
             query_str
         )

mindsdb/integrations/handlers/twitter_handler/twitter_handler.py

@@ -1,10 +1,8 @@
 import re
 import os
 import datetime as dt
-import ast
 import time
 from collections import defaultdict
-import pytz
 import io
 import requests
 
@@ -28,6 +26,7 @@ from mindsdb.integrations.libs.response import (
 
 logger = log.getLogger(__name__)
 
+
 class TweetsTable(APITable):
 
     def select(self, query: ast.Select) -> Response:
@@ -39,7 +38,7 @@ class TweetsTable(APITable):
         for op, arg1, arg2 in conditions:
 
             if op == 'or':
-                raise NotImplementedError(f'OR is not supported')
+                raise NotImplementedError('OR is not supported')
             if arg1 == 'created_at':
                 date = parse_utc_date(arg2)
                 if op == '>':
@@ -170,7 +169,6 @@ class TweetsTable(APITable):
 
                 media_ids = [media.media_id]
 
-
             words = re.split('( )', text)
 
             messages = []

mindsdb/integrations/handlers/unify_handler/tests/test_unify_handler.py

@@ -1,20 +1,19 @@
 import os
 import pytest
-import pandas as pd
 
 from mindsdb_sql_parser import parse_sql
 
 from tests.unit.executor_test_base import BaseExecutorTest
 
+
 class TestUnify(BaseExecutorTest):
-    
+
     def run_sql(self, sql):
         ret = self.command_executor.execute_command(parse_sql(sql))
         assert ret.error_code is None
         if ret.data is not None:
             return ret.data.to_df()
 
-
     """
     Integration tests for the Unify handler.
     """
@@ -25,20 +24,20 @@ class TestUnify(BaseExecutorTest):
         """
         super().setup_method()
         self.run_sql("create database proj")
-    
+
     @pytest.mark.skipif(os.environ.get('UNIFY_API_KEY') is None, reason='Missing API key!')
     def test_unify_correct_flow(self):
         self.run_sql(
-        f"""
+            f"""
         CREATE ML_ENGINE unify_engine
         FROM unify
         USING
             unify_api_key = '{os.environ.get('UNIFY_API_KEY')}';
         """
         )
-        
+
         self.run_sql(
-        f"""
+            """
         CREATE MODEL proj.test_unify_correct_flow
         PREDICT output
         USING
@@ -51,7 +50,7 @@ class TestUnify(BaseExecutorTest):
         self.wait_predictor("proj", "test_unify_correct_flow")
 
         result_df = self.run_sql(
-        """
+            """
             SELECT text, output
             FROM proj.test_unify_correct_flow
             WHERE text = 'Hello';

mindsdb/integrations/handlers/unify_handler/unify_handler.py

@@ -12,6 +12,7 @@ from mindsdb.integrations.utilities.handler_utils import get_api_key
 
 logger = log.getLogger(__name__)
 
+
 class UnifyHandler(BaseMLEngine):
     """
     Integration with the Unifyai Python Library
@@ -26,9 +27,8 @@ class UnifyHandler(BaseMLEngine):
         self.model_storage.json_set('args', args)
 
     def predict(self, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
-        
+
         args = self.model_storage.json_get('args')
-        
 
         input_keys = list(args.keys())
 
@@ -41,7 +41,7 @@ class UnifyHandler(BaseMLEngine):
         if 'provider' not in args['using']:
             raise Exception("Unify requires a provider parameter in the USING clause! Refer to its documentation for more details.")
         provider = args['using']['provider']
-        
+
         self.endpoint = model + '@' + provider
         self.api_key = get_api_key('unify', args["using"], self.engine_storage, strict=False)
         available_endpoints = unify.utils.list_endpoints(api_key=self.api_key)
@@ -51,15 +51,15 @@ class UnifyHandler(BaseMLEngine):
         question_column = args['using']['column']
         if question_column not in df.columns:
             raise RuntimeError(f'Column "{question_column}" not found in input data')
-        
-        result_df = pd.DataFrame() 
-        result_df['predictions'] = df[question_column].apply(self.predict_answer)     
+
+        result_df = pd.DataFrame()
+        result_df['predictions'] = df[question_column].apply(self.predict_answer)
         result_df = result_df.rename(columns={'predictions': args['target']})
-        
+
         return result_df
-    
+
     def predict_answer(self, text):
-        
+
         client = unify.Unify(self.endpoint, api_key=self.api_key)
 
         response = client.generate(text)

mindsdb/integrations/handlers/vertex_handler/requirements.txt

@@ -1 +1,2 @@
 google-cloud-aiplatform>=1.35.0
+-r mindsdb/integrations/utilities/handlers/auth_utilities/google/requirements.txt

mindsdb/integrations/handlers/vertex_handler/vertex_client.py

@@ -2,7 +2,7 @@ from mindsdb.utilities import log
 from google.cloud.aiplatform import init, TabularDataset, Model, Endpoint
 import pandas as pd
 
-from mindsdb.integrations.utilities.handlers.auth_utilities import GoogleServiceAccountOAuth2Manager
+from mindsdb.integrations.utilities.handlers.auth_utilities.google import GoogleServiceAccountOAuth2Manager
 
 logger = log.getLogger(__name__)
 

mindsdb/integrations/handlers/vertica_handler/tests/test_vertica_handler.py

@@ -8,14 +8,14 @@ class VerticaHandlerTest(unittest.TestCase):
     def setUpClass(cls):
         cls.kwargs = {
             "connection_data": {
-                "host":'127.0.0.1',
-                "port":5433,
-                "user":'dbadmin',
-                "password":'',
-                "database":'VMart',
-                "schema_name":'public'
+                "host": '127.0.0.1',
+                "port": 5433,
+                "user": 'dbadmin',
+                "password": '',
+                "database": 'VMart',
+                "schema_name": 'public'
             }
-    
+
         }
         cls.handler = VerticaHandler('test_vertica_handler', cls.kwargs)
 
@@ -24,21 +24,21 @@ class VerticaHandlerTest(unittest.TestCase):
 
     def test_1_connect(self):
         assert self.handler.connect()
-    
+
     def test_2_create_table(self):
         query = "CREATE Table TEST(id Number(1),Name Varchar(33))"
         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 TEST (1,'lOVe yOU)"
         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 TEST;"
         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()

mindsdb/integrations/handlers/vertica_handler/vertica_handler.py

@@ -30,7 +30,7 @@ class VerticaHandler(DatabaseHandler):
 
     def __init__(self, name, connection_data: Optional[dict], **kwargs):
         super().__init__(name)
-        
+
         self.parser = parse_sql
         self.dialect = 'vertica'
         self.kwargs = kwargs
@@ -40,7 +40,6 @@ class VerticaHandler(DatabaseHandler):
         self.connection = None
         self.is_connected = False
 
-
     def connect(self):
         if self.is_connected is True:
             return self.connection
@@ -66,7 +65,7 @@ class VerticaHandler(DatabaseHandler):
         return
 
     def check_connection(self) -> StatusResponse:
-       
+
         result = StatusResponse(False)
         need_to_close = self.is_connected is False
 
@@ -96,10 +95,10 @@ class VerticaHandler(DatabaseHandler):
         connection = self.connect()
         with connection.cursor() as cur:
             try:
-                e=cur.execute(query)
+                e = cur.execute(query)
                 result = e.fetchall()
                 if e.rowcount != -1:
-                    
+
                     response = Response(
                         RESPONSE_TYPE.TABLE,
                         pd.DataFrame(
@@ -135,26 +134,24 @@ class VerticaHandler(DatabaseHandler):
         """
         Get a list with all of the tabels in VERTICA
         """
-        q = f'''SELECT 
+        q = f'''SELECT
         TABLE_NAME,
         TABLE_SCHEMA
-        from v_catalog.tables 
-        WHERE table_schema='{self.schema_name}' 
+        from v_catalog.tables
+        WHERE table_schema='{self.schema_name}'
         order by
         table_name;'''
 
-         
         return self.native_query(q)
 
     def get_columns(self, table_name) -> Response:
         """
         Show details about the table
         """
-        q = f'''SELECT 
-        column_name , 
-        data_type 
-        FROM v_catalog.columns 
+        q = f'''SELECT
+        column_name ,
+        data_type
+        FROM v_catalog.columns
         WHERE table_name='{table_name}';'''
 
-        
         return self.native_query(q)

mindsdb/integrations/handlers/vitess_handler/tests/test_vitess_handler.py

@@ -2,13 +2,14 @@ import unittest
 from mindsdb.integrations.handlers.vitess_handler.vitess_handler import VitessHandler
 from mindsdb.integrations.libs.response import RESPONSE_TYPE
 
+
 class VitessHandlerTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.kwargs = {
             "connection_data": {
                 "host": "localhost",
-                "port": 33577 ,
+                "port": 33577,
                 "user": "root",
                 "password": "",
                 "database": "vitess",
@@ -21,36 +22,33 @@ class VitessHandlerTest(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/vitess_handler/vitess_handler.py

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

mindsdb/integrations/handlers/web_handler/web_handler.py

@@ -83,6 +83,7 @@ class WebHandler(APIHandler):
     """
     Web handler, handling crawling content from websites.
     """
+
     def __init__(self, name=None, **kwargs):
         super().__init__(name)
         crawler = CrawlerTable(self)

mindsdb/integrations/handlers/whatsapp_handler/__init__.py

@@ -10,7 +10,7 @@ try:
 except Exception as e:
     Handler = None
     import_error = e
-    
+
 title = 'WhatsApp'
 name = 'whatsapp'
 type = HANDLER_TYPE.DATA
@@ -21,8 +21,8 @@ __all__ = [
     'version',
     'name',
     'type',
-    'title', 
+    'title',
     'description',
     'import_error',
     'icon_path'
-]
+]

mindsdb/integrations/handlers/writer_handler/evaluate.py

@@ -359,4 +359,4 @@ class WriterEvaluator:
         elif self.args.evaluation_type == "e2e":
             return self.evaluate_e2e()
         else:
-            raise ValueError(f"evaluation_type must be either 'retrieval' or 'e2e'")
+            raise ValueError("evaluation_type must be either 'retrieval' or 'e2e'")

mindsdb/integrations/handlers/writer_handler/settings.py

@@ -2,7 +2,6 @@ from typing import List, Union
 from pydantic import BaseModel, Extra, field_validator
 
 from mindsdb.integrations.handlers.rag_handler.settings import (
-    DEFAULT_EMBEDDINGS_MODEL,
     RAGBaseParameters,
 )
 from langchain_core.callbacks import StreamingStdOutCallbackHandler

mindsdb/integrations/handlers/writer_handler/writer_handler.py

@@ -22,6 +22,7 @@ from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
 
+
 def extract_llm_params(args):
     """extract llm params from input query args"""
 

mindsdb/integrations/handlers/youtube_handler/requirements.txt

@@ -1,2 +1,3 @@
 google-api-python-client
 youtube-transcript-api
+-r mindsdb/integrations/utilities/handlers/auth_utilities/google/requirements.txt