MindsDB 25.2.4.0__py3-none-any.whl → 25.3.2.0__py3-none-any.whl

mindsdb/integrations/handlers/gmail_handler/gmail_handler.py

@@ -1,7 +1,4 @@
 import json
-from shutil import copyfile
-
-import requests
 
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
@@ -15,31 +12,28 @@ from mindsdb.utilities import log
 from mindsdb_sql_parser import parse_sql
 from mindsdb.utilities.config import Config
 
-import os
 import time
 from typing import List
 import pandas as pd
 
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import Flow
 from googleapiclient.discovery import build
 from googleapiclient.errors import HttpError
 from email.message import EmailMessage
 
 from base64 import urlsafe_b64encode, urlsafe_b64decode
 
-from .utils import AuthException, google_auth_flow, save_creds_to_file
+from mindsdb.integrations.utilities.handlers.auth_utilities import GoogleUserOAuth2Manager
+from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
 
-DEFAULT_SCOPES = ['https://www.googleapis.com/auth/gmail.compose',
-                  'https://www.googleapis.com/auth/gmail.readonly',
-                  'https://www.googleapis.com/auth/gmail.modify']
+DEFAULT_SCOPES = [
+    'https://www.googleapis.com/auth/gmail.compose',
+    'https://www.googleapis.com/auth/gmail.readonly',
+    'https://www.googleapis.com/auth/gmail.modify'
+]
 
 logger = log.getLogger(__name__)
 
 
-
-
 class EmailsTable(APITable):
     """Implementation for the emails table for Gmail"""
 
@@ -283,6 +277,14 @@ class GmailHandler(APIHandler):
         super().__init__(name)
         self.connection_args = kwargs.get('connection_data', {})
 
+        self.token_file = None
+        self.max_page_size = 500
+        self.max_batch_size = 100
+        self.service = None
+        self.is_connected = False
+
+        self.handler_storage = kwargs['handler_storage']
+
         self.credentials_url = self.connection_args.get('credentials_url', None)
         self.credentials_file = self.connection_args.get('credentials_file', None)
         if self.connection_args.get('credentials'):
@@ -298,63 +300,11 @@ class GmailHandler(APIHandler):
                 self.credentials_url = secret_url
 
         self.scopes = self.connection_args.get('scopes', DEFAULT_SCOPES)
-        self.token_file = None
-        self.max_page_size = 500
-        self.max_batch_size = 100
-        self.service = None
-        self.is_connected = False
-
-        self.handler_storage = kwargs['handler_storage']
 
         emails = EmailsTable(self)
         self.emails = emails
         self._register_table('emails', emails)
 
