MindsDB 25.8.3.0__py3-none-any.whl → 25.9.1.0__py3-none-any.whl

mindsdb/integrations/handlers/google_books_handler/google_books_handler.py

@@ -19,9 +19,10 @@ logger = log.getLogger(__name__)
 
 class GoogleBooksHandler(APIHandler):
     """
-        A class for handling connections and interactions with the Google Books API.
+    A class for handling connections and interactions with the Google Books API.
     """
-    name = 'google_books'
+
+    name = "google_books"
 
     def __init__(self, name: str, **kwargs):
         """
@@ -33,18 +34,18 @@ class GoogleBooksHandler(APIHandler):
         super().__init__(name)
         self.token = None
         self.service = None
-        self.connection_data = kwargs.get('connection_data', {})
-        self.credentials_file = self.connection_data.get('credentials', None)
+        self.connection_data = kwargs.get("connection_data", {})
+        self.credentials_file = self.connection_data.get("credentials", None)
         self.credentials = None
-        self.scopes = ['https://www.googleapis.com/auth/books']
+        self.scopes = ["https://www.googleapis.com/auth/books"]
         self.is_connected = False
         self.connection = None
         bookshelves = BookshelvesTable(self)
         self.bookshelves = bookshelves
-        self._register_table('bookshelves', bookshelves)
+        self._register_table("bookshelves", bookshelves)
         volumes = VolumesTable(self)
         self.volumes = volumes
-        self._register_table('volumes', volumes)
+        self._register_table("volumes", volumes)
 
     def connect(self):
         """
@@ -58,18 +59,19 @@ class GoogleBooksHandler(APIHandler):
         if self.is_connected is True:
             return self.service
         if self.credentials_file:
-            if os.path.exists('token_books.json'):
-                self.credentials = Credentials.from_authorized_user_file('token_books.json', self.scopes)
+            if os.path.exists("token_books.json"):
+                self.credentials = Credentials.from_authorized_user_file("token_books.json", self.scopes)
             if not self.credentials or not self.credentials.valid:
                 if self.credentials and self.credentials.expired and self.credentials.refresh_token:
                     self.credentials.refresh(Request())
                 else:
                     self.credentials = service_account.Credentials.from_service_account_file(
-                        self.credentials_file, scopes=self.scopes)
+                        self.credentials_file, scopes=self.scopes
+                    )
             # Save the credentials for the next run
-            with open('token_books.json', 'w') as token:
+            with open("token_books.json", "w") as token:
                 token.write(self.credentials.to_json())
-            self.service = build('books', 'v1', credentials=self.credentials)
+            self.service = build("books", "v1", credentials=self.credentials)
         return self.service
 
     def check_connection(self) -> StatusResponse:
@@ -85,7 +87,7 @@ class GoogleBooksHandler(APIHandler):
             self.connect()
             response.success = True
         except Exception as e:
-            logger.error(f'Error connecting to Google Books API: {e}!')
+            logger.error(f"Error connecting to Google Books API: {e}!")
             response.error_message = e
 
         self.is_connected = response.success
@@ -96,7 +98,7 @@ class GoogleBooksHandler(APIHandler):
         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)
+                api's json etc)
         Returns:
             HandlerResponse
         """
@@ -104,10 +106,7 @@ class GoogleBooksHandler(APIHandler):
 
         df = self.call_application_api(method_name, params)
 
-        return Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=df
-        )
+        return Response(RESPONSE_TYPE.TABLE, data_frame=df)
 
     def get_bookshelves(self, params: dict = None) -> DataFrame:
         """
@@ -120,35 +119,39 @@ class GoogleBooksHandler(APIHandler):
         service = self.connect()
         minShelf = None
         maxShelf = None
-        if params['shelf']:
-            shelf = int(params['shelf'])
-            if params['source']:
-                df = service.mylibrary().bookshelves().get(shelf=shelf, userid=params['userid'],
-                                                           source=params['source']).execute()
+        if params["shelf"]:
+            shelf = int(params["shelf"])
+            if params["source"]:
+                df = (
+                    service.mylibrary()
+                    .bookshelves()
+                    .get(shelf=shelf, userid=params["userid"], source=params["source"])
+                    .execute()
+                )
             else:
