universal-mcp-applications 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

universal_mcp/applications/google_sheet/app.py

@@ -21,18 +21,18 @@ class GoogleSheetApp(APIApplication):
 
     def create_spreadsheet(self, title: str) -> dict[str, Any]:
         """
-        Creates a new blank Google Spreadsheet with the specified title and returns the API response.
-
+        Creates a new, blank Google Spreadsheet file with a specified title. This function generates a completely new document, unlike `add_sheet` which adds a tab to an existing spreadsheet. It returns the API response containing the new spreadsheet's metadata.
+        
         Args:
             title: String representing the desired title for the new spreadsheet
-
+        
         Returns:
             Dictionary containing the full response from the Google Sheets API, including the spreadsheet's metadata and properties
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid authentication, network issues, or API limitations
             ValueError: When the title parameter is empty or contains invalid characters
-
+        
         Tags:
             create, spreadsheet, google-sheets, api, important
         """
@@ -41,21 +41,21 @@ class GoogleSheetApp(APIApplication):
         response = self._post(url, data=spreadsheet_data)
         return self._handle_response(response)
 
-    def get_spreadsheet(self, spreadsheet_id: str) -> dict[str, Any]:
+    def get_spreadsheet_metadata(self, spreadsheet_id: str) -> dict[str, Any]:
         """
-        Retrieves detailed information about a specific Google Spreadsheet using its ID  excluding cell data.
-
+        Retrieves a spreadsheet's metadata and structural properties, such as sheet names, IDs, and named ranges, using its unique ID. This function intentionally excludes cell data, distinguishing it from `get_values` which fetches the actual content within the cells.
+        
         Args:
             spreadsheet_id: The unique identifier of the Google Spreadsheet to retrieve (found in the spreadsheet's URL)
-
+        
         Returns:
             A dictionary containing the full spreadsheet metadata and contents, including properties, sheets, named ranges, and other spreadsheet-specific information from the Google Sheets API
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid spreadsheet_id or insufficient permissions
             ConnectionError: When there's a network connectivity issue
             ValueError: When the response cannot be parsed as JSON
-
+        
         Tags:
             get, retrieve, spreadsheet, api, metadata, read, important
         """
@@ -72,22 +72,22 @@ class GoogleSheetApp(APIApplication):
         dateTimeRenderOption: str | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves values from a specific range in a Google Spreadsheet.
-
+        Retrieves cell values from a single, specified A1 notation range in a Google Spreadsheet. Unlike `batch_get_values` which fetches multiple ranges, this function is for a singular query and provides options to control the data's output format (e.g., rows vs. columns, formatted vs. raw values).
+        
         Args:
             spreadsheetId: The unique identifier of the Google Spreadsheet to retrieve values from
             range: A1 notation range string (e.g., 'Sheet1!A1:B2')
             majorDimension: The major dimension that results should use. "ROWS" or "COLUMNS". Example: "ROWS"
             valueRenderOption: How values should be represented in the output. "FORMATTED_VALUE", "UNFORMATTED_VALUE", or "FORMULA". Example: "FORMATTED_VALUE"
             dateTimeRenderOption: How dates, times, and durations should be represented. "SERIAL_NUMBER" or "FORMATTED_STRING". Example: "FORMATTED_STRING"
-
+        
         Returns:
             A dictionary containing the API response with the requested spreadsheet values and metadata
-
+        
         Raises:
             HTTPError: If the API request fails due to invalid spreadsheet_id, insufficient permissions, or invalid range format
             ValueError: If the spreadsheet_id is empty or invalid
-
+        
         Tags:
             get, read, spreadsheet, values, important
         """
@@ -104,23 +104,23 @@ class GoogleSheetApp(APIApplication):
         response = self._get(url, params=params)
         return self._handle_response(response)
 
-    def batch_get_values(
+    def batch_get_values_by_range(
         self, spreadsheet_id: str, ranges: list[str] | None = None
     ) -> dict[str, Any]:
         """
-        Retrieves multiple ranges of values from a Google Spreadsheet in a single batch request.
-
+        Efficiently retrieves values from multiple specified ranges in a Google Spreadsheet using a single batch API request. This method is distinct from `get_values`, which fetches a single range, and `batch_get_values_by_data_filter`, which uses filtering criteria instead of predefined A1 notation ranges.
+        
         Args:
             spreadsheet_id: The unique identifier of the Google Spreadsheet to retrieve values from
             ranges: Optional list of A1 notation or R1C1 notation range strings (e.g., ['Sheet1!A1:B2', 'Sheet2!C3:D4']). If None, returns values from the entire spreadsheet
-
+        
         Returns:
             A dictionary containing the API response with the requested spreadsheet values and metadata