-    def _download_secret_file(self, secret_file):
-        # Giving more priority to the S3 file
-        if self.credentials_url:
-            response = requests.get(self.credentials_url)
-            if response.status_code == 200:
-                with open(secret_file, 'w') as creds:
-                    creds.write(response.text)
-                return True
-            else:
-                logger.error("Failed to get credentials from S3", response.status_code)
-
-        if self.credentials_file and os.path.isfile(self.credentials_file):
-            copyfile(self.credentials_file, secret_file)
-            return True
-        return False
-
-    def create_connection(self):
-        creds = None
-
-        # Get the current dir, we'll check for Token & Creds files in this dir
-        curr_dir = self.handler_storage.folder_get('config')
-
-        creds_file = os.path.join(curr_dir, 'creds.json')
-        secret_file = os.path.join(curr_dir, 'secret.json')
-
-        if os.path.isfile(creds_file):
-            creds = Credentials.from_authorized_user_file(creds_file, self.scopes)
-
-        if not creds or not creds.valid:
-            if creds and creds.expired and creds.refresh_token:
-                creds.refresh(Request())
-
-            if self._download_secret_file(secret_file):
-                # save to storage
-                self.handler_storage.folder_sync('config')
-            else:
-                raise ValueError('No valid Gmail Credentials filepath or S3 url found.')
-
-            creds = google_auth_flow(secret_file, self.scopes, self.connection_args.get('code'))
-
-            save_creds_to_file(creds, creds_file)
-            self.handler_storage.folder_sync('config')
-
-        return build('gmail', 'v1', credentials=creds)
-
     def connect(self):
         """Authenticate with the Gmail API using the credentials file.
 
@@ -366,7 +316,10 @@ class GmailHandler(APIHandler):
         if self.is_connected and self.service is not None:
             return self.service
 
-        self.service = self.create_connection()
+        google_oauth2_manager = GoogleUserOAuth2Manager(self.handler_storage, self.scopes, self.credentials_file, self.credentials_url, self.connection_args.get('code'))
+        creds = google_oauth2_manager.get_oauth2_credentials()
+
+        self.service = build('gmail', 'v1', credentials=creds)
 
         self.is_connected = True
         return self.service

mindsdb/integrations/handlers/gmail_handler/requirements.txt

@@ -1,2 +1 @@
 google-api-python-client
-google-auth-httplib2

mindsdb/integrations/handlers/google_calendar_handler/connection_args.py

@@ -4,9 +4,24 @@ from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_T
 
 
 connection_args = OrderedDict(
+    credentials_url={
+        'type': ARG_TYPE.STR,
+        'description': 'URL to Service Account Keys',
+        'label': 'URL to Service Account Keys',
+    },
+    credentials_file={
+        'type': ARG_TYPE.STR,
+        'description': 'Location of Service Account Keys',
+        'label': 'Path to Service Account Keys',
+    },
     credentials={
         'type': ARG_TYPE.PATH,
         'description': 'Service Account Keys',
         'label': 'Upload Service Account Keys',
     },
+    code={
+        'type': ARG_TYPE.STR,
+        'description': 'Code After Authorisation',
+        'label': 'Code After Authorisation',
+    },
 )

mindsdb/integrations/handlers/google_calendar_handler/google_calendar_handler.py

@@ -1,8 +1,4 @@
-import os
-
 import pandas as pd
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
 from googleapiclient.discovery import build
 
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
@@ -11,13 +7,21 @@ from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
 )
+from mindsdb.utilities.config import Config
 from mindsdb.utilities import log
-logger = log.getLogger(__name__)
-
-from mindsdb.integrations.handlers.gmail_handler.utils import AuthException, google_auth_flow, save_creds_to_file
+from mindsdb.integrations.utilities.handlers.auth_utilities import GoogleUserOAuth2Manager
+from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
 
 from .google_calendar_tables import GoogleCalendarEventsTable
 
+DEFAULT_SCOPES = [
+    'https://www.googleapis.com/auth/calendar',
+    'https://www.googleapis.com/auth/calendar.events',
+    'https://www.googleapis.com/auth/calendar.readonly'
+]
+
+logger = log.getLogger(__name__)
+
 
 class GoogleCalendarHandler(APIHandler):
     """
@@ -35,20 +39,29 @@ class GoogleCalendarHandler(APIHandler):
             events (GoogleCalendarEventsTable): The `GoogleCalendarEventsTable` object for interacting with the events table.
         """
         super().__init__(name)
+        self.connection_data = kwargs.get('connection_data', {})
 
-        self.token = None
         self.service = None
-        self.connection_data = kwargs.get('connection_data', {})
-        self.credentials_file = self.connection_data['credentials']
-        self.scopes = [
-            'https://www.googleapis.com/auth/calendar',
-            'https://www.googleapis.com/auth/calendar.events',
-            'https://www.googleapis.com/auth/calendar.readonly'
-        ]
         self.is_connected = False
 
         self.handler_storage = kwargs['handler_storage']
 
+        self.credentials_url = self.connection_data.get('credentials_url', None)
+        self.credentials_file = self.connection_data.get('credentials_file', None)
+        if self.connection_data.get('credentials'):
+            self.credentials_file = self.connection_data.pop('credentials')
+        if not self.credentials_file and not self.credentials_url:
+            # try to get from config
+            gcalendar_config = Config().get('handlers', {}).get('youtube', {})
+            secret_file = gcalendar_config.get('credentials_file')
+            secret_url = gcalendar_config.get('credentials_url')
+            if secret_file:
+                self.credentials_file = secret_file
+            elif secret_url:
+                self.credentials_url = secret_url
+
+        self.scopes = self.connection_data.get('scopes', DEFAULT_SCOPES)
+
         events = GoogleCalendarEventsTable(self)
         self.events = events
         self._register_table('events', events)
@@ -64,32 +77,8 @@ class GoogleCalendarHandler(APIHandler):
         if self.is_connected is True:
             return self.service
 
-        secret_file = self.credentials_file
-
-        curr_dir = self.handler_storage.folder_get('config')
-
-        creds_file = None
-        try:
-            creds_file = os.path.join(curr_dir, 'secret.json')
-        except Exception:
-            pass
-
-        creds = None
-        if os.path.isfile(creds_file):
-            creds = Credentials.from_authorized_user_file(creds_file, self.scopes)
-
-        if not creds or not creds.valid:
-            if creds and creds.expired and creds.refresh_token:
-                creds.refresh(Request())
-
-                save_creds_to_file(creds, creds_file)
-                self.handler_storage.folder_sync('config')
-
-            else:
-                creds = google_auth_flow(secret_file, self.scopes, self.connection_data.get('code'))
-
-                save_creds_to_file(creds, creds_file)
-                self.handler_storage.folder_sync('config')
+        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()
 
         self.service = build('calendar', 'v3', credentials=creds)
         return self.service
@@ -106,6 +95,7 @@ class GoogleCalendarHandler(APIHandler):
         try:
             self.connect()
             response.success = True
+            response.copy_storage = True
 
         except AuthException as error:
             response.error_message = str(error)

mindsdb/integrations/handlers/google_calendar_handler/requirements.txt

@@ -1,3 +1 @@
 google-api-python-client
-google-auth-httplib2
--r mindsdb/integrations/handlers/gmail_handler/requirements.txt

mindsdb/integrations/handlers/jira_handler/__init__.py

@@ -4,6 +4,7 @@ from .__about__ import __version__ as version, __description__ as description
 try:
     from .jira_handler import JiraHandler as Handler
     import_error = None
+
 except Exception as e:
     Handler = None
     import_error = e

mindsdb/integrations/handlers/jira_handler/jira_handler.py

@@ -1,23 +1,15 @@
-from mindsdb.integrations.handlers.jira_handler.jira_table import JiraProjectsTable
 from mindsdb.integrations.libs.api_handler import APIHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
 )
 from mindsdb.utilities import log
-from mindsdb_sql_parser import parse_sql
-
-from atlassian import Jira
-from typing import Optional
-import requests
+from mindsdb.integrations.libs.api_handler_generator import APIResourceGenerator
 
 
 logger = log.getLogger(__name__)
 
-class JiraHandler(APIHandler):
-    """
-    This handler handles connection and execution of the Airtable statements.
-    """
 
+class JiraHandler(APIHandler):
 
     def __init__(self, name=None, **kwargs):
         """