-                df = service.mylibrary().bookshelves().get(shelf=shelf, userid=params['userid']).execute()
+                df = service.mylibrary().bookshelves().get(shelf=shelf, userid=params["userid"]).execute()
 
             df = pd.DataFrame(df, columns=self.bookshelves.get_columns())
             return df
-        elif not params['minShelf'] and params['maxShelf']:
-            minShelf = int(params['maxShelf']) - 10
-            maxShelf = int(params['maxShelf'])
-        elif not params['maxShelf'] and params['minShelf']:
-            minShelf = int(params['minShelf'])
-            maxShelf = int(params['minShelf']) + 10
-        elif params['maxShelf'] and params['minShelf']:
-            minShelf = int(params['minShelf'])
-            maxShelf = int(params['maxShelf'])
+        elif not params["minShelf"] and params["maxShelf"]:
+            minShelf = int(params["maxShelf"]) - 10
+            maxShelf = int(params["maxShelf"])
+        elif not params["maxShelf"] and params["minShelf"]:
+            minShelf = int(params["minShelf"])
+            maxShelf = int(params["minShelf"]) + 10
+        elif params["maxShelf"] and params["minShelf"]:
+            minShelf = int(params["minShelf"])
+            maxShelf = int(params["maxShelf"])
 
         args = {
-            key: value for key, value in params.items() if key not in ['minShelf', 'maxShelf'] and value is not None
+            key: value for key, value in params.items() if key not in ["minShelf", "maxShelf"] and value is not None
         }
-        bookshelves = service.bookshelves().list(userid=params['userid'], **args).execute()
+        bookshelves = service.bookshelves().list(userid=params["userid"], **args).execute()
 
-        df = pd.DataFrame(bookshelves['items'], columns=self.bookshelves.get_columns())
+        df = pd.DataFrame(bookshelves["items"], columns=self.bookshelves.get_columns())
         if minShelf is not None or maxShelf is not None:
             # Drop bookshelves that are not in the id range
-            df = df.drop(df[(df['id'] < minShelf) | (df['id'] > maxShelf)].index)
+            df = df.drop(df[(df["id"] < minShelf) | (df["id"] > maxShelf)].index)
 
         return df
 
@@ -161,11 +164,9 @@ class GoogleBooksHandler(APIHandler):
             DataFrame
         """
         service = self.connect()
-        args = {
-            key: value for key, value in params.items() if value is not None
-        }
+        args = {key: value for key, value in params.items() if value is not None}
         volumes = service.volumes().list(**args).execute()
-        df = pd.DataFrame(volumes['items'], columns=self.volumes.get_columns())
+        df = pd.DataFrame(volumes["items"], columns=self.volumes.get_columns())
         return df
 
     def call_application_api(self, method_name: str = None, params: dict = None) -> DataFrame:
@@ -177,9 +178,9 @@ class GoogleBooksHandler(APIHandler):
         Returns:
             DataFrame
         """
-        if method_name == 'get_bookshelves':
+        if method_name == "get_bookshelves":
             return self.get_bookshelves(params)
-        elif method_name == 'get_volumes':
+        elif method_name == "get_volumes":
             return self.get_volumes(params)
         else:
-            raise NotImplementedError(f'Unknown method {method_name}')
+            raise NotImplementedError(f"Unknown method {method_name}")

mindsdb/integrations/handlers/google_calendar_handler/google_calendar_handler.py

@@ -15,9 +15,9 @@ from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import Au
 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'
+    "https://www.googleapis.com/auth/calendar",
+    "https://www.googleapis.com/auth/calendar.events",
+    "https://www.googleapis.com/auth/calendar.readonly",
 ]
 
 logger = log.getLogger(__name__)
@@ -25,12 +25,13 @@ logger = log.getLogger(__name__)
 
 class GoogleCalendarHandler(APIHandler):
     """
-        A class for handling connections and interactions with the Google Calendar API.
+    A class for handling connections and interactions with the Google Calendar API.
     """
-    name = 'google_calendar'
+
+    name = "google_calendar"
 
     def __init__(self, name: str, **kwargs):
-        """ constructor
+        """constructor
         Args:
             name (str): the handler name
             credentials_file (str): The path to the credentials file.
@@ -39,32 +40,32 @@ 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.connection_data = kwargs.get("connection_data", {})
 
         self.service = None
         self.is_connected = False
 
