MindsDB 25.5.3.0__py3-none-any.whl → 25.5.4.1__py3-none-any.whl

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/youtube_handler.py

@@ -14,12 +14,12 @@ from mindsdb.utilities.config import Config
 
 from googleapiclient.discovery import build
 
-from mindsdb.integrations.utilities.handlers.auth_utilities import GoogleUserOAuth2Manager
+from mindsdb.integrations.utilities.handlers.auth_utilities.google import GoogleUserOAuth2Manager
 
 DEFAULT_SCOPES = [
-	'https://www.googleapis.com/auth/youtube',
-	'https://www.googleapis.com/auth/youtube.force-ssl',
-	'https://www.googleapis.com/auth/youtubepartner'
+    'https://www.googleapis.com/auth/youtube',
+    'https://www.googleapis.com/auth/youtube.force-ssl',
+    'https://www.googleapis.com/auth/youtubepartner'
 ]
 
 logger = log.getLogger(__name__)
@@ -81,7 +81,7 @@ class YoutubeHandler(APIHandler):
         """
         if self.is_connected is True:
             return self.connection
-        
+
         google_oauth2_manager = GoogleUserOAuth2Manager(self.handler_storage, self.scopes, self.credentials_file, self.credentials_url, self.connection_data.get('code'))
         creds = google_oauth2_manager.get_oauth2_credentials()
 

mindsdb/integrations/handlers/youtube_handler/youtube_tables.py

@@ -1,7 +1,6 @@
 from typing import List
 
 from mindsdb.integrations.libs.api_handler import APITable
-from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
 from mindsdb.utilities import log
 
 from mindsdb_sql_parser import ast
@@ -61,21 +60,21 @@ class YoutubeCommentsTable(APITable):
 
         if not video_id and not channel_id:
             raise ValueError("Either video_id or channel_id has to be present in where clause.")
-            
+
         comments_df = self.get_comments(video_id=video_id, channel_id=channel_id)
 
         select_statement_executor = SELECTQueryExecutor(
-            comments_df, 
-            selected_columns, 
-            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']], 
-            order_by_conditions, 
+            comments_df,
+            selected_columns,
+            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']],
+            order_by_conditions,
             result_limit if query.limit else None
         )
 
         comments_df = select_statement_executor.execute_query()
 
         return comments_df
-    
+
     def insert(self, query: ast.Insert) -> None:
         """Inserts data into the YouTube POST /commentThreads API endpoint.
 