@@ -30,64 +22,38 @@ class JiraHandler(APIHandler):
         super().__init__(name)
         self.connection_data = kwargs.get("connection_data", {})
 
-        self.parser = parse_sql
-        self.dialect = 'jira'
-        self.kwargs = kwargs
         self.connection = None
         self.is_connected = False
 
+        # todo store parsed data in files
+
+        self.api_resource_generator = APIResourceGenerator(
+            "https://developer.atlassian.com/cloud/jira/platform/swagger-v3.v3.json",
+            self.connection_data,
+            url_base='/rest/api/3/',
+            options={
+                'offset_param': ['startAt', 'offset'],
+                'total_column': ['totalEntryCount', 'total'],
+                'check_connection_table': 'myself'
+            }
+        )
+
+        resource_tables = self.api_resource_generator.generate_api_resources(self)
 
-        jira_projects_data = JiraProjectsTable(self)
-        self._register_table("project", jira_projects_data)
+        for table_name, resource in resource_tables.items():
+            self._register_table(table_name, resource)
 
     def __del__(self):
         if self.is_connected is True:
             self.disconnect()
 
-    def connect(self) -> StatusResponse:
+    def connect(self):
         """
         Set up the connection required by the handler.
         Returns:
             HandlerStatusResponse
         """
-
-        if self.is_connected is True:
-            return self.connection
-        
-        s = requests.Session()
-        if self.connection_data.get("cloud", False):
-            params = {
-                "cloud": True,
-                "username": self.connection_data['jira_username'],
-                "password": self.connection_data['jira_api_token'],
-                "url": self.connection_data['jira_url'],
-            }   
-        else:
-            params = {
-                "cloud": False,
-                "url": self.connection_data['jira_url'],
-                "session": s
-            }
-
-        s.headers['Authorization'] =  f"Bearer {self.connection_data['jira_api_token']}"
-
-        self.connection = Jira(**params)
-        self.is_connected = True
-
-
-        return self.connection
-
-    def disconnect(self):
-        """
-        Close any existing connections.
-        """
-
-        if self.is_connected is False:
-            return
-
-        self.connection.close()
-        self.is_connected = False
-        return self.is_connected
+        return
 
     def check_connection(self) -> StatusResponse:
         """
@@ -97,37 +63,13 @@ class JiraHandler(APIHandler):
         """
 
         response = StatusResponse(False)
-        need_to_close = self.is_connected is False
-        
+
         try:
-            self.connect()
+            self.api_resource_generator.check_connection()
             response.success = True
         except Exception as e:
             logger.error(f"Error connecting to Jira API: {e}!")
             response.error_message = e
 
         self.is_connected = response.success
