google-workspace-mcp 1.0.0__tar.gz → 1.0.1__tar.gz

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-workspace-mcp
-Version: 1.0.0
+Version: 1.0.1
 Summary: MCP server for Google Workspace integration
 Author-email: Arclio Team <info@arclio.com>
 License: MIT

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "google-workspace-mcp"
-version = "1.0.0"
+version = "1.0.1"
 description = "MCP server for Google Workspace integration"
 authors = [
     {name = "Arclio Team", email = "info@arclio.com"},

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/src/google_workspace_mcp/__main__.py

@@ -19,16 +19,16 @@ from google_workspace_mcp.resources import drive as drive_resources  # noqa: F40
 from google_workspace_mcp.resources import gmail as gmail_resources  # noqa: F401
 from google_workspace_mcp.resources import sheets_resources  # noqa: F401
 from google_workspace_mcp.resources import slides as slides_resources  # noqa: F401
+from google_workspace_mcp.tools import calendar as calendar_tools  # noqa: F401
 
 # Register tools
-from google_workspace_mcp.tools import (  # noqa: F401
-    calendar_tools,
-    docs_tools,
-    drive_tools,
-    gmail_tools,
-    sheets_tools,
-    slides_tools,
+from google_workspace_mcp.tools import (
+    docs_tools,  # noqa: F401
+    sheets_tools,  # noqa: F401
 )
+from google_workspace_mcp.tools import drive as drive_tools  # noqa: F401
+from google_workspace_mcp.tools import gmail as gmail_tools  # noqa: F401
+from google_workspace_mcp.tools import slides as slides_tools  # noqa: F401
 
 
 def main():

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/src/google_workspace_mcp/resources/sheets_resources.py

@@ -13,9 +13,7 @@ async def get_spreadsheet_metadata_resource(spreadsheet_id: str) -> dict[str, An
     Retrieves metadata for a specific Google Spreadsheet.
     Maps to URI: sheets://spreadsheets/{spreadsheet_id}/metadata
     """
-    logger.info(
-        f"Executing get_spreadsheet_metadata_resource for spreadsheet_id: {spreadsheet_id}"
-    )
+    logger.info(f"Executing get_spreadsheet_metadata_resource for spreadsheet_id: {spreadsheet_id}")
     if not spreadsheet_id:
         raise ValueError("Spreadsheet ID is required in the URI path.")
 
@@ -23,24 +21,16 @@ async def get_spreadsheet_metadata_resource(spreadsheet_id: str) -> dict[str, An
     metadata = sheets_service.get_spreadsheet_metadata(spreadsheet_id=spreadsheet_id)
 
     if isinstance(metadata, dict) and metadata.get("error"):
-        raise ValueError(
-            metadata.get("message", "Error retrieving spreadsheet metadata")
-        )
+        raise ValueError(metadata.get("message", "Error retrieving spreadsheet metadata"))
 
     if not metadata:
-        raise ValueError(
-            f"Could not retrieve metadata for spreadsheet ID: {spreadsheet_id}"
-        )
+        raise ValueError(f"Could not retrieve metadata for spreadsheet ID: {spreadsheet_id}")
 
     return metadata
 
 
-@mcp.resource(
-    "sheets://spreadsheets/{spreadsheet_id}/sheets/{sheet_identifier}/metadata"
-)
-async def get_specific_sheet_metadata_resource(
-    spreadsheet_id: str, sheet_identifier: str
-) -> dict[str, Any]:
+@mcp.resource("sheets://spreadsheets/{spreadsheet_id}/sheets/{sheet_identifier}/metadata")
+async def get_specific_sheet_metadata_resource(spreadsheet_id: str, sheet_identifier: str) -> dict[str, Any]:
     """
     Retrieves metadata for a specific sheet within a Google Spreadsheet,
     identified by its title (name) or numeric sheetId.
@@ -50,9 +40,7 @@ async def get_specific_sheet_metadata_resource(
         f"Executing get_specific_sheet_metadata_resource for spreadsheet: {spreadsheet_id}, sheet_identifier: {sheet_identifier}"
     )
     if not spreadsheet_id or not sheet_identifier:
-        raise ValueError(
-            "Spreadsheet ID and sheet identifier (name or ID) are required."
-        )
+        raise ValueError("Spreadsheet ID and sheet identifier (name or ID) are required.")
 
     sheets_service = SheetsService()
     # Fetch metadata for all sheets first
@@ -62,16 +50,10 @@ async def get_specific_sheet_metadata_resource(
     )
 
     if isinstance(full_metadata, dict) and full_metadata.get("error"):
-        raise ValueError(
-            full_metadata.get(
-                "message", "Error retrieving spreadsheet to find sheet metadata"
-            )
-        )
+        raise ValueError(full_metadata.get("message", "Error retrieving spreadsheet to find sheet metadata"))
 
     if not full_metadata or not full_metadata.get("sheets"):
-        raise ValueError(
-            f"No sheets found in spreadsheet {spreadsheet_id} or metadata incomplete."
-        )
+        raise ValueError(f"No sheets found in spreadsheet {spreadsheet_id} or metadata incomplete.")
 
     found_sheet = None
     for sheet in full_metadata.get("sheets", []):
@@ -85,8 +67,6 @@ async def get_specific_sheet_metadata_resource(
             break
 
     if not found_sheet:
-        raise ValueError(
-            f"Sheet '{sheet_identifier}' not found in spreadsheet '{spreadsheet_id}'."
-        )
+        raise ValueError(f"Sheet '{sheet_identifier}' not found in spreadsheet '{spreadsheet_id}'.")
 
     return found_sheet

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/src/google_workspace_mcp/services/calendar.py

@@ -226,9 +226,7 @@ class CalendarService(BaseGoogleService):
             self.handle_api_error("delete_event", e)
             return False
 
-    def get_event_details(
-        self, event_id: str, calendar_id: str = "primary"
-    ) -> dict[str, Any] | None:
+    def get_event_details(self, event_id: str, calendar_id: str = "primary") -> dict[str, Any] | None:
         """
         Retrieves details for a specific event.
 
@@ -240,17 +238,9 @@ class CalendarService(BaseGoogleService):
             A dictionary containing the event details or an error dictionary.
         """
         try:
-            logger.info(
-                f"Fetching details for event ID: {event_id} from calendar: {calendar_id}"
-            )
-            event = (
-                self.service.events()
-                .get(calendarId=calendar_id, eventId=event_id)
-                .execute()
-            )
-            logger.info(
-                f"Successfully fetched details for event: {event.get('summary')}"
-            )
+            logger.info(f"Fetching details for event ID: {event_id} from calendar: {calendar_id}")
+            event = self.service.events().get(calendarId=calendar_id, eventId=event_id).execute()
+            logger.info(f"Successfully fetched details for event: {event.get('summary')}")
             return event  # Return the full event resource as per API
         except Exception as e:
             return self.handle_api_error("get_event_details", e)

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/src/google_workspace_mcp/services/drive.py

@@ -27,9 +27,7 @@ class DriveService(BaseGoogleService):
         """Initialize the Drive service."""
         super().__init__("drive", "v3")
 
-    def search_files(
-        self, query: str, page_size: int = 10, shared_drive_id: str | None = None
-    ) -> list[dict[str, Any]]:
+    def search_files(self, query: str, page_size: int = 10, shared_drive_id: str | None = None) -> list[dict[str, Any]]:
         """
         Search for files in Google Drive.
 
@@ -42,9 +40,7 @@ class DriveService(BaseGoogleService):
             List of file metadata dictionaries (id, name, mimeType, etc.) or an error dictionary
         """
         try:
-            logger.info(
-                f"Searching files with query: '{query}', page_size: {page_size}, shared_drive_id: {shared_drive_id}"
-            )
+            logger.info(f"Searching files with query: '{query}', page_size: {page_size}, shared_drive_id: {shared_drive_id}")
 
             # Validate and constrain page_size
             page_size = max(1, min(page_size, 1000))
@@ -63,13 +59,9 @@ class DriveService(BaseGoogleService):
 
             if shared_drive_id:
                 list_params["driveId"] = shared_drive_id
-                list_params["corpora"] = (
-                    "drive"  # Search within the specified shared drive
-                )
+                list_params["corpora"] = "drive"  # Search within the specified shared drive
             else:
-                list_params["corpora"] = (
-                    "user"  # Default to user's files if no specific shared drive ID
-                )
+                list_params["corpora"] = "user"  # Default to user's files if no specific shared drive ID
 
             results = self.service.files().list(**list_params).execute()
             files = results.get("files", [])
@@ -92,18 +84,12 @@ class DriveService(BaseGoogleService):
         """
         try:
             # Get file metadata
-            file_metadata = (
-                self.service.files()
-                .get(fileId=file_id, fields="mimeType, name")
-                .execute()
-            )
+            file_metadata = self.service.files().get(fileId=file_id, fields="mimeType, name").execute()
 
             original_mime_type = file_metadata.get("mimeType")
             file_name = file_metadata.get("name", "Unknown")
 
-            logger.info(
-                f"Reading file '{file_name}' ({file_id}) with mimeType: {original_mime_type}"
-            )
+            logger.info(f"Reading file '{file_name}' ({file_id}) with mimeType: {original_mime_type}")
 
             # Handle Google Workspace files by exporting
             if original_mime_type.startswith("application/vnd.google-apps."):
@@ -143,9 +129,7 @@ class DriveService(BaseGoogleService):
                 .execute()
             )
 
-            logger.info(
-                f"Successfully retrieved metadata for file: {file_metadata.get('name', 'Unknown')}"
-            )
+            logger.info(f"Successfully retrieved metadata for file: {file_metadata.get('name', 'Unknown')}")
             return file_metadata
 
         except Exception as e:
@@ -201,17 +185,13 @@ class DriveService(BaseGoogleService):
 
             created_folder = self.service.files().create(**create_params).execute()
 
-            logger.info(
-                f"Successfully created folder '{folder_name}' with ID: {created_folder.get('id')}"
-            )
+            logger.info(f"Successfully created folder '{folder_name}' with ID: {created_folder.get('id')}")
             return created_folder
 
         except Exception as e:
             return self.handle_api_error("create_folder", e)
 
-    def _export_google_file(
-        self, file_id: str, file_name: str, mime_type: str
-    ) -> dict[str, Any]:
+    def _export_google_file(self, file_id: str, file_name: str, mime_type: str) -> dict[str, Any]:
         """Export a Google Workspace file in an appropriate format."""
         # Determine export format
         export_mime_type = None
@@ -236,9 +216,7 @@ class DriveService(BaseGoogleService):
 
         # Export the file
         try:
-            request = self.service.files().export_media(
-                fileId=file_id, mimeType=export_mime_type, supportsAllDrives=True
-            )
+            request = self.service.files().export_media(fileId=file_id, mimeType=export_mime_type, supportsAllDrives=True)
 
             content_bytes = self._download_content(request)
             if isinstance(content_bytes, dict) and content_bytes.get("error"):
@@ -270,9 +248,7 @@ class DriveService(BaseGoogleService):
         except Exception as e:
             return self.handle_api_error("_export_google_file", e)
 
-    def _download_regular_file(
-        self, file_id: str, file_name: str, mime_type: str
-    ) -> dict[str, Any]:
+    def _download_regular_file(self, file_id: str, file_name: str, mime_type: str) -> dict[str, Any]:
         """Download a regular (non-Google Workspace) file."""
         request = self.service.files().get_media(fileId=file_id, supportsAllDrives=True)
 
@@ -286,9 +262,7 @@ class DriveService(BaseGoogleService):
                 content = content_bytes.decode("utf-8")
                 return {"mimeType": mime_type, "content": content, "encoding": "utf-8"}
             except UnicodeDecodeError:
-                logger.warning(
-                    f"UTF-8 decoding failed for file {file_id} ('{file_name}', {mime_type}). Using base64."
-                )
+                logger.warning(f"UTF-8 decoding failed for file {file_id} ('{file_name}', {mime_type}). Using base64.")
                 content = base64.b64encode(content_bytes).decode("utf-8")
                 return {
                     "mimeType": mime_type,
@@ -426,11 +400,7 @@ class DriveService(BaseGoogleService):
             # API allows pageSize up to 100 for drives.list
             actual_page_size = min(max(1, page_size), 100)
 
-            results = (
-                self.service.drives()
-                .list(pageSize=actual_page_size, fields="drives(id, name, kind)")
-                .execute()
-            )
+            results = self.service.drives().list(pageSize=actual_page_size, fields="drives(id, name, kind)").execute()
             drives = results.get("drives", [])
 
             # Filter for kind='drive#drive' just to be sure, though API should only return these

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/src/google_workspace_mcp/services/sheets_service.py

@@ -36,9 +36,7 @@ class SheetsService(BaseGoogleService):
         try:
             logger.info(f"Creating new Google Spreadsheet with title: '{title}'")
             spreadsheet_body = {"properties": {"title": title}}
-            spreadsheet = (
-                self.service.spreadsheets().create(body=spreadsheet_body).execute()
-            )
+            spreadsheet = self.service.spreadsheets().create(body=spreadsheet_body).execute()
             spreadsheet_id = spreadsheet.get("spreadsheetId")
             logger.info(
                 f"Successfully created spreadsheet: {spreadsheet.get('properties', {}).get('title')} (ID: {spreadsheet_id})"
@@ -73,15 +71,8 @@ class SheetsService(BaseGoogleService):
             or an error dictionary.
         """
         try:
-            logger.info(
-                f"Reading range '{range_a1}' from spreadsheet ID: {spreadsheet_id}"
-            )
-            result = (
-                self.service.spreadsheets()
-                .values()
-                .get(spreadsheetId=spreadsheet_id, range=range_a1)
-                .execute()
-            )
+            logger.info(f"Reading range '{range_a1}' from spreadsheet ID: {spreadsheet_id}")
+            result = self.service.spreadsheets().values().get(spreadsheetId=spreadsheet_id, range=range_a1).execute()
 
             # result will contain 'range', 'majorDimension', 'values'
             # 'values' is a list of lists.
@@ -91,23 +82,15 @@ class SheetsService(BaseGoogleService):
             return {
                 "spreadsheet_id": spreadsheet_id,
                 "range_requested": range_a1,  # The input range
-                "range_returned": result.get(
-                    "range"
-                ),  # The actual range returned by API
+                "range_returned": result.get("range"),  # The actual range returned by API
                 "major_dimension": result.get("majorDimension"),
-                "values": result.get(
-                    "values", []
-                ),  # Default to empty list if no values
+                "values": result.get("values", []),  # Default to empty list if no values
             }
         except HttpError as error:
-            logger.error(
-                f"Error reading range '{range_a1}' from spreadsheet {spreadsheet_id}: {error}"
-            )
+            logger.error(f"Error reading range '{range_a1}' from spreadsheet {spreadsheet_id}: {error}")
             return self.handle_api_error("read_range", error)
         except Exception as e:
-            logger.exception(
-                f"Unexpected error reading range '{range_a1}' from spreadsheet {spreadsheet_id}"
-            )
+            logger.exception(f"Unexpected error reading range '{range_a1}' from spreadsheet {spreadsheet_id}")
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -157,23 +140,17 @@ class SheetsService(BaseGoogleService):
                 f"Successfully wrote to range '{result.get('updatedRange')}' in spreadsheet ID: {spreadsheet_id}. Updated {result.get('updatedCells')} cells."
             )
             return {
-                "spreadsheet_id": result.get(
-                    "spreadsheetId"
-                ),  # Or use the input spreadsheet_id
+                "spreadsheet_id": result.get("spreadsheetId"),  # Or use the input spreadsheet_id
                 "updated_range": result.get("updatedRange"),
                 "updated_rows": result.get("updatedRows"),
                 "updated_columns": result.get("updatedColumns"),
                 "updated_cells": result.get("updatedCells"),
             }
         except HttpError as error:
-            logger.error(
-                f"Error writing to range '{range_a1}' in spreadsheet {spreadsheet_id}: {error}"
-            )
+            logger.error(f"Error writing to range '{range_a1}' in spreadsheet {spreadsheet_id}: {error}")
             return self.handle_api_error("write_range", error)
         except Exception as e:
-            logger.exception(
-                f"Unexpected error writing to range '{range_a1}' in spreadsheet {spreadsheet_id}"
-            )
+            logger.exception(f"Unexpected error writing to range '{range_a1}' in spreadsheet {spreadsheet_id}")
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -223,29 +200,17 @@ class SheetsService(BaseGoogleService):
                 .execute()
             )
             # result typically includes: spreadsheetId, tableRange (if appended to a table), updates (if named ranges/etc. were affected)
-            logger.info(
-                f"Successfully appended rows to spreadsheet ID: {spreadsheet_id}. Updates: {result.get('updates')}"
-            )
+            logger.info(f"Successfully appended rows to spreadsheet ID: {spreadsheet_id}. Updates: {result.get('updates')}")
             return {
-                "spreadsheet_id": result.get(
-                    "spreadsheetId"
-                ),  # Or use the input spreadsheet_id
-                "table_range_updated": result.get(
-                    "tableRange"
-                ),  # The range of the new data
-                "updates": result.get(
-                    "updates"
-                ),  # Info about other updates, e.g. to named ranges
+                "spreadsheet_id": result.get("spreadsheetId"),  # Or use the input spreadsheet_id
+                "table_range_updated": result.get("tableRange"),  # The range of the new data
+                "updates": result.get("updates"),  # Info about other updates, e.g. to named ranges
             }
         except HttpError as error:
-            logger.error(
-                f"Error appending rows to range '{range_a1}' in spreadsheet {spreadsheet_id}: {error}"
-            )
+            logger.error(f"Error appending rows to range '{range_a1}' in spreadsheet {spreadsheet_id}: {error}")
             return self.handle_api_error("append_rows", error)
         except Exception as e:
-            logger.exception(
-                f"Unexpected error appending rows to range '{range_a1}' in spreadsheet {spreadsheet_id}"
-            )
+            logger.exception(f"Unexpected error appending rows to range '{range_a1}' in spreadsheet {spreadsheet_id}")
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -266,35 +231,22 @@ class SheetsService(BaseGoogleService):
             A dictionary containing the cleared range and spreadsheet ID, or an error dictionary.
         """
         try:
-            logger.info(
-                f"Clearing range '{range_a1}' in spreadsheet ID: {spreadsheet_id}"
-            )
+            logger.info(f"Clearing range '{range_a1}' in spreadsheet ID: {spreadsheet_id}")
             # The body for clear is an empty JSON object {}.
             result = (
-                self.service.spreadsheets()
-                .values()
-                .clear(spreadsheetId=spreadsheet_id, range=range_a1, body={})
-                .execute()
+                self.service.spreadsheets().values().clear(spreadsheetId=spreadsheet_id, range=range_a1, body={}).execute()
             )
             # result typically includes: spreadsheetId, clearedRange
-            logger.info(
-                f"Successfully cleared range '{result.get('clearedRange')}' in spreadsheet ID: {spreadsheet_id}."
-            )
+            logger.info(f"Successfully cleared range '{result.get('clearedRange')}' in spreadsheet ID: {spreadsheet_id}.")
             return {
-                "spreadsheet_id": result.get(
-                    "spreadsheetId"
-                ),  # Or use the input spreadsheet_id
+                "spreadsheet_id": result.get("spreadsheetId"),  # Or use the input spreadsheet_id
                 "cleared_range": result.get("clearedRange"),
             }
         except HttpError as error:
-            logger.error(
-                f"Error clearing range '{range_a1}' from spreadsheet {spreadsheet_id}: {error}"
-            )
+            logger.error(f"Error clearing range '{range_a1}' from spreadsheet {spreadsheet_id}: {error}")
             return self.handle_api_error("clear_range", error)
         except Exception as e:
-            logger.exception(
-                f"Unexpected error clearing range '{range_a1}' from spreadsheet {spreadsheet_id}"
-            )
+            logger.exception(f"Unexpected error clearing range '{range_a1}' from spreadsheet {spreadsheet_id}")
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -315,16 +267,10 @@ class SheetsService(BaseGoogleService):
             or an error dictionary.
         """
         try:
-            logger.info(
-                f"Adding new sheet with title '{title}' to spreadsheet ID: {spreadsheet_id}"
-            )
+            logger.info(f"Adding new sheet with title '{title}' to spreadsheet ID: {spreadsheet_id}")
             requests = [{"addSheet": {"properties": {"title": title}}}]
             body = {"requests": requests}
-            response = (
-                self.service.spreadsheets()
-                .batchUpdate(spreadsheetId=spreadsheet_id, body=body)
-                .execute()
-            )
+            response = self.service.spreadsheets().batchUpdate(spreadsheetId=spreadsheet_id, body=body).execute()
 
             # The response contains a list of replies, one for each request.
             # The addSheet reply contains the properties of the new sheet.
@@ -354,14 +300,10 @@ class SheetsService(BaseGoogleService):
                 "sheet_properties": new_sheet_properties,
             }
         except HttpError as error:
-            logger.error(
-                f"Error adding sheet '{title}' to spreadsheet {spreadsheet_id}: {error}"
-            )
+            logger.error(f"Error adding sheet '{title}' to spreadsheet {spreadsheet_id}: {error}")
             return self.handle_api_error("add_sheet", error)
         except Exception as e:
-            logger.exception(
-                f"Unexpected error adding sheet '{title}' to spreadsheet {spreadsheet_id}"
-            )
+            logger.exception(f"Unexpected error adding sheet '{title}' to spreadsheet {spreadsheet_id}")
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -381,16 +323,10 @@ class SheetsService(BaseGoogleService):
             A dictionary indicating success (spreadsheetId and deleted sheetId) or an error dictionary.
         """
         try:
-            logger.info(
-                f"Deleting sheet ID: {sheet_id} from spreadsheet ID: {spreadsheet_id}"
-            )
+            logger.info(f"Deleting sheet ID: {sheet_id} from spreadsheet ID: {spreadsheet_id}")
             requests = [{"deleteSheet": {"sheetId": sheet_id}}]
             body = {"requests": requests}
-            response = (
-                self.service.spreadsheets()
-                .batchUpdate(spreadsheetId=spreadsheet_id, body=body)
-                .execute()
-            )
+            response = self.service.spreadsheets().batchUpdate(spreadsheetId=spreadsheet_id, body=body).execute()
 
             # A successful deleteSheet request usually doesn't return detailed content in the reply.
             # The overall response.spreadsheetId confirms the operation was on the correct spreadsheet.
@@ -403,14 +339,10 @@ class SheetsService(BaseGoogleService):
                 "success": True,
             }
         except HttpError as error:
-            logger.error(
-                f"Error deleting sheet ID {sheet_id} from spreadsheet {spreadsheet_id}: {error}"
-            )
+            logger.error(f"Error deleting sheet ID {sheet_id} from spreadsheet {spreadsheet_id}: {error}")
             return self.handle_api_error("delete_sheet", error)
         except Exception as e:
-            logger.exception(
-                f"Unexpected error deleting sheet ID {sheet_id} from spreadsheet {spreadsheet_id}"
-            )
+            logger.exception(f"Unexpected error deleting sheet ID {sheet_id} from spreadsheet {spreadsheet_id}")
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",
@@ -418,9 +350,7 @@ class SheetsService(BaseGoogleService):
                 "operation": "delete_sheet",
             }
 
-    def get_spreadsheet_metadata(
-        self, spreadsheet_id: str, fields: str | None = None
-    ) -> dict[str, Any] | None:
+    def get_spreadsheet_metadata(self, spreadsheet_id: str, fields: str | None = None) -> dict[str, Any] | None:
         """
         Retrieves metadata for a specific Google Spreadsheet.
 
@@ -434,30 +364,21 @@ class SheetsService(BaseGoogleService):
         """
         try:
             logger.info(
-                f"Fetching metadata for spreadsheet ID: {spreadsheet_id}"
-                + (f" with fields: {fields}" if fields else "")
+                f"Fetching metadata for spreadsheet ID: {spreadsheet_id}" + (f" with fields: {fields}" if fields else "")
             )
             if fields is None:
                 fields = "spreadsheetId,properties,sheets(properties(sheetId,title,index,sheetType,gridProperties))"
 
-            spreadsheet_metadata = (
-                self.service.spreadsheets()
-                .get(spreadsheetId=spreadsheet_id, fields=fields)
-                .execute()
-            )
+            spreadsheet_metadata = self.service.spreadsheets().get(spreadsheetId=spreadsheet_id, fields=fields).execute()
             logger.info(
-                f"Successfully fetched metadata for spreadsheet: {spreadsheet_metadata.get('properties',{}).get('title')}"
+                f"Successfully fetched metadata for spreadsheet: {spreadsheet_metadata.get('properties', {}).get('title')}"
             )
             return spreadsheet_metadata
         except HttpError as error:
-            logger.error(
-                f"Error fetching metadata for spreadsheet ID {spreadsheet_id}: {error}"
-            )
+            logger.error(f"Error fetching metadata for spreadsheet ID {spreadsheet_id}: {error}")
             return self.handle_api_error("get_spreadsheet_metadata", error)
         except Exception as e:
-            logger.exception(
-                f"Unexpected error fetching metadata for spreadsheet ID {spreadsheet_id}"
-            )
+            logger.exception(f"Unexpected error fetching metadata for spreadsheet ID {spreadsheet_id}")
             return {
                 "error": True,
                 "error_type": "unexpected_service_error",

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/src/google_workspace_mcp/tools/docs_tools.py

@@ -37,9 +37,7 @@ async def docs_create_document(title: str) -> dict[str, Any]:
         raise ValueError(result.get("message", "Error creating document"))
 
     if not result or not result.get("document_id"):
-        raise ValueError(
-            f"Failed to create document '{title}' or did not receive a document ID."
-        )
+        raise ValueError(f"Failed to create document '{title}' or did not receive a document ID.")
 
     return result
 
@@ -59,9 +57,7 @@ async def docs_get_document_metadata(document_id: str) -> dict[str, Any]:
         A dictionary containing the document's 'document_id', 'title', and 'document_link',
         or an error message.
     """
-    logger.info(
-        f"Executing docs_get_document_metadata tool for document_id: '{document_id}'"
-    )
+    logger.info(f"Executing docs_get_document_metadata tool for document_id: '{document_id}'")
     if not document_id or not document_id.strip():
         raise ValueError("Document ID cannot be empty.")
 
@@ -92,9 +88,7 @@ async def docs_get_content_as_markdown(document_id: str) -> dict[str, Any]:
         A dictionary containing the 'document_id' and 'markdown_content',
         or an error message.
     """
-    logger.info(
-        f"Executing docs_get_content_as_markdown tool for document_id: '{document_id}'"
-    )
+    logger.info(f"Executing docs_get_content_as_markdown tool for document_id: '{document_id}'")
     if not document_id or not document_id.strip():
         raise ValueError("Document ID cannot be empty.")
 
@@ -102,14 +96,10 @@ async def docs_get_content_as_markdown(document_id: str) -> dict[str, Any]:
     result = docs_service.get_document_content_as_markdown(document_id=document_id)
 
     if isinstance(result, dict) and result.get("error"):
-        raise ValueError(
-            result.get("message", "Error retrieving document content as Markdown")
-        )
+        raise ValueError(result.get("message", "Error retrieving document content as Markdown"))
 
     if not result or "markdown_content" not in result:
-        raise ValueError(
-            f"Failed to retrieve Markdown content for document '{document_id}'."
-        )
+        raise ValueError(f"Failed to retrieve Markdown content for document '{document_id}'.")
 
     return result
 
@@ -118,9 +108,7 @@ async def docs_get_content_as_markdown(document_id: str) -> dict[str, Any]:
     name="docs_append_text",
     description="Appends text to the end of a specified Google Document.",
 )
-async def docs_append_text(
-    document_id: str, text: str, ensure_newline: bool = True
-) -> dict[str, Any]:
+async def docs_append_text(document_id: str, text: str, ensure_newline: bool = True) -> dict[str, Any]:
     """
     Appends the given text to the end of the specified Google Document.
 
@@ -139,9 +127,7 @@ async def docs_append_text(
     # Text can be empty, that's fine.
 
     docs_service = DocsService()
-    result = docs_service.append_text(
-        document_id=document_id, text=text, ensure_newline=ensure_newline
-    )
+    result = docs_service.append_text(document_id=document_id, text=text, ensure_newline=ensure_newline)
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error appending text to document"))
@@ -156,9 +142,7 @@ async def docs_append_text(
     name="docs_prepend_text",
     description="Prepends text to the beginning of a specified Google Document.",
 )
-async def docs_prepend_text(
-    document_id: str, text: str, ensure_newline: bool = True
-) -> dict[str, Any]:
+async def docs_prepend_text(document_id: str, text: str, ensure_newline: bool = True) -> dict[str, Any]:
     """
     Prepends the given text to the beginning of the specified Google Document.
 
@@ -177,9 +161,7 @@ async def docs_prepend_text(
     # Text can be empty, that's fine.
 
     docs_service = DocsService()
-    result = docs_service.prepend_text(
-        document_id=document_id, text=text, ensure_newline=ensure_newline
-    )
+    result = docs_service.prepend_text(document_id=document_id, text=text, ensure_newline=ensure_newline)
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error prepending text to document"))
@@ -213,17 +195,13 @@ async def docs_insert_text(
     Returns:
         A dictionary indicating success or an error message.
     """
-    logger.info(
-        f"Executing docs_insert_text tool for document_id: '{document_id}' at index: {index}"
-    )
+    logger.info(f"Executing docs_insert_text tool for document_id: '{document_id}' at index: {index}")
     if not document_id or not document_id.strip():
         raise ValueError("Document ID cannot be empty.")
     # Text can be empty, that's a valid insertion (though perhaps not useful).
 
     docs_service = DocsService()
-    result = docs_service.insert_text(
-        document_id=document_id, text=text, index=index, segment_id=segment_id
-    )
+    result = docs_service.insert_text(document_id=document_id, text=text, index=index, segment_id=segment_id)
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error inserting text into document"))
@@ -253,9 +231,7 @@ async def docs_batch_update(document_id: str, requests: list[dict]) -> dict[str,
         A dictionary containing the API response from the batchUpdate call (includes replies for each request),
         or an error message.
     """
-    logger.info(
-        f"Executing docs_batch_update tool for document_id: '{document_id}' with {len(requests)} requests."
-    )
+    logger.info(f"Executing docs_batch_update tool for document_id: '{document_id}' with {len(requests)} requests.")
     if not document_id or not document_id.strip():
         raise ValueError("Document ID cannot be empty.")
     if not isinstance(requests, list):
@@ -267,9 +243,7 @@ async def docs_batch_update(document_id: str, requests: list[dict]) -> dict[str,
     result = docs_service.batch_update(document_id=document_id, requests=requests)
 
     if isinstance(result, dict) and result.get("error"):
-        raise ValueError(
-            result.get("message", "Error executing batch update on document")
-        )
+        raise ValueError(result.get("message", "Error executing batch update on document"))
 
     if not result:  # Should be caught by error dict check
         raise ValueError(f"Failed to execute batch update on document '{document_id}'.")

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/src/google_workspace_mcp/tools/drive.py

@@ -42,9 +42,7 @@ async def drive_search_files(
         raise ValueError("Query cannot be empty")
 
     drive_service = DriveService()
-    files = drive_service.search_files(
-        query=query, page_size=page_size, shared_drive_id=shared_drive_id
-    )
+    files = drive_service.search_files(query=query, page_size=page_size, shared_drive_id=shared_drive_id)
 
     if isinstance(files, dict) and files.get("error"):
         raise ValueError(f"Search failed: {files.get('message', 'Unknown error')}")
@@ -156,9 +154,7 @@ async def drive_create_folder(
     )
 
     if isinstance(result, dict) and result.get("error"):
-        raise ValueError(
-            f"Folder creation failed: {result.get('message', 'Unknown error')}"
-        )
+        raise ValueError(f"Folder creation failed: {result.get('message', 'Unknown error')}")
 
     return result
 

{google_workspace_mcp-1.0.0 → google_workspace_mcp-1.0.1}/src/google_workspace_mcp/tools/sheets_tools.py

@@ -37,9 +37,7 @@ async def sheets_create_spreadsheet(title: str) -> dict[str, Any]:
         raise ValueError(result.get("message", "Error creating spreadsheet"))
 
     if not result or not result.get("spreadsheet_id"):
-        raise ValueError(
-            f"Failed to create spreadsheet '{title}' or did not receive a spreadsheet ID."
-        )
+        raise ValueError(f"Failed to create spreadsheet '{title}' or did not receive a spreadsheet ID.")
 
     return result
 
@@ -61,9 +59,7 @@ async def sheets_read_range(spreadsheet_id: str, range_a1: str) -> dict[str, Any
         A dictionary containing the range and a list of lists representing the cell values,
         or an error message.
     """
-    logger.info(
-        f"Executing sheets_read_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'"
-    )
+    logger.info(f"Executing sheets_read_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'")
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not range_a1 or not range_a1.strip():
@@ -75,12 +71,8 @@ async def sheets_read_range(spreadsheet_id: str, range_a1: str) -> dict[str, Any
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error reading range from spreadsheet"))
 
-    if (
-        not result or "values" not in result
-    ):  # Check for 'values' as it's key for successful read
-        raise ValueError(
-            f"Failed to read range '{range_a1}' from spreadsheet '{spreadsheet_id}'."
-        )
+    if not result or "values" not in result:  # Check for 'values' as it's key for successful read
+        raise ValueError(f"Failed to read range '{range_a1}' from spreadsheet '{spreadsheet_id}'.")
 
     return result
 
@@ -110,9 +102,7 @@ async def sheets_write_range(
         A dictionary detailing the update (updated range, number of cells, etc.),
         or an error message.
     """
-    logger.info(
-        f"Executing sheets_write_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'"
-    )
+    logger.info(f"Executing sheets_write_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'")
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not range_a1 or not range_a1.strip():
@@ -134,9 +124,7 @@ async def sheets_write_range(
         raise ValueError(result.get("message", "Error writing to range in spreadsheet"))
 
     if not result or not result.get("updated_range"):
-        raise ValueError(
-            f"Failed to write to range '{range_a1}' in spreadsheet '{spreadsheet_id}'."
-        )
+        raise ValueError(f"Failed to write to range '{range_a1}' in spreadsheet '{spreadsheet_id}'.")
 
     return result
 
@@ -167,9 +155,7 @@ async def sheets_append_rows(
         A dictionary detailing the append operation (e.g., range of appended data),
         or an error message.
     """
-    logger.info(
-        f"Executing sheets_append_rows tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'"
-    )
+    logger.info(f"Executing sheets_append_rows tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'")
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not range_a1 or not range_a1.strip():
@@ -181,9 +167,7 @@ async def sheets_append_rows(
     if value_input_option not in ["USER_ENTERED", "RAW"]:
         raise ValueError("value_input_option must be either 'USER_ENTERED' or 'RAW'.")
     if insert_data_option not in ["INSERT_ROWS", "OVERWRITE"]:
-        raise ValueError(
-            "insert_data_option must be either 'INSERT_ROWS' or 'OVERWRITE'."
-        )
+        raise ValueError("insert_data_option must be either 'INSERT_ROWS' or 'OVERWRITE'.")
 
     sheets_service = SheetsService()
     result = sheets_service.append_rows(
@@ -198,9 +182,7 @@ async def sheets_append_rows(
         raise ValueError(result.get("message", "Error appending rows to spreadsheet"))
 
     if not result:  # Check for empty or None result as well
-        raise ValueError(
-            f"Failed to append rows to range '{range_a1}' in spreadsheet '{spreadsheet_id}'."
-        )
+        raise ValueError(f"Failed to append rows to range '{range_a1}' in spreadsheet '{spreadsheet_id}'.")
 
     return result
 
@@ -221,26 +203,20 @@ async def sheets_clear_range(spreadsheet_id: str, range_a1: str) -> dict[str, An
     Returns:
         A dictionary confirming the cleared range, or an error message.
     """
-    logger.info(
-        f"Executing sheets_clear_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'"
-    )
+    logger.info(f"Executing sheets_clear_range tool for spreadsheet_id: '{spreadsheet_id}', range: '{range_a1}'")
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not range_a1 or not range_a1.strip():
         raise ValueError("Range (A1 notation) cannot be empty.")
 
     sheets_service = SheetsService()
-    result = sheets_service.clear_range(
-        spreadsheet_id=spreadsheet_id, range_a1=range_a1
-    )
+    result = sheets_service.clear_range(spreadsheet_id=spreadsheet_id, range_a1=range_a1)
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error clearing range in spreadsheet"))
 
     if not result or not result.get("cleared_range"):
-        raise ValueError(
-            f"Failed to clear range '{range_a1}' in spreadsheet '{spreadsheet_id}'."
-        )
+        raise ValueError(f"Failed to clear range '{range_a1}' in spreadsheet '{spreadsheet_id}'.")
 
     return result
 
@@ -261,9 +237,7 @@ async def sheets_add_sheet(spreadsheet_id: str, title: str) -> dict[str, Any]:
         A dictionary containing properties of the newly created sheet (like sheetId, title, index),
         or an error message.
     """
-    logger.info(
-        f"Executing sheets_add_sheet tool for spreadsheet_id: '{spreadsheet_id}', title: '{title}'"
-    )
+    logger.info(f"Executing sheets_add_sheet tool for spreadsheet_id: '{spreadsheet_id}', title: '{title}'")
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not title or not title.strip():
@@ -276,9 +250,7 @@ async def sheets_add_sheet(spreadsheet_id: str, title: str) -> dict[str, Any]:
         raise ValueError(result.get("message", "Error adding sheet to spreadsheet"))
 
     if not result or not result.get("sheet_properties"):
-        raise ValueError(
-            f"Failed to add sheet '{title}' to spreadsheet '{spreadsheet_id}'."
-        )
+        raise ValueError(f"Failed to add sheet '{title}' to spreadsheet '{spreadsheet_id}'.")
 
     return result
 
@@ -298,25 +270,19 @@ async def sheets_delete_sheet(spreadsheet_id: str, sheet_id: int) -> dict[str, A
     Returns:
         A dictionary confirming the deletion or an error message.
     """
-    logger.info(
-        f"Executing sheets_delete_sheet tool for spreadsheet_id: '{spreadsheet_id}', sheet_id: {sheet_id}"
-    )
+    logger.info(f"Executing sheets_delete_sheet tool for spreadsheet_id: '{spreadsheet_id}', sheet_id: {sheet_id}")
     if not spreadsheet_id or not spreadsheet_id.strip():
         raise ValueError("Spreadsheet ID cannot be empty.")
     if not isinstance(sheet_id, int):
         raise ValueError("Sheet ID must be an integer.")
 
     sheets_service = SheetsService()
-    result = sheets_service.delete_sheet(
-        spreadsheet_id=spreadsheet_id, sheet_id=sheet_id
-    )
+    result = sheets_service.delete_sheet(spreadsheet_id=spreadsheet_id, sheet_id=sheet_id)
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error deleting sheet from spreadsheet"))
 
     if not result or not result.get("success"):
-        raise ValueError(
-            f"Failed to delete sheet ID '{sheet_id}' from spreadsheet '{spreadsheet_id}'."
-        )
+        raise ValueError(f"Failed to delete sheet ID '{sheet_id}' from spreadsheet '{spreadsheet_id}'.")
 
     return result