google-workspace-mcp 1.1.5__py3-none-any.whl → 1.2.0__py3-none-any.whl

google_workspace_mcp/services/sheets_service.py

@@ -36,7 +36,9 @@ 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})"
@@ -71,8 +73,15 @@ 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.
@@ -82,15 +91,23 @@ 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",
@@ -140,17 +157,23 @@ 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",
@@ -200,17 +223,29 @@ 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",
@@ -231,22 +266,35 @@ 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",
@@ -267,10 +315,16 @@ 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.
@@ -300,10 +354,14 @@ 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",
@@ -323,10 +381,16 @@ 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.
@@ -339,10 +403,14 @@ 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",
@@ -350,7 +418,9 @@ 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.
 
@@ -364,24 +434,192 @@ 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')}"
             )
             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",
                 "message": str(e),
                 "operation": "get_spreadsheet_metadata",
             }
+
+    def create_chart_on_sheet(
+        self,
+        spreadsheet_id: str,
+        sheet_id: int,
+        chart_type: str,
+        num_rows: int,
+        num_cols: int,
+        title: str,
+    ) -> dict[str, Any] | None:
+        """
+        Adds a new chart to a sheet, handling different chart types correctly.
+
+        Args:
+            spreadsheet_id: The ID of the Google Spreadsheet.
+            sheet_id: The numeric ID of the sheet to add the chart to.
+            chart_type: The API-specific type of chart ('COLUMN', 'LINE', 'PIE_CHART').
+            num_rows: The number of rows in the data range.
+            num_cols: The number of columns in the data range.
+            title: The title of the chart.
+
+        Returns:
+            A dictionary containing the properties of the newly created chart or an error dictionary.
+        """
+        try:
+            logger.info(f"Constructing spec for chart '{title}' of type '{chart_type}'")
+
+            chart_spec = {"title": title}
+
+            if chart_type == "PIE_CHART":
+                chart_spec["pieChart"] = {
+                    "domain": {
+                        "sourceRange": {
+                            "sources": [
+                                {
+                                    "sheetId": sheet_id,
+                                    "startRowIndex": 0,
+                                    "endRowIndex": num_rows,
+                                    "startColumnIndex": 0,
+                                    "endColumnIndex": 1,
+                                }
+                            ]
+                        }
+                    },
+                    "series": {
+                        "sourceRange": {
+                            "sources": [
+                                {
+                                    "sheetId": sheet_id,
+                                    "startRowIndex": 0,
+                                    "endRowIndex": num_rows,
+                                    "startColumnIndex": 1,
+                                    "endColumnIndex": 2,
+                                }
+                            ]
+                        }
+                    },
+                    "legendPosition": "LABELED_LEGEND",
+                }
+            else:  # For BAR, COLUMN, LINE charts
+                # --- START OF FIX: Correctly structure the domain object ---
+                domain_spec = {
+                    "domain": {
+                        "sourceRange": {
+                            "sources": [
+                                {
+                                    "sheetId": sheet_id,
+                                    "startRowIndex": 0,
+                                    "endRowIndex": num_rows,
+                                    "startColumnIndex": 0,
+                                    "endColumnIndex": 1,
+                                }
+                            ]
+                        }
+                    }
+                }
+                # --- END OF FIX ---
+
+                series = []
+                for i in range(1, num_cols):
+                    series.append(
+                        {
+                            "series": {
+                                "sourceRange": {
+                                    "sources": [
+                                        {
+                                            "sheetId": sheet_id,
+                                            "startRowIndex": 0,
+                                            "endRowIndex": num_rows,
+                                            "startColumnIndex": i,
+                                            "endColumnIndex": i + 1,
+                                        }
+                                    ]
+                                }
+                            },
+                            "targetAxis": "LEFT_AXIS",
+                        }
+                    )
+
+                chart_spec["basicChart"] = {
+                    "chartType": chart_type,
+                    "legendPosition": "BOTTOM_LEGEND",
+                    "axis": [
+                        {"position": "BOTTOM_AXIS"},
+                        {"position": "LEFT_AXIS"},
+                    ],
+                    "domains": [domain_spec],  # Use the corrected domain object
+                    "series": series,
+                }
+
+            requests = [
+                {
+                    "addChart": {
+                        "chart": {
+                            "spec": chart_spec,
+                            "position": {
+                                "overlayPosition": {
+                                    "anchorCell": {
+                                        "sheetId": sheet_id,
+                                        "rowIndex": num_rows + 2,
+                                        "columnIndex": 0,
+                                    },
+                                }
+                            },
+                        }
+                    }
+                }
+            ]
+
+            body = {"requests": requests}
+            # The google-api-python-client expects snake_case keys in the body,
+            # so we'll convert our camelCase spec to snake_case before sending.
+            # This is a good practice for robustness.
+            import humps
+
+            snake_body = humps.decamelize(body)
+
+            response = (
+                self.service.spreadsheets()
+                .batchUpdate(spreadsheetId=spreadsheet_id, body=snake_body)
+                .execute()
+            )
+
+            new_chart_properties = (
+                response.get("replies", [{}])[0].get("addChart", {}).get("chart")
+            )
+            if not new_chart_properties:
+                raise ValueError("Failed to create chart or parse response.")
+
+            logger.info(
+                f"Successfully created chart with ID: {new_chart_properties.get('chartId')}"
+            )
+            return new_chart_properties
+
+        except HttpError as error:
+            logger.error(f"Google API error in create_chart_on_sheet: {error.content}")
+            return self.handle_api_error("create_chart_on_sheet", error)
+        except Exception as e:
+            return self.handle_api_error("create_chart_on_sheet", e)