-        self.handler_storage = kwargs['handler_storage']
+        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')
+        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')
+            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)
+        self.scopes = self.connection_data.get("scopes", DEFAULT_SCOPES)
 
         events = GoogleCalendarEventsTable(self)
         self.events = events
-        self._register_table('events', events)
+        self._register_table("events", events)
 
     def connect(self):
         """
@@ -77,10 +78,16 @@ class GoogleCalendarHandler(APIHandler):
         if self.is_connected is True:
             return self.service
 
-        google_oauth2_manager = GoogleUserOAuth2Manager(self.handler_storage, self.scopes, self.credentials_file, self.credentials_url, self.connection_data.get('code'))
+        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)
+        self.service = build("calendar", "v3", credentials=creds)
         return self.service
 
     def check_connection(self) -> StatusResponse:
@@ -103,7 +110,7 @@ class GoogleCalendarHandler(APIHandler):
             return response
 
         except Exception as e:
-            logger.error(f'Error connecting to Google Calendar API: {e}!')
+            logger.error(f"Error connecting to Google Calendar API: {e}!")
             response.error_message = e
 
         self.is_connected = response.success
@@ -114,7 +121,7 @@ class GoogleCalendarHandler(APIHandler):
         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)
+                api's json etc)
         Returns:
             HandlerResponse
         """
@@ -122,10 +129,7 @@ class GoogleCalendarHandler(APIHandler):
 
         df = self.call_application_api(method_name, params)
 
-        return Response(
-            RESPONSE_TYPE.TABLE,
-            data_frame=df
-        )
+        return Response(RESPONSE_TYPE.TABLE, data_frame=df)
 
     def get_events(self, params: dict = None) -> pd.DataFrame:
         """
@@ -139,12 +143,12 @@ class GoogleCalendarHandler(APIHandler):
         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_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
+                [events, pd.DataFrame(events_result.get("items", []), columns=self.events.get_columns())],
+                ignore_index=True,
             )
-            page_token = events_result.get('nextPageToken')
+            page_token = events_result.get("nextPageToken")
             if not page_token:
                 break
         return events
@@ -159,37 +163,38 @@ class GoogleCalendarHandler(APIHandler):
         """
         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(',')
+        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'],
+            "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'],
+            "end": {
+                "dateTime": params["end"]["dateTime"],
+                "timeZone": params["end"]["timeZone"],
             },
-            'recurrence': [
-                'RRULE:FREQ=DAILY;COUNT=1'
+            "recurrence": ["RRULE:FREQ=DAILY;COUNT=1"],
+            "attendees": [
+                {"email": attendee["email"]}
+                for attendee in (
+                    params["attendees"] if isinstance(params["attendees"], list) else [params["attendees"]]
+                )
             ],
-            '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},
+            "reminders": {
+                "useDefault": False,
+                "overrides": [
+                    {"method": "email", "minutes": 24 * 60},
+                    {"method": "popup", "minutes": 10},
                 ],
             },
         }
 
-        event = service.events().insert(calendarId='primary',
-                                        body=event).execute()
+        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:
@@ -201,37 +206,38 @@ class GoogleCalendarHandler(APIHandler):
             DataFrame
         """
         service = self.connect()
-        df = pd.DataFrame(columns=['eventId', 'status'])
-        if params['event_id']:
-            start_id = int(params['event_id'])
+        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
+        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'])
+            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)
+            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
 
@@ -244,21 +250,21 @@ class GoogleCalendarHandler(APIHandler):
             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'}])
+        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
+            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'])
+                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)
+                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:
@@ -270,13 +276,13 @@ class GoogleCalendarHandler(APIHandler):
         Returns:
             DataFrame
         """
-        if method_name == 'get_events':
+        if method_name == "get_events":
             return self.get_events(params)
-        elif method_name == 'create_event':
+        elif method_name == "create_event":
             return self.create_event(params)
-        elif method_name == 'update_event':
+        elif method_name == "update_event":
             return self.update_event(params)
-        elif method_name == 'delete_event':
+        elif method_name == "delete_event":
             return self.delete_event(params)
         else:
-            raise NotImplementedError(f'Unknown method {method_name}')
+            raise NotImplementedError(f"Unknown method {method_name}")