-
         return response
-
-    def native_query(self, query: str) -> StatusResponse:
-        """Receive and process a raw query.
-        Parameters
-        ----------
-        query : str
-            query in a native format
-        Returns
-        -------
-        StatusResponse
-            Request status
-        """
-        ast = parse_sql(query)
-        return self.query(ast)
-   
-    def construct_jql(self):
-        """construct jql & returns it to JiraProjectsTable class
-        Returns
-        -------
-        Str
-        """
-        return 'project = ' + str(self.connection_data['project'])

mindsdb/integrations/handlers/pgvector_handler/pgvector_handler.py

@@ -27,7 +27,7 @@ logger = log.getLogger(__name__)
 
 
 # todo Issue #7316 add support for different indexes and search algorithms e.g. cosine similarity or L2 norm
-class PgVectorHandler(VectorStoreHandler, PostgresHandler):
+class PgVectorHandler(PostgresHandler, VectorStoreHandler):
     """This handler handles connection and execution of the PostgreSQL with pgvector extension statements."""
 
     name = "pgvector"
@@ -64,11 +64,11 @@ class PgVectorHandler(VectorStoreHandler, PostgresHandler):
             return Response(RESPONSE_TYPE.OK)
         return super().get_tables()
 
-    def native_query(self, query) -> Response:
+    def native_query(self, query, params=None) -> Response:
         # Prevent execute native queries
         if self._is_shared_db:
             return Response(RESPONSE_TYPE.OK)
-        return super().native_query(query)
+        return super().native_query(query, params=params)
 
     def raw_query(self, query, params=None) -> Response:
         resp = super().native_query(query, params)

mindsdb/integrations/handlers/slack_handler/slack_handler.py

@@ -267,7 +267,8 @@ class SlackHandler(APIChatHandler):
         user_info = web_connection.auth_test().data
         return user_info['bot_id']
 
-    def subscribe(self, stop_event: threading.Event, callback: Callable, table_name: Text, columns: List = None, **kwargs: Any) -> None:
+    def subscribe(self, stop_event: threading.Event, callback: Callable, table_name: Text = 'messages',
+                  columns: List = None, **kwargs: Any) -> None:
         """
         Subscribes to the Slack API using the Socket Mode for real-time responses to messages.
 

mindsdb/integrations/handlers/youtube_handler/youtube_handler.py

@@ -10,9 +10,7 @@ from mindsdb.integrations.libs.response import (
 from mindsdb.utilities import log
 from mindsdb_sql_parser import parse_sql
 
-from collections import OrderedDict
 from mindsdb.utilities.config import Config
-from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
 
 from googleapiclient.discovery import build
 
@@ -38,12 +36,10 @@ class YoutubeHandler(APIHandler):
             name of a handler instance
         """
         super().__init__(name)
-
-        connection_data = kwargs.get("connection_data", {})
+        self.connection_data = kwargs.get("connection_data", {})
+        self.kwargs = kwargs
 
         self.parser = parse_sql
-        self.connection_data = connection_data
-        self.kwargs = kwargs
         self.connection = None
         self.is_connected = False
 
@@ -104,7 +100,6 @@ class YoutubeHandler(APIHandler):
             Status confirmation
         """
         response = StatusResponse(False)
-        need_to_close = self.is_connected is False
 
         try:
             self.connect()
@@ -131,34 +126,3 @@ class YoutubeHandler(APIHandler):
         """
         ast = parse_sql(query)
         return self.query(ast)
-
-
-connection_args = OrderedDict(
-    youtube_access_token={
-        "type": ARG_TYPE.STR,
-        "description": "API Key",
-        "label": "API Key",
-    },
-    credentials_url={
-        'type': ARG_TYPE.STR,
-        'description': 'URL to OAuth2 Credentials',
-        'label': 'URL to OAuth2 Credentials',
-    },
-    credentials_file={
-        'type': ARG_TYPE.STR,
-        'description': 'Location of OAuth2 Credentials',
-        'label': 'Location of OAuth2 Credentials',
-    },
-    credentials={
-        'type': ARG_TYPE.PATH,
-        'description': 'OAuth2 Credentials',
-        'label': 'Upload OAuth2 Credentials',
-    },
-    code={
-        'type': ARG_TYPE.STR,
-        'description': 'Authentication Code',
-        'label': 'Authentication Code',
-    }
-)
-
-connection_args_example = OrderedDict(youtube_api_token="<your-youtube-api-token>")