MindsDB 1.3.1__py3-none-any.whl → 24.12.4.0__py3-none-any.whl

mindsdb/integrations/handlers/google_calendar_handler/google_calendar_handler.py

@@ -0,0 +1,292 @@
+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
+from mindsdb.integrations.libs.api_handler import APIHandler, FuncParser
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+)
+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 .google_calendar_tables import GoogleCalendarEventsTable
+
+
+class GoogleCalendarHandler(APIHandler):
+    """
+        A class for handling connections and interactions with the Google Calendar API.
+    """
+    name = 'google_calendar'
+
+    def __init__(self, name: str, **kwargs):
+        """ constructor
+        Args:
+            name (str): the handler name
+            credentials_file (str): The path to the credentials file.
+            scopes (list): The list of scopes to use for authentication.
+            is_connected (bool): Whether the API client is connected to Google Calendar.
+            events (GoogleCalendarEventsTable): The `GoogleCalendarEventsTable` object for interacting with the events table.
+        """
+        super().__init__(name)
+
+        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']
+
+        events = GoogleCalendarEventsTable(self)
+        self.events = events
+        self._register_table('events', events)
+
+    def connect(self):
+        """
+        Set up any connections required by the handler
+        Should return output of check_connection() method after attempting
+        connection. Should switch self.is_connected.
+        Returns:
+            HandlerStatusResponse
+        """
+        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')
+
+        self.service = build('calendar', 'v3', credentials=creds)
+        return self.service
+
+    def check_connection(self) -> StatusResponse:
+        """
+        Check connection to the handler
+        Returns:
+            HandlerStatusResponse
+        """
+
+        response = StatusResponse(False)
+
+        try:
+            self.connect()
+            response.success = True
+
+        except AuthException as error:
+            response.error_message = str(error)
+            response.redirect_url = error.auth_url
+            return response
+
+        except Exception as e:
+            logger.error(f'Error connecting to Google Calendar API: {e}!')
+            response.error_message = e
+
+        self.is_connected = response.success
+        return response
+
+    def native_query(self, query: str = None) -> Response:
+        """
+        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)
+        Returns:
+            HandlerResponse
+        """
+        method_name, params = FuncParser().from_string(query)
+
+        df = self.call_application_api(method_name, params)
+
+        return Response(
+            RESPONSE_TYPE.TABLE,
+            data_frame=df
+        )
+
+    def get_events(self, params: dict = None) -> pd.DataFrame:
+        """
+        Get events from Google Calendar API
+        Args:
+            params (dict): query parameters
+        Returns:
+            DataFrame
+        """
+        service = self.connect()
+        page_token = None
+        events = pd.DataFrame(columns=self.events.get_columns())
+        while True:
+            events_result = service.events().list(calendarId='primary', pageToken=page_token, **params).execute()
+            events = pd.concat(
+                [events, pd.DataFrame(events_result.get('items', []), columns=self.events.get_columns())],
+                ignore_index=True
+            )
+            page_token = events_result.get('nextPageToken')
+            if not page_token:
+                break
+        return events
+
+    def create_event(self, params: dict = None) -> pd.DataFrame:
+        """
+        Create an event in the calendar.
+        Args:
+            params (dict): query parameters
+        Returns:
+            DataFrame
+        """
+        service = self.connect()
+        # Check if 'attendees' is a string and split it into a list
+        if isinstance(params['attendees'], str):
+            params['attendees'] = params['attendees'].split(',')
+
+        event = {
+            'summary': params['summary'],
+            'location': params['location'],
+            'description': params['description'],
+            'start': {
+                'dateTime': params['start']['dateTime'],
+                'timeZone': params['start']['timeZone'],
+            },
+            'end': {
+                'dateTime': params['end']['dateTime'],
+                'timeZone': params['end']['timeZone'],
+            },
+            'recurrence': [
+                'RRULE:FREQ=DAILY;COUNT=1'
+            ],
+            'attendees': [{'email': attendee['email']} for attendee in (params['attendees'] 
+                            if isinstance(params['attendees'], list) else [params['attendees']])],
+            'reminders': {
+                'useDefault': False,
+                'overrides': [
+                    {'method': 'email', 'minutes': 24 * 60},
+                    {'method': 'popup', 'minutes': 10},
+                ],
+            },
+        }
+
+        event = service.events().insert(calendarId='primary', 
+                                        body=event).execute()
+        return pd.DataFrame([event], columns=self.events.get_columns())
+
+    def update_event(self, params: dict = None) -> pd.DataFrame:
+        """
+        Update event or events in the calendar.
+        Args:
+            params (dict): query parameters
+        Returns:
+            DataFrame
+        """
+        service = self.connect()
+        df = pd.DataFrame(columns=['eventId', 'status'])
+        if params['event_id']:
+            start_id = int(params['event_id'])
+            end_id = start_id + 1
+        elif not params['start_id']:
+            start_id = int(params['end_id']) - 10
+        elif not params['end_id']:
+            end_id = int(params['start_id']) + 10
+        else:
+            start_id = int(params['start_id'])
+            end_id = int(params['end_id'])
+
+        for i in range(start_id, end_id):
+            event = service.events().get(calendarId='primary', eventId=i).execute()
+            if params['summary']:
+                event['summary'] = params['summary']
+            if params['location']:
+                event['location'] = params['location']
+            if params['description']:
+                event['description'] = params['description']
+            if params['start']:
+                event['start']['dateTime'] = params['start']['dateTime']
+                event['start']['timeZone'] = params['start']['timeZone']
+            if params['end']:
+                event['end']['dateTime'] = params['end']['dateTime']
+                event['end']['timeZone'] = params['end']['timeZone']
+            if params['attendees']:
+                event['attendees'] = [{'email': attendee} for attendee in params['attendees'].split(',')]
+            updated_event = service.events().update(calendarId='primary', eventId=event['id'], body=event).execute()
+            df = pd.concat([df, pd.DataFrame([{'eventId': updated_event['id'], 'status': 'updated'}])],
+                           ignore_index=True)
+
+        return df
+
+    def delete_event(self, params):
+        """
+        Delete event or events in the calendar.
+        Args:
+            params (dict): query parameters
+        Returns:
+            DataFrame
+        """
+        service = self.connect()
+        if params['event_id']:
+            service.events().delete(calendarId='primary', eventId=params['event_id']).execute()
+            return pd.DataFrame([{'eventId': params['event_id'], 'status': 'deleted'}])
+        else:
+            df = pd.DataFrame(columns=['eventId', 'status'])
+            if not params['start_id']:
+                start_id = int(params['end_id']) - 10
+            elif not params['end_id']:
+                end_id = int(params['start_id']) + 10
+            else:
+                start_id = int(params['start_id'])
+                end_id = int(params['end_id'])
+            for i in range(start_id, end_id):
+                service.events().delete(calendarId='primary', eventId=str(i)).execute()
+                df = pd.concat([df, pd.DataFrame([{'eventId': str(i), 'status': 'deleted'}])], ignore_index=True)
+            return df
+
+    def call_application_api(self, method_name: str = None, params: dict = None) -> pd.DataFrame:
+        """
+        Call Google Calendar API and map the data to pandas DataFrame
+        Args:
+            method_name (str): method name
+            params (dict): query parameters
+        Returns:
+            DataFrame
+        """
+        if method_name == 'get_events':
+            return self.get_events(params)
+        elif method_name == 'create_event':
+            return self.create_event(params)
+        elif method_name == 'update_event':
+            return self.update_event(params)
+        elif method_name == 'delete_event':
+            return self.delete_event(params)
+        else:
+            raise NotImplementedError(f'Unknown method {method_name}')