-
+        
         Raises:
             HTTPError: If the API request fails due to invalid spreadsheet_id, insufficient permissions, or invalid range format
             ValueError: If the spreadsheet_id is empty or invalid
-
+        
         Tags:
             get, batch, read, spreadsheet, values
         """
@@ -144,11 +144,11 @@ class GoogleSheetApp(APIApplication):
         response_ranges: list[str] | None = None,
     ) -> dict[str, Any]:
         """
-        Inserts new rows or columns into a Google Sheet at a specific position within the sheet.
-
+        Inserts empty rows or columns at a specified index, shifting existing content. Unlike `append_dimensions`, which adds to the end, this function is used to insert space within the data grid. Returns the API response containing update details.
+        
         This function inserts empty rows or columns at a specified location, shifting existing content.
         Use this when you need to add rows/columns in the middle of your data.
-
+        
         Args:
             spreadsheet_id: The ID of the spreadsheet to update. Example: "abc123spreadsheetId"
             sheet_id: The ID of the sheet where the dimensions will be inserted. Example: 0
@@ -159,14 +159,14 @@ class GoogleSheetApp(APIApplication):
             include_spreadsheet_in_response: True if the updated spreadsheet should be included in the response. Example: True
             response_include_grid_data: True if grid data should be included in the response (if includeSpreadsheetInResponse is true). Example: True
             response_ranges: Limits the ranges of the spreadsheet to include in the response. Example: ["Sheet1!A1:B10"]
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with update details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or dimension is not "ROWS" or "COLUMNS"
-
+        
         Tags:
             insert, modify, spreadsheet, rows, columns, dimensions, important
         """
@@ -223,24 +223,24 @@ class GoogleSheetApp(APIApplication):
         length: int,
     ) -> dict[str, Any]:
         """
-        Appends empty rows or columns to the end of a Google Sheet.
-
+        Adds a specified number of empty rows or columns to the end of a designated sheet. Unlike `insert_dimensions`, which adds dimensions at a specific index, this function exclusively extends the sheet's boundaries at the bottom or to the right without affecting existing content.
+        
         This function adds empty rows or columns to the end of the sheet without affecting existing content.
         Use this when you need to extend the sheet with additional space at the bottom or right.
-
+        
         Args:
             spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
             sheet_id: The ID of the sheet within the spreadsheet (0 for first sheet)
             dimension: The type of dimension to append - "ROWS" or "COLUMNS"
             length: The number of rows or columns to append to the end
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with update details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty, dimension is not "ROWS" or "COLUMNS", or length is not positive
-
+        
         Tags:
             append, modify, spreadsheet, rows, columns, dimensions, important
         """
@@ -282,9 +282,8 @@ class GoogleSheetApp(APIApplication):
         response_ranges: list[str] | None = None,
     ) -> dict[str, Any]:
         """
-        Tool to delete specified rows or columns from a sheet in a google spreadsheet. use when you need to remove a range of rows or columns.
-        or Use this when you need to remove unwanted rows or columns from your data.
-
+        Deletes a specified range of rows or columns from a sheet, permanently removing them and shifting subsequent cells. This alters the sheet's structure, unlike `clear_values` which only removes cell content. It complements `insert_dimensions` and `append_dimensions` for structural modifications.
+        
         Args:
             spreadsheet_id: The ID of the spreadsheet. Example: "abc123xyz789"
             sheet_id: The ID of the sheet from which to delete the dimension. Example: 0 for first sheet
@@ -294,14 +293,14 @@ class GoogleSheetApp(APIApplication):
             include_spreadsheet_in_response: Determines if the update response should include the spreadsheet resource. Example: True
             response_include_grid_data: True if grid data should be returned. This parameter is ignored if a field mask was set in the request. Example: True
             response_ranges: Limits the ranges of cells included in the response spreadsheet. Example: ["Sheet1!A1:B2", "Sheet2!C:C"]
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with update details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty, dimension is not "ROWS" or "COLUMNS", or indices are invalid
-
+        
         Tags:
             delete, modify, spreadsheet, rows, columns, dimensions, important
         """
@@ -372,8 +371,8 @@ class GoogleSheetApp(APIApplication):
         responseIncludeGridData: bool = False,
     ) -> dict[str, Any]:
         """
-        Adds a new sheet (worksheet) to a spreadsheet. use this tool to create a new tab within an existing google sheet, optionally specifying its title, index, size, and other properties.
-
+        Adds a new worksheet (tab) to an existing Google Spreadsheet. Allows customization of the new sheet's properties, including its title, index position, size (rows/columns), and visibility. This differs from `create_spreadsheet`, which creates a new spreadsheet file entirely.
+        
         Args:
             spreadsheetId: The ID of the spreadsheet to add the sheet to. This is the long string of characters in the URL of your Google Sheet. Example: "abc123xyz789"
             title: The name of the sheet. Example: "Q3 Report"