@@ -93,7 +92,7 @@ class YoutubeCommentsTable(APITable):
         ValueError
             If the query contains an unsupported condition
         """
-        
+
         insert_query_parser = INSERTQueryParser(query, self.get_columns())
 
         values_to_insert = insert_query_parser.parse_query()
@@ -101,13 +100,13 @@ class YoutubeCommentsTable(APITable):
         for value in values_to_insert:
             if not value.get('comment_id'):
                 if not value.get('comment'):
-                    raise ValueError(f"comment is mandatory for inserting a top-level comment.")
+                    raise ValueError("comment is mandatory for inserting a top-level comment.")
                 else:
                     self.insert_comment(video_id=value['video_id'], text=value['comment'])
 
             else:
                 if not value.get('reply'):
-                    raise ValueError(f"reply is mandatory for inserting a reply.")
+                    raise ValueError("reply is mandatory for inserting a reply.")
                 else:
                     self.insert_comment(comment_id=value['comment_id'], text=value['reply'])
 
@@ -178,7 +177,7 @@ class YoutubeCommentsTable(APITable):
                 replies = []
                 if 'replies' in comment:
                     for reply in comment["replies"]["comments"]:
-                        replies.append( 
+                        replies.append(
                             {
                                 "reply_author": reply["snippet"]["authorDisplayName"],
                                 "user_id": reply["snippet"]["authorChannelId"]["value"],
@@ -225,7 +224,7 @@ class YoutubeCommentsTable(APITable):
 
         youtube_comments_df = pd.json_normalize(data, 'replies', ['comment_id', 'channel_id', 'video_id', 'user_id', 'display_name', 'comment', "published_at", "updated_at"], record_prefix='replies.')
         youtube_comments_df = youtube_comments_df.rename(columns={'replies.user_id': 'reply_user_id', 'replies.reply_author': 'reply_author', 'replies.reply': 'reply'})
-        
+
         # check if DataFrame is empty
         if youtube_comments_df.empty:
             return youtube_comments_df
@@ -262,10 +261,10 @@ class YoutubeChannelsTable(APITable):
         channel_df = self.get_channel_details(channel_id)
 
         select_statement_executor = SELECTQueryExecutor(
-            channel_df, 
-            selected_columns, 
-            [where_condition for where_condition in where_conditions if where_condition[1] == 'channel_id'], 
-            order_by_conditions, 
+            channel_df,
+            selected_columns,
+            [where_condition for where_condition in where_conditions if where_condition[1] == 'channel_id'],
+            order_by_conditions,
             result_limit if query.limit else None
         )
 
@@ -325,7 +324,7 @@ class YoutubeVideosTable(APITable):
                     video_id = arg2
                 else:
                     raise NotImplementedError("Only '=' operator is supported for video_id column.")
-                
+
             elif arg1 == "channel_id":
                 if op == "=":
                     channel_id = arg2
@@ -334,24 +333,24 @@ class YoutubeVideosTable(APITable):
 
         if not video_id and not channel_id:
             raise ValueError("Either video_id or channel_id has to be present in where clause.")
-        
+
         if video_id:
             video_df = self.get_videos_by_video_ids([video_id])
         else:
             video_df = self.get_videos_by_channel_id(channel_id)
 
         select_statement_executor = SELECTQueryExecutor(
-            video_df, 
-            selected_columns, 
-            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']], 
-            order_by_conditions, 
+            video_df,
+            selected_columns,
+            [where_condition for where_condition in where_conditions if where_condition[1] not in ['video_id', 'channel_id']],
+            order_by_conditions,
             result_limit if query.limit else None
         )
 
         video_df = select_statement_executor.execute_query()
 
         return video_df
-    
+
     def get_videos_by_channel_id(self, channel_id):
         video_ids = []
         resource = (
@@ -389,7 +388,7 @@ class YoutubeVideosTable(APITable):
         # loop over 50 video ids at a time
         # an invalid request error is caused otherwise
         for i in range(0, len(video_ids), 50):
-            resource = self.handler.connect().videos().list(part="statistics,snippet,contentDetails", id=",".join(video_ids[i:i+50])).execute()
+            resource = self.handler.connect().videos().list(part="statistics,snippet,contentDetails", id=",".join(video_ids[i:i + 50])).execute()
             for item in resource["items"]:
                 data.append(
                     {
@@ -418,15 +417,15 @@ class YoutubeVideosTable(APITable):
         except Exception as e:
             logger.error(f"Encountered an error while fetching transcripts for video ${video_id}: ${e}"),
             return "Transcript not available for this video"
-        
+
     def parse_duration(self, video_id, duration):
         try:
-            parsed_duration = re.search(f"PT(\d+H)?(\d+M)?(\d+S)", duration).groups()
+            parsed_duration = re.search(r"PT(\d+H)?(\d+M)?(\d+S)", duration).groups()
             duration_str = ""
             for d in parsed_duration:
                 if d:
                     duration_str += f"{d[:-1]}:"
-            
+
             return duration_str.strip(":")
         except Exception as e:
             logger.error(f"Encountered an error while parsing duration for video ${video_id}: ${e}"),

mindsdb/integrations/handlers/yugabyte_handler/tests/test_yugabyte_handler.py

@@ -35,7 +35,7 @@ class YugabyteHandlerTest(unittest.TestCase):
     def test_4_get_tables(self):
         tables = self.handler.get_tables()
         assert tables.type is not RESPONSE_TYPE.ERROR
- 
+
     def test_5_select_query(self):
         query = "SELECT * FROM PREM;"
         result = self.handler.native_query(query)
@@ -44,6 +44,6 @@ class YugabyteHandlerTest(unittest.TestCase):
     def test_6_check_connection(self):
         self.handler.check_connection()
 
-        
+
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

mindsdb/integrations/handlers/yugabyte_handler/yugabyte_handler.py

@@ -1,10 +1,4 @@
 from collections import OrderedDict
-from typing import Optional
-
-from mindsdb_sql_parser import parse_sql
-from mindsdb_sql_parser.ast.base import ASTNode
-from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
-from pandas import DataFrame
 
 from mindsdb.integrations.handlers.postgres_handler.postgres_handler import (
     PostgresHandler,

mindsdb/integrations/libs/llm/config.py

@@ -114,3 +114,16 @@ class GoogleConfig(BaseLLMConfig):
     top_k: Optional[int] = Field(default=None, description="Number of highest probability tokens to consider")
     max_output_tokens: Optional[int] = Field(default=None, description="Maximum number of tokens to generate")
     google_api_key: Optional[str] = Field(default=None, description="API key for Google Generative AI")
+
+
+# See https://api.python.langchain.com/en/latest/llms/langchain_community.llms.writer.Writer.html
+class WriterConfig(BaseLLMConfig):
+    model_name: str = Field(default="palmyra-x5", alias="model_id")
+    temperature: Optional[float] = Field(default=0.7)
+    max_tokens: Optional[int] = Field(default=None)
+    top_p: Optional[float] = Field(default=None)
+    stop: Optional[List[str]] = Field(default=None)
+    best_of: Optional[int] = Field(default=None)
+    writer_api_key: Optional[str] = Field(default=None)
+    writer_org_id: Optional[str] = Field(default=None)
+    base_url: Optional[str] = Field(default=None)