mindsdb/integrations/handlers/google_calendar_handler/google_calendar_tables.py

@@ -0,0 +1,228 @@
+import pandas as pd
+import datetime
+from mindsdb_sql_parser import ast
+from pandas import DataFrame
+
+from mindsdb.integrations.libs.api_handler import APITable
+from mindsdb.integrations.libs.response import (
+    HandlerResponse as Response,
+)
+from mindsdb.integrations.utilities.date_utils import utc_date_str_to_timestamp_ms, parse_utc_date
+from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
+
+
+class GoogleCalendarEventsTable(APITable):
+
+    def select(self, query: ast.Select) -> DataFrame:
+        """
+        Gets all events from the calendar.
+
+        Args:
+            query (ast.Select): SQL query to parse.
+
+        Returns:
+            Response: Response object containing the results.
+        """
+
+        # Parse the query to get the conditions.
+        conditions = extract_comparison_conditions(query.where)
+        # Get the start and end times from the conditions.
+        params = {}
+        for op, arg1, arg2 in conditions:
+            if arg1 == 'timeMax' or arg1 == 'timeMin':
+                date = parse_utc_date(arg2)
+                if op == '=':
+                    params[arg1] = date
+                else:
+                    raise NotImplementedError
+            elif arg1 == 'timeZone':
+                params[arg1] = arg2
+            elif arg1 == 'maxAttendees':
+                params[arg1] = arg2
+            elif arg1 == 'q':
+                params[arg1] = arg2
+           
+
+        # Get the order by from the query.
+        if query.order_by is not None:
+            if query.order_by[0].value == 'start_time':
+                params['orderBy'] = 'startTime'
+            elif query.order_by[0].value == 'updated':
+                params['orderBy'] = 'updated'
+            else:
+                raise NotImplementedError
+
+        if query.limit is not None:
+            params['maxResults'] = query.limit.value
+
+        # Get the events from the Google Calendar API.
+        events = self.handler.call_application_api(method_name='get_events', params=params)
+
+        selected_columns = []
+        for target in query.targets:
+            if isinstance(target, ast.Star):
+                selected_columns = self.get_columns()
+                break
+            elif isinstance(target, ast.Identifier):
+                selected_columns.append(target.parts[-1])
+            else:
+                raise ValueError(f"Unknown query target {type(target)}")
+
+        if len(events) == 0:
+            events = pd.DataFrame([], columns=selected_columns)
+        else:
+            events.columns = self.get_columns()
+            for col in set(events.columns).difference(set(selected_columns)):
+                events = events.drop(col, axis=1)
+        return events
+
+    def insert(self, query: ast.Insert):
+        """
+        Inserts an event into the calendar.
+
+        Args:
+            query (ast.Insert): SQL query to parse.
+
+        Returns:
+            Response: Response object containing the results.
+        """
+
+        # Get the values from the query.
+        values = query.values[0]
+        # Get the event data from the values.
+        event_data = {}
+        timestamp_columns = {'start_time', 'end_time', 'created', 'updated'}
+        regular_columns = {'summary', 'description', 'location', 'status', 'html_link',
+                            'creator', 'organizer', 'reminders', 'timeZone', 'calendar_id', 'attendees'}
+
+        # TODO: check why query.columns is None
+        for col, val in zip(query.columns, values):
+            if col.name in timestamp_columns:
+                event_data[col.name] = utc_date_str_to_timestamp_ms(val)
+            elif col.name in regular_columns:
+                event_data[col.name] = val
+            else:
+                raise NotImplementedError
+            
+        st = datetime.datetime.utcfromtimestamp(event_data['start_time'] / 1000).isoformat() + 'Z'
+        et = datetime.datetime.utcfromtimestamp(event_data['end_time'] / 1000).isoformat() + 'Z'
+
+        event_data['start'] = {
+            'dateTime': st,
+            'timeZone': event_data['timeZone']
+        }
+
+        event_data['end'] = {
+            'dateTime': et,
+            'timeZone': event_data['timeZone']
+        }
+
+        event_data['attendees'] = event_data['attendees'].split(',')
+        event_data['attendees'] = [{'email': attendee} for attendee in event_data['attendees']]
+
+        # Insert the event into the Google Calendar API.
+        self.handler.call_application_api(method_name='create_event', params=event_data)
+
+    def update(self, query: ast.Update):
+        """
+        Updates an event or events in the calendar.
+
+        Args:
+            query (ast.Update): SQL query to parse.
+
+        Returns:
+            Response: Response object containing the results.
+        """
+
+        # Get the values from the query.
+        values = query.values[0]
+        # Get the event data from the values.
+        event_data = {}
+        for col, val in zip(query.update_columns, values):
+            if col == 'start_time' or col == 'end_time' or col == 'created' or col == 'updated':
+                event_data[col] = utc_date_str_to_timestamp_ms(val)
+            elif col == 'summary' or col == 'description' or col == 'location' or col == 'status' or col == 'html_link' \
+                    or col == 'creator' or col == 'organizer' or col == 'reminders' \
+                    or col == 'timeZone' or col == 'calendar_id' or col == 'attendees':
+                event_data[col] = val
+            else:
+                raise NotImplementedError
+
+        event_data['start'] = {
+            'dateTime': event_data['start_time'],
+            'timeZone': event_data['timeZone']
+        }
+
+        event_data['end'] = {
+            'dateTime': event_data['end_time'],
+            'timeZone': event_data['timeZone']
+        }
+
+        event_data['attendees'] = event_data.get('attendees').split(',')
+        event_data['attendees'] = [{'email': attendee} for attendee in event_data['attendees']]
+
+        conditions = extract_comparison_conditions(query.where)
+        for op, arg1, arg2 in conditions:
+            if arg1 == 'event_id':
+                if op == '=':
+                    event_data['event_id'] = arg2
+                elif op == '>':
+                    event_data['start_id'] = arg2
+                elif op == '<':
+                    event_data['end_id'] = arg2
+                else:
+                    raise NotImplementedError
+            else:
+                raise NotImplementedError
+
+        # Update the event in the Google Calendar API.
+        self.handler.call_application_api(method_name='update_event', params=event_data)
+
+    def delete(self, query: ast.Delete):
+        """
+        Deletes an event or events in the calendar.
+
+        Args:
+            query (ast.Delete): SQL query to parse.
+
+        Returns:
+            Response: Response object containing the results.
+        """
+
+        # Parse the query to get the conditions.
+        conditions = extract_comparison_conditions(query.where)
+        # Get the start and end times from the conditions.
+        params = {}
+        for op, arg1, arg2 in conditions:
+            if arg1 == 'event_id':
+                if op == '=':
+                    params[arg1] = arg2
+                elif op == '>':
+                    params['start_id'] = arg2
+                elif op == '<':
+                    params['end_id'] = arg2
+                else:
+                    raise NotImplementedError
+
+        # Delete the events in the Google Calendar API.
+        self.handler.call_application_api(method_name='delete_event', params=params)
+
+    def get_columns(self) -> list:
+        """Gets all columns to be returned in pandas DataFrame responses"""
+        return [
+            'etag',
+            'id',
+            'status',
+            'htmlLink',
+            'created',
+            'updated',
+            'summary',
+            'creator',
+            'organizer',
+            'start',
+            'end',
+            'timeZone',
+            'iCalUID',
+            'sequence',
+            'reminders',
+            'eventType']