@@ -392,14 +391,14 @@ class GoogleSheetApp(APIApplication):
             columnGroupControlAfter: True if the column group control toggle is shown after the group, false if before.
             includeSpreadsheetInResponse: Whether the response should include the entire spreadsheet resource. Defaults to false.
             responseIncludeGridData: True if grid data should be returned. This parameter is ignored if includeSpreadsheetInResponse is false. Defaults to false.
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with the new sheet details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or invalid parameters are provided
-
+        
         Tags:
             add, sheet, spreadsheet, create
         """
@@ -492,11 +491,11 @@ class GoogleSheetApp(APIApplication):
         y_axis_title: str | None = None,
     ) -> dict[str, Any]:
         """
-        Adds a basic chart to a Google Spreadsheet like a column chart, bar chart, line chart and  area chart.
-
+        Adds various axis-based charts (e.g., column, bar, line, area) to a spreadsheet from specified data ranges. The chart can be placed on a new sheet or positioned on an existing one. This is distinct from `add_pie_chart`, which creates proportional visualizations instead of axis-based charts.
+        
         This function creates various types of charts from the specified data ranges and places it in a new sheet or existing sheet.
         Use this when you need to visualize data in different chart formats.
-
+        
         Args:
             spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
             source_sheet_id: The ID of the sheet containing the source data
@@ -508,14 +507,14 @@ class GoogleSheetApp(APIApplication):
             chart_position: Optional positioning for chart when new_sheet=False. Example: {"overlayPosition": {"anchorCell": {"sheetId": 0, "rowIndex": 10, "columnIndex": 5}, "offsetXPixels": 0, "offsetYPixels": 0, "widthPixels": 600, "heightPixels": 400}}
             x_axis_title: Optional title for the X-axis (bottom axis). If not provided, defaults to "Categories"
             y_axis_title: Optional title for the Y-axis (left axis). If not provided, defaults to "Values"
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with the chart details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or invalid parameters are provided
-
+        
         Tags:
             add, chart, basic-chart, visualization
         """
@@ -639,11 +638,11 @@ class GoogleSheetApp(APIApplication):
         pie_hole: float | None = None,
     ) -> dict[str, Any]:
         """
-        Adds a pie chart to a Google Spreadsheet.
-
+        Adds a pie or donut chart to a Google Spreadsheet from a specified data range. Unlike the more general `add_basic_chart`, this function is specialized for visualizing data as proportions of a whole and supports pie-specific options like creating a donut chart via the `pie_hole` parameter.
+        
         This function creates a pie chart from the specified data range and places it in a new sheet or existing sheet.
         Use this when you need to visualize data as proportions of a whole.
-
+        
         Args:
             spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
             source_sheet_id: The ID of the sheet containing the source data
@@ -653,14 +652,14 @@ class GoogleSheetApp(APIApplication):
             chart_position: Optional positioning for chart when new_sheet=False. Example: {"overlayPosition": {"anchorCell": {"sheetId": 0, "rowIndex": 10, "columnIndex": 5}, "offsetXPixels": 0, "offsetYPixels": 0, "widthPixels": 600, "heightPixels": 400}}
             legend_position: Position of the legend. Options: "BOTTOM_LEGEND", "LEFT_LEGEND", "RIGHT_LEGEND", "TOP_LEGEND", "NO_LEGEND"
             pie_hole: Optional hole size for creating a donut chart (0.0 to 1.0). 0.0 = solid pie, 0.5 = 50% hole
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with the chart details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or invalid parameters are provided
-
+        
         Tags:
             add, chart, pie, visualization
         """
@@ -759,11 +758,11 @@ class GoogleSheetApp(APIApplication):
         column_properties: list[dict] | None = None,
     ) -> dict[str, Any]:
         """
-        Adds a table to a Google Spreadsheet.
-
+        Creates a structured table within a specified range on a Google Sheet. Defines the table's name, ID, and dimensions, and can optionally configure column properties like data types and validation rules. This action creates a formal table object, distinct from functions that only write cell values.
+        
         This function creates a table with specified properties and column types.
         Use this when you need to create structured data with headers, footers, and column types.
-
+        
         Args:
             spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
             sheet_id: The ID of the sheet where the table will be created