mindsdb/integrations/handlers/google_calendar_handler/icon.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M30 10H10V30H30V10Z" fill="white"/>
+  <path d="M30 39L39 30H30V39Z" fill="#EA4335"/>
+  <path d="M39 10H30V30H39V10Z" fill="#FBBC04"/>
+  <path d="M30 30H10V39H30V30Z" fill="#34A853"/>
+  <path d="M1 30V36C1 37.6575 2.3425 39 4 39H10V30H1Z" fill="#188038"/>
+  <path d="M39 10V4C39 2.3425 37.6575 1 36 1H30V10H39Z" fill="#1967D2"/>
+  <path d="M30 1H4C2.3425 1 1 2.3425 1 4V30H10V10H30V1Z" fill="#4285F4"/>
+  <path d="M14.5393 25.2555C13.7957 24.7576 13.281 24.0304 13 23.069L14.7258 22.364C14.8824 22.9556 15.1559 23.4141 15.5464 23.7395C15.9343 24.0649 16.4067 24.2251 16.9588 24.2251C17.5233 24.2251 18.0082 24.055 18.4135 23.7149C18.8188 23.3747 19.0227 22.9408 19.0227 22.4158C19.0227 21.8784 18.8089 21.4396 18.3812 21.0994C17.9535 20.7592 17.4163 20.5891 16.7748 20.5891H15.7776V18.8956H16.6728C17.2249 18.8956 17.6899 18.7477 18.0679 18.4519C18.4458 18.1561 18.6348 17.7518 18.6348 17.2366C18.6348 16.7781 18.4657 16.4133 18.1275 16.1397C17.7893 15.8661 17.3616 15.728 16.8419 15.728C16.3346 15.728 15.9318 15.8611 15.6334 16.1298C15.3352 16.3992 15.111 16.7394 14.9819 17.1183L13.2735 16.4133C13.4998 15.7773 13.9151 15.2153 14.5243 14.7297C15.1336 14.244 15.9119 14 16.8568 14C17.5556 14 18.1847 14.1331 18.7417 14.4018C19.2988 14.6705 19.7364 15.0427 20.0522 15.516C20.368 15.9918 20.5247 16.5242 20.5247 17.1159C20.5247 17.7198 20.378 18.2301 20.0845 18.6491C19.7911 19.0682 19.4306 19.3887 19.0028 19.613V19.714C19.5551 19.9398 20.0348 20.3105 20.3904 20.7863C20.751 21.267 20.9325 21.8414 20.9325 22.5119C20.9325 23.1824 20.7609 23.7814 20.4178 24.3065C20.0746 24.8315 19.5996 25.2457 18.9979 25.5464C18.3936 25.8471 17.7147 26 16.9613 26C16.0885 26.0024 15.2828 25.7535 14.5393 25.2555ZM25.14 16.7658L23.2451 18.1241L22.2977 16.6993L25.697 14.2687H27V25.7338H25.14V16.7658Z" fill="#4285F4"/>
+</svg>

mindsdb/integrations/handlers/google_calendar_handler/requirements.txt

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

mindsdb/integrations/handlers/google_calendar_handler/tests/test_google_calendar_handler.py

@@ -0,0 +1,56 @@
+import unittest
+from mindsdb.integrations.handlers.google_calendar_handler.google_calendar_handler import GoogleCalendarHandler
+from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
+
+
+class GoogleCalendarHandlerTest(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.kwargs = {
+            "connection_data": {
+                "credentials": "C:\\Users\\panagiotis\\Desktop\\GitHub\\mindsdb\\mindsdb\\integrations\\handlers"
+                               "\\google_calendar_handler\\credentials.json",
+            }
+        }
+        cls.handler = GoogleCalendarHandler('test_google_calendar_handler', **cls.kwargs)
+
+    def test_0_check_connection(self):
+        assert self.handler.check_connection()
+
+    def test_1_get_tables(self):
+        tables = self.handler.get_tables()
+        assert tables.type is not RESPONSE_TYPE.ERROR
+
+    def test_2_select_query(self):
+        query = "SELECT summary FROM calendar.events WHERE id = 1"
+        result = self.handler.native_query(query)
+        assert result.type is RESPONSE_TYPE.TABLE
+
+    def test_3_get_columns(self):
+        columns = self.handler.get_columns('id')
+        assert columns.type is not RESPONSE_TYPE.ERROR
+
+    def test_4_insert(self):
+        res = self.handler.native_query(
+            "INSERT INTO calendar.events VALUES (100, '2023-04-21 00:00:00', '2023-05-01 00:00:00',"
+            "'summary', 'description','location', 'status', 'html_link', "
+            "'creator', 'organizer', 'reminders', "
+            "'timeZone', 'calendar_id', 'attendees'")
+        assert res.type is not RESPONSE_TYPE.ERROR
+
+    def test_5_update(self):
+        res = self.handler.native_query("UPDATE calendar.events SET summary = 'ONE HUNDRED' WHERE id = 100")
+        assert res.type is not RESPONSE_TYPE.ERROR
+
+    def test_6_delete(self):
+        res = self.handler.native_query("DELETE FROM calendar.events WHERE id = 100")
+        assert res.type is not RESPONSE_TYPE.ERROR
+
+    def test_7_delete_multiple(self):
+        res = self.handler.native_query("DELETE FROM calendar.events WHERE id > 1 AND id < 20")
+        assert res.type is not RESPONSE_TYPE.ERROR
+
+
+if __name__ == '__main__':
+    unittest.main()

mindsdb/integrations/handlers/google_content_shopping_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB Google Content API for Shopping handler'
+__package_name__ = 'mindsdb_google_content_shopping_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for the Google Content API for Shopping"
+__author__ = 'Panagiotis-Alexios Spanakis'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2023 - mindsdb'

mindsdb/integrations/handlers/google_content_shopping_handler/__init__.py

@@ -0,0 +1,20 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+from .connection_args import connection_args, connection_args_example
+try:
+    from .google_content_shopping_handler import GoogleContentShoppingHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'Google Content Shopping'
+name = 'google_content_shopping'
+type = HANDLER_TYPE.DATA
+icon_path = 'icon.svg'
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title', 'description',
+    'import_error', 'icon_path', 'connection_args', 'connection_args_example'
+]

mindsdb/integrations/handlers/google_content_shopping_handler/connection_args.py

@@ -0,0 +1,20 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    credentials={
+        'type': ARG_TYPE.PATH,
+        'description': 'The path to the credentials file. If not specified, the default credentials are used.'
+    },
+    merchant_id={
+        'type': ARG_TYPE.STR,
+        'description': 'The merchant ID for the Google Content API.'
+    },
+)
+
+connection_args_example = OrderedDict(
+    credentials='/path/to/credentials.json',
+    merchant_id='1234567890'
+)