@@ -776,11 +775,11 @@ class GoogleSheetApp(APIApplication):
             column_properties: Optional list of column properties with types and validation rules. Valid column types: "TEXT", "PERCENT", "DROPDOWN", "DOUBLE", "CURRENCY", "DATE", "TIME", "DATE_TIME". Example: [{"columnIndex": 0, "columnName": "Model Number", "columnType": "TEXT"}, {"columnIndex": 1, "columnName": "Sales - Jan", "columnType": "DOUBLE"}, {"columnIndex": 2, "columnName": "Price", "columnType": "CURRENCY"}, {"columnIndex": 3, "columnName": "Progress", "columnType": "PERCENT"}, {"columnIndex": 4, "columnName": "Created Date", "columnType": "DATE"}, {"columnIndex": 5, "columnName": "Status", "columnType": "DROPDOWN", "dataValidationRule": {"condition": {"type": "ONE_OF_LIST", "values": [{"userEnteredValue": "Active"}, {"userEnteredValue": "Inactive"}]}}}]
         Returns:
             A dictionary containing the Google Sheets API response with the table details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or invalid parameters are provided
-
+        
         Tags:
             add, table, structured-data
         """
@@ -865,11 +864,11 @@ class GoogleSheetApp(APIApplication):
         column_properties: list[dict] | None = None,
     ) -> dict[str, Any]:
         """
-        Updates an existing table in a Google Spreadsheet.
-
+        Modifies properties of an existing table within a Google Sheet, such as its name, data range, or column specifications. This function updates the table's structural metadata, distinguishing it from `update_values` which alters the cell data within the table's range.
+        
         This function modifies table properties such as name, range, and column properties.
         Use this when you need to modify an existing table's structure or properties.
-
+        
         Args:
             spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
             table_id: The unique identifier of the table to update
@@ -879,14 +878,14 @@ class GoogleSheetApp(APIApplication):
             start_column_index: Optional new starting column index (0-based)
             end_column_index: Optional new ending column index (exclusive)
             column_properties: Optional list of column properties with types and validation rules. Valid column types: "TEXT", "PERCENT", "DROPDOWN", "DOUBLE", "CURRENCY", "DATE", "TIME", "DATE_TIME". Example: [{"columnIndex": 0, "columnName": "Model Number", "columnType": "TEXT"}, {"columnIndex": 1, "columnName": "Sales - Jan", "columnType": "DOUBLE"}, {"columnIndex": 2, "columnName": "Price", "columnType": "CURRENCY"}, {"columnIndex": 3, "columnName": "Progress", "columnType": "PERCENT"}, {"columnIndex": 4, "columnName": "Created Date", "columnType": "DATE"}, {"columnIndex": 5, "columnName": "Status", "columnType": "DROPDOWN", "dataValidationRule": {"condition": {"type": "ONE_OF_LIST", "values": [{"userEnteredValue": "Active"}, {"userEnteredValue": "Inactive"}]}}}]
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with the updated table details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id or table_id is empty or invalid parameters are provided
-
+        
         Tags:
             update, table, modify, structured-data
         """
@@ -998,19 +997,19 @@ class GoogleSheetApp(APIApplication):
 
     def clear_values(self, spreadsheet_id: str, range: str) -> dict[str, Any]:
         """
-        Clears all values from a specified range in a Google Spreadsheet while preserving cell formatting and other properties
-
+        Clears data from a single, specified cell range in a Google Sheet while preserving all formatting. Unlike `delete_dimensions`, it only removes content, not the cells themselves. For clearing multiple ranges simultaneously, use the `batch_clear_values` function.
+        
         Args:
             spreadsheet_id: The unique identifier of the Google Spreadsheet to modify
             range: The A1 or R1C1 notation range of cells to clear (e.g., 'Sheet1!A1:B2')
-
+        
         Returns:
             A dictionary containing the Google Sheets API response
-
+        
         Raises:
             HttpError: When the API request fails due to invalid spreadsheet_id, invalid range format, or insufficient permissions
             ValueError: When spreadsheet_id is empty or range is in invalid format
-
+        
         Tags:
             clear, modify, spreadsheet, api, sheets, data-management, important
         """
@@ -1026,21 +1025,21 @@ class GoogleSheetApp(APIApplication):
         value_input_option: str = "RAW",
     ) -> dict[str, Any]:
         """
-        Updates cell values in a specified range of a Google Spreadsheet using the Sheets API
-
+        Overwrites cell values within a specific A1 notation range in a Google Spreadsheet. This function replaces existing data with the provided values, differing from `append_values` which adds new rows. It provides a direct method for targeted data replacement in a predefined area of the sheet.
+        
         Args:
             spreadsheet_id: The unique identifier of the target Google Spreadsheet
             range: The A1 notation range where values will be updated (e.g., 'Sheet1!A1:B2')
             values: A list of lists containing the data to write, where each inner list represents a row of values
             value_input_option: Determines how input data should be interpreted: 'RAW' (as-is) or 'USER_ENTERED' (parsed as UI input). Defaults to 'RAW'
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with update details
-
+        
         Raises:
             RequestError: When the API request fails due to invalid parameters or network issues
             AuthenticationError: When authentication with the Google Sheets API fails
-
+        
         Tags:
             update, write, sheets, api, important, data-modification, google-sheets
         """
@@ -1056,19 +1055,19 @@ class GoogleSheetApp(APIApplication):
         ranges: list[str],
     ) -> dict[str, Any]:
         """
-        Tool to clear one or more ranges of values from a spreadsheet. use when you need to remove data from specific cells or ranges while keeping formatting and other properties intact.
-
+        Clears cell values from multiple specified ranges in a single batch operation, preserving existing formatting. Unlike `clear_values`, which handles a single range, this method efficiently processes a list of ranges at once, removing only the content and not the cells themselves.
+        
         Args:
             spreadsheet_id: The ID of the spreadsheet to update. Example: "1q2w3e4r5t6y7u8i9o0p"
             ranges: The ranges to clear, in A1 notation or R1C1 notation. Example: ["Sheet1!A1:B2", "Sheet1!C3:D4"]
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with clear details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or ranges is empty
-
+        
         Tags:
             clear, batch, values, spreadsheet
         """
@@ -1094,8 +1093,8 @@ class GoogleSheetApp(APIApplication):
         date_time_render_option: str | None = None,
     ) -> dict[str, Any]:
         """
-        Tool to return one or more ranges of values from a spreadsheet that match the specified data filters. use when you need to retrieve specific data sets based on filtering criteria rather than entire sheets or fixed ranges.
-
+        Retrieves values from spreadsheet ranges matching a list of data filters. This method provides dynamic, criteria-based selection using A1 notation or grid coordinates, unlike `batch_get_values` which uses a simple list of range strings. It is ideal for fetching multiple, specific datasets in one request.
+        
         Args:
             spreadsheet_id: The ID of the spreadsheet to retrieve data from. Example: "1q2w3e4r5t6y7u8i9o0p"
             data_filters: The data filters used to match the ranges of values to retrieve. Ranges that match any of the specified data filters are included in the response. Each filter can contain:
@@ -1104,14 +1103,14 @@ class GoogleSheetApp(APIApplication):
             major_dimension: The major dimension that results should use. For example, if the spreadsheet data is: A1=1,B1=2,A2=3,B2=4, then a request that selects that range and sets majorDimension=ROWS returns [[1,2],[3,4]], whereas a request that sets majorDimension=COLUMNS returns [[1,3],[2,4]]. Options: "ROWS" or "COLUMNS". Example: "ROWS"
             value_render_option: How values should be represented in the output. The default render option is FORMATTED_VALUE. Options: "FORMATTED_VALUE", "UNFORMATTED_VALUE", or "FORMULA". Example: "FORMATTED_VALUE"
             date_time_render_option: How dates, times, and durations should be represented in the output. This is ignored if valueRenderOption is FORMATTED_VALUE. The default dateTime render option is SERIAL_NUMBER. Options: "SERIAL_NUMBER" or "FORMATTED_STRING". Example: "SERIAL_NUMBER"
-
+        
         Returns:
             A dictionary containing the filtered values that match the specified data filters
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or data_filters is empty
-
+        
         Tags:
             get, batch, data-filter, values, spreadsheet
         """
@@ -1162,28 +1161,28 @@ class GoogleSheetApp(APIApplication):
         response = self._post(url, data=request_body)
         return self._handle_response(response)
 
-    def copy_to_sheet(
+    def copy_sheet_to_spreadsheet(
         self,
         spreadsheet_id: str,
         sheet_id: int,
         destination_spreadsheet_id: str,
     ) -> dict[str, Any]:
         """
-        Tool to copy a single sheet from a spreadsheet to another spreadsheet. Use when you need to duplicate a sheet into a different spreadsheet.
-
-
+        Copies a specific sheet, including all its data and formatting, from a source spreadsheet to a different destination spreadsheet. This action duplicates an entire worksheet into another workbook, returning the properties of the newly created sheet in the API response.
+        
+        
         Args:
             spreadsheet_id: The ID of the spreadsheet containing the sheet to copy. Example: "1qZ_..."
             sheet_id: The ID of the sheet to copy. Example: 0
             destination_spreadsheet_id: The ID of the spreadsheet to copy the sheet to. Example: "2rY_..."
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with copy details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When any required parameter is empty or invalid
-
+        
         Tags:
             copy, sheet, spreadsheet, duplicate
         """
@@ -1203,7 +1202,7 @@ class GoogleSheetApp(APIApplication):
         response = self._post(url, data=request_body)
         return self._handle_response(response)
 
-    def batch_update(
+    def write_values_to_sheet(
         self,
         spreadsheet_id: str,
         sheet_name: str,
@@ -1213,9 +1212,8 @@ class GoogleSheetApp(APIApplication):
         include_values_in_response: bool = False,
     ) -> dict[str, Any]:
         """
-        Updates a specified range in a google sheet with given values, or appends them as new rows if `first cell location` is omitted; ensure the target sheet exists and the spreadsheet contains at least one worksheet.
-        Use this tool for basic updates/append. Overwrites existing data when appending.
-
+        Writes a 2D list of values to a sheet, overwriting existing data. Data is written starting from a specified cell, or defaults to cell A1 if no location is provided. This differs from `append_values`, which adds new rows after existing data.
+        
         Args:
             spreadsheet_id: The unique identifier of the Google Sheets spreadsheet to be updated. Example: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
             sheet_name: The name of the specific sheet within the spreadsheet to update. Example: "Sheet1"
@@ -1223,14 +1221,14 @@ class GoogleSheetApp(APIApplication):
             first_cell_location: The starting cell for the update range, specified in A1 notation (e.g., 'A1', 'B2'). The update will extend from this cell to the right and down, based on the provided values. If omitted, values are appended to the end of the sheet. Example: "A1"
             value_input_option: How input data is interpreted. 'USER_ENTERED': Values parsed as if typed by a user (e.g., strings may become numbers/dates, formulas are calculated); recommended for formulas. 'RAW': Values stored as-is without parsing (e.g., '123' stays string, '=SUM(A1:B1)' stays string). Defaults to 'USER_ENTERED'. Example: "USER_ENTERED"
             include_values_in_response: If set to True, the response will include the updated values from the spreadsheet. Defaults to False. Example: True
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with update details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty, sheet_name is empty, or values is empty
-
+        
         Tags:
             batch, update, write, sheets, api, important, data-modification, google-sheets
         """
@@ -1280,9 +1278,8 @@ class GoogleSheetApp(APIApplication):
         response_date_time_render_option: str | None = None,
     ) -> dict[str, Any]:
         """
-        Tool to append values to a spreadsheet. use when you need to add new data to the end of an existing table in a google sheet.
-        Use it for Insert new rows (INSERT_ROWS), specific range append, advanced options
-
+        Appends rows of data after a table within a specified range. Unlike `batch_update`, this function can optionally insert new rows, shifting existing data down. This provides more granular control for adding data to a sheet without overwriting existing cells below the target table.
+        
         Args:
             spreadsheet_id: The ID of the spreadsheet to update. Example: "1q0gLhLdGXYZblahblahblah"
             range: The A1 notation of a range to search for a logical table of data. Values are appended after the last row of the table. Example: "Sheet1!A1:B2"
@@ -1292,14 +1289,14 @@ class GoogleSheetApp(APIApplication):
             include_values_in_response: Determines if the update response should include the values of the cells that were appended. By default, responses do not include the updated values. Example: True
             response_value_render_option: Determines how values in the response should be rendered. The default render option is FORMATTED_VALUE. Options: "FORMATTED_VALUE", "UNFORMATTED_VALUE", or "FORMULA". Example: "FORMATTED_VALUE"
             response_date_time_render_option: Determines how dates, times, and durations in the response should be rendered. This is ignored if responseValueRenderOption is FORMATTED_VALUE. The default dateTime render option is SERIAL_NUMBER. Options: "SERIAL_NUMBER" or "FORMATTED_STRING". Example: "SERIAL_NUMBER"
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with append details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When required parameters are empty or invalid
-
+        
         Tags:
             append, values, spreadsheet, data, important
         """
@@ -1374,19 +1371,19 @@ class GoogleSheetApp(APIApplication):
         sheet_id: int,
     ) -> dict[str, Any]:
         """
-        Tool to clear the basic filter from a sheet. use when you need to remove an existing basic filter from a specific sheet within a google spreadsheet.
-
+        Removes the basic filter from a specified sheet within a Google Spreadsheet. This action clears any active sorting or filtering criteria, restoring the default data view. It is the direct counterpart to the `set_basic_filter` function.
+        
         Args:
             spreadsheet_id: The ID of the spreadsheet. Example: "abc123xyz789"
             sheet_id: The ID of the sheet on which the basic filter should be cleared. Example: 0
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with update details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or sheet_id is negative
-
+        
         Tags:
             clear, filter, basic-filter, spreadsheet
         """
@@ -1409,19 +1406,19 @@ class GoogleSheetApp(APIApplication):
         sheet_id: int,
     ) -> dict[str, Any]:
         """
-        Tool to delete a sheet (worksheet) from a spreadsheet. use when you need to remove a specific sheet from a google sheet document.
-
+        Permanently deletes a specific sheet (worksheet) from a Google Spreadsheet using its sheet ID. This operation removes the target sheet and all its contents, acting as the direct counterpart to the `add_sheet` function which creates new sheets within a spreadsheet.
+        
         Args:
             spreadsheet_id: The ID of the spreadsheet from which to delete the sheet. Example: "abc123xyz789"
             sheet_id: The ID of the sheet to delete. If the sheet is of DATA_SOURCE type, the associated DataSource is also deleted. Example: 123456789
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with update details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or sheet_id is negative
-
+        
         Tags:
             delete, sheet, spreadsheet, worksheet
         """
@@ -1438,7 +1435,7 @@ class GoogleSheetApp(APIApplication):
         response = self._post(url, data=request_body)
         return self._handle_response(response)
 
-    def list_tables(
+    def discover_tables(
         self,
         spreadsheet_id: str,
         min_rows: int = 2,
@@ -1446,21 +1443,21 @@ class GoogleSheetApp(APIApplication):
         min_confidence: float = 0.5,
     ) -> dict[str, Any]:
         """
-        This action is used to list all tables in a google spreadsheet, call this action to get the list of tables in a spreadsheet. discover all tables in a google spreadsheet by analyzing sheet structure and detecting data patterns. uses heuristic analysis to find header rows, data boundaries, and table structures.
-
+        Discovers and lists all table-like data structures within a Google Spreadsheet. It heuristically analyzes each sheet to identify headers and data boundaries, returning tables that meet specified size and confidence criteria. This is distinct from listing formally defined tables.
+        
         Args:
             spreadsheet_id: Google Sheets ID from the URL (e.g., '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms'). Example: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
             min_rows: Minimum number of data rows to consider a valid table. Example: 2
             min_columns: Minimum number of columns to consider a valid table. Example: 1
             min_confidence: Minimum confidence score (0.0-1.0) to consider a valid table. Example: 0.5
-
+        
         Returns:
             A dictionary containing the list of discovered tables with their properties
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or parameters are invalid
-
+        
         Tags:
             list, tables, discover, analyze, spreadsheet, important
         """
@@ -1509,7 +1506,7 @@ class GoogleSheetApp(APIApplication):
             },
         }
 
-    def get_table_schema(
+    def analyze_table_schema(
         self,
         spreadsheet_id: str,
         table_name: str,
@@ -1517,23 +1514,21 @@ class GoogleSheetApp(APIApplication):
         sample_size: int = 50,
     ) -> dict[str, Any]:
         """
-        Analyzes table structure and infers column names, types, and constraints.
-        Uses statistical analysis of sample data to determine the most likely data type for each column.
-        Call this action after calling the list tables action to get the schema of a table in a spreadsheet.
-
+        Infers the schema for a specific table within a Google Sheet by analyzing a sample of its data. After locating the table by name (as discovered by `list_tables`), it determines the most likely data type and properties for each column.
+        
         Args:
             spreadsheet_id: Google Sheets ID from the URL (e.g., '1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms')
             table_name: Specific table name from LIST_TABLES response (e.g., 'Sales_Data', 'Employee_List'). Use 'auto' to analyze the largest/most prominent table
             sheet_name: Sheet/tab name if table_name is ambiguous across multiple sheets
             sample_size: Number of rows to sample for type inference (1-1000, default 50)
-
+        
         Returns:
             A dictionary containing the table schema with column names, types, and constraints
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty, table_name is empty, or sample_size is invalid
-
+        
         Tags:
             schema, analyze, table, structure, types, columns
         """
@@ -1600,8 +1595,8 @@ class GoogleSheetApp(APIApplication):
         filter: dict,
     ) -> dict[str, Any]:
         """
-        Tool to set a basic filter on a sheet in a google spreadsheet. use when you need to filter or sort data within a specific range on a sheet.
-
+        Sets or updates a basic filter on a specified range within a sheet, enabling data sorting and filtering. The filter's target range and optional sort specifications are defined in a dictionary argument. It is the counterpart to `clear_basic_filter`, which removes an existing filter.
+        
         Args:
             spreadsheet_id: The ID of the spreadsheet. Example: "abc123xyz789"
             filter: The filter to set. This parameter is required. Contains:
@@ -1614,14 +1609,14 @@ class GoogleSheetApp(APIApplication):
                 - sortSpecs: The sort specifications for the filter (optional)
                     - dimensionIndex: The dimension the sort should be applied to
                     - sortOrder: The order data should be sorted ("ASCENDING", "DESCENDING", "SORT_ORDER_UNSPECIFIED")
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with filter details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty or filter is missing required fields
-
+        
         Tags:
             filter, basic-filter, spreadsheet, sort, important
         """
@@ -1686,10 +1681,8 @@ class GoogleSheetApp(APIApplication):
         mergeCells: bool = False,
     ) -> dict[str, Any]:
         """
-        Applies comprehensive cell formatting to a specified range in a Google Sheets worksheet.
-        Supports background colors, text colors, borders, text formatting, font properties,
-        alignment, number formats, text wrapping, and cell merging.
-
+        Applies comprehensive formatting to a specified cell range in a worksheet. It modifies visual properties like text style, color, alignment, borders, and can merge cells, without altering the underlying cell values.
+        
         Args:
             spreadsheetId: Identifier of the Google Sheets spreadsheet. Example: "1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms"
             worksheetId: ID (sheetId) of the worksheet. Use `get_spreadsheet` to find this ID. Example: 123456789
@@ -1697,44 +1690,44 @@ class GoogleSheetApp(APIApplication):
             startColumnIndex: 0-based index of the first column in the range. Example: 0
             endRowIndex: 0-based index of the row *after* the last row in the range (exclusive). Example: 1
             endColumnIndex: 0-based index of the column *after* the last column in the range (exclusive). Example: 2
-
-
+        
+        
             bold: Apply bold formatting. Example: True
             italic: Apply italic formatting. Example: False
             underline: Apply underline formatting. Example: False
             strikethrough: Apply strikethrough formatting. Example: False
             fontSize: Font size in points. Example: 12
             fontFamily: Font family name. Example: "Arial", "Times New Roman"
-
+        
             backgroundRed: Red component of background color. Example: 0.9
             backgroundGreen: Green component of background color. Example: 0.9
             backgroundBlue: Blue component of background color. Example: 0.9
-
+        
             textRed: Red component of text color. Example: 0.0
             textGreen: Green component of text color. Example: 0.0
             textBlue: Blue component of text color. Example: 0.0
-
+        
             horizontalAlignment: "LEFT", "CENTER", or "RIGHT". Example: "CENTER"
             verticalAlignment: "TOP", "MIDDLE", or "BOTTOM". Example: "MIDDLE"
-
+        
             wrapStrategy: "OVERFLOW_CELL", "LEGACY_WRAP", "CLIP", or "WRAP". Example: "WRAP"
-
+        
             numberFormat: Number format string. Example: "#,##0.00", "0.00%", "$#,##0.00"
-
+        
             borderTop: Top border settings. Example: {"style": "SOLID", "color": {"red": 0, "green": 0, "blue": 0}}
             borderBottom: Bottom border settings. Example: {"style": "SOLID", "color": {"red": 0, "green": 0, "blue": 0}}
             borderLeft: Left border settings. Example: {"style": "SOLID", "color": {"red": 0, "green": 0, "blue": 0}}
             borderRight: Right border settings. Example: {"style": "SOLID", "color": {"red": 0, "green": 0, "blue": 0}}
-
+        
             mergeCells: Whether to merge the specified range into a single cell. Example: True
-
+        
         Returns:
             A dictionary containing the Google Sheets API response with formatting details
-
+        
         Raises:
             HTTPError: When the API request fails due to invalid parameters or insufficient permissions
             ValueError: When spreadsheet_id is empty, indices are invalid, or color values are out of range
-
+        
         Tags:
             format, cells, styling, text-formatting, background-color, borders, alignment, merge
         """
@@ -1915,28 +1908,28 @@ class GoogleSheetApp(APIApplication):
         """Returns a list of methods exposed as tools."""
         return [
             self.create_spreadsheet,
-            self.get_spreadsheet,
-            self.batch_get_values,
+            self.get_spreadsheet_metadata,
+            self.get_values,
+            self.batch_get_values_by_range,
             self.insert_dimensions,
             self.append_dimensions,
             self.delete_dimensions,
             self.add_sheet,
-            self.delete_sheet,
             self.add_basic_chart,
             self.add_pie_chart,
             self.add_table,
             self.update_table,
             self.clear_values,
             self.update_values,
-            self.batch_update,
-            self.clear_basic_filter,
-            self.list_tables,
-            self.get_values,
-            self.get_table_schema,
-            self.set_basic_filter,
-            self.copy_to_sheet,
-            self.append_values,
             self.batch_clear_values,
             self.batch_get_values_by_data_filter,
+            self.copy_sheet_to_spreadsheet,
+            self.write_values_to_sheet,
+            self.append_values,
+            self.clear_basic_filter,
+            self.delete_sheet,
+            self.discover_tables,
+            self.analyze_table_schema,
+            self.set_basic_filter,
             self.format_cells,
         ]