arcade-google-sheets 2.0.0rc1__py3-none-any.whl → 3.1.0__py3-none-any.whl

arcade_google_sheets/tools/write.py

@@ -2,17 +2,20 @@ from typing import Annotated
 
 from arcade_tdk import ToolContext, tool
 from arcade_tdk.auth import Google
-from arcade_tdk.errors import RetryableToolError
 
+from arcade_google_sheets.converters import SheetDataInputToValueRangesConverter
 from arcade_google_sheets.models import (
-    SheetDataInput,
     Spreadsheet,
     SpreadsheetProperties,
 )
 from arcade_google_sheets.utils import (
+    batch_update,
     build_sheets_service,
+    col_to_index,
     create_sheet,
+    get_sheet_metadata_from_identifier,
     parse_write_to_cell_response,
+    validate_sheet_data_input,
     validate_write_to_cell_params,
 )
 
@@ -40,15 +43,7 @@ def create_spreadsheet(
     """
     service = build_sheets_service(context.get_auth_token_or_empty())
 
-    try:
-        sheet_data = SheetDataInput(data=data)  # type: ignore[arg-type]
-    except Exception as e:
-        msg = "Invalid JSON or unexpected data format for parameter `data`"
-        raise RetryableToolError(
-            message=msg,
-            additional_prompt_content=f"{msg}: {e}",
-            retry_after_ms=100,
-        )
+    sheet_data = validate_sheet_data_input(data)
 
     spreadsheet = Spreadsheet(
         properties=SpreadsheetProperties(title=title),
@@ -112,3 +107,120 @@ def write_to_cell(
     )
 
     return parse_write_to_cell_response(sheet_properties)
+
+
+@tool(
+    requires_auth=Google(
+        scopes=["https://www.googleapis.com/auth/drive.file"],
+    )
+)
+def update_cells(
+    context: ToolContext,
+    spreadsheet_id: Annotated[str, "The id of the spreadsheet to write to"],
+    data: Annotated[
+        str,
+        "The data to write. A JSON string (property names enclosed in double quotes) "
+        "representing a dictionary that maps row numbers to dictionaries that map "
+        "column letters to cell values. For example, data[23]['C'] is the value for cell C23. "
+        "This is the same format accepted by create_spreadsheet. "
+        "Type hint: dict[int, dict[str, int | float | str | bool]]",
+    ],
+    sheet_position: Annotated[
+        int | None,
+        "The position/tab of the sheet in the spreadsheet to write to. "
+        "A value of 1 represents the first (leftmost/Sheet1) sheet. "
+        "Defaults to 1.",
+    ] = 1,
+    sheet_id_or_name: Annotated[
+        str | None,
+        "The id or name of the sheet to write to. If provided, takes "
+        "precedence over sheet_position.",
+    ] = None,
+) -> Annotated[dict, "The status of the operation, including updated ranges and counts"]:
+    """
+    Write values to a Google Sheet using a flexible data format.
+
+    sheet_id_or_name takes precedence over sheet_position. If a sheet is not mentioned,
+    then always assume the default sheet_position is sufficient.
+    """
+    service = build_sheets_service(context.get_auth_token_or_empty())
+
+    sheet_data = validate_sheet_data_input(data)
+    sheet_name, sheet_id, sheet_url = get_sheet_metadata_from_identifier(
+        service, spreadsheet_id, sheet_position, sheet_id_or_name
+    )
+    converter = SheetDataInputToValueRangesConverter(sheet_name, sheet_data)
+    value_ranges = converter.convert()
+
+    response = batch_update(service, spreadsheet_id, value_ranges)
+
+    return {**response, "sheet_url": sheet_url, "sheet_id": sheet_id}
+
+
+@tool(
+    requires_auth=Google(
+        scopes=["https://www.googleapis.com/auth/drive.file"],
+    )
+)
+def add_note_to_cell(
+    context: ToolContext,
+    spreadsheet_id: Annotated[str, "The id of the spreadsheet to add a comment to"],
+    column: Annotated[str, "The column string to add a note to. For example, 'A', 'F', or 'AZ'"],
+    row: Annotated[int, "The row number to add a note to"],
+    note_text: Annotated[str, "The text for the note to add"],
+    sheet_position: Annotated[
+        int | None,
+        "The position/tab of the sheet in the spreadsheet to write to. "
+        "A value of 1 represents the first (leftmost/Sheet1) sheet. "
+        "Defaults to 1.",
+    ] = 1,
+    sheet_id_or_name: Annotated[
+        str | None,
+        "The id or name of the sheet to write to. If provided, takes "
+        "precedence over sheet_position.",
+    ] = None,
+) -> Annotated[dict, "The status of the operation"]:
+    """
+    Add a note to a specific cell in a spreadsheet. A note is a small
+    piece of text attached to a cell (shown with a black triangle) that
+    appears when you hover over the cell.
+
+    sheet_id_or_name takes precedence over sheet_position. If a sheet is not mentioned,
+    then always assume the default sheet_position is sufficient.
+    """
+    service = build_sheets_service(context.get_auth_token_or_empty())
+
+    sheet_name, sheet_id, sheet_url = get_sheet_metadata_from_identifier(
+        service, spreadsheet_id, sheet_position, sheet_id_or_name
+    )
+    column_index = col_to_index(column)
+
+    service.spreadsheets().batchUpdate(
+        spreadsheetId=spreadsheet_id,
+        body={
+            "requests": [
+                {
+                    "repeatCell": {
+                        "range": {
+                            "sheetId": sheet_id,
+                            "startRowIndex": row - 1,
+                            "endRowIndex": row,
+                            "startColumnIndex": column_index,
+                            "endColumnIndex": column_index + 1,
+                        },
+                        "cell": {
+                            "note": note_text,
+                        },
+                        "fields": "note",
+                    },
+                }
+            ]
+        },
+    ).execute()
+
+    return {
+        "status": "success",
+        "sheet_url": sheet_url,
+        "sheet_id": sheet_id,
+        "sheet_name": sheet_name,
+    }

arcade_google_sheets/utils.py

@@ -1,4 +1,5 @@
 import logging
+import string
 from typing import Any
 
 from arcade_tdk.errors import RetryableToolError, ToolExecutionError
@@ -9,7 +10,12 @@ from arcade_google_sheets.constants import (
     DEFAULT_SHEET_COLUMN_COUNT,
     DEFAULT_SHEET_ROW_COUNT,
 )
-from arcade_google_sheets.enums import NumberFormatType
+from arcade_google_sheets.enums import (
+    Corpora,
+    NumberFormatType,
+    OrderBy,
+    SheetIdentifierType,
+)
 from arcade_google_sheets.models import (
     CellData,
     CellExtendedValue,
@@ -21,7 +27,10 @@ from arcade_google_sheets.models import (
     Sheet,
     SheetDataInput,
     SheetProperties,
+    Spreadsheet,
+    ValueRange,
 )
+from arcade_google_sheets.templates import sheet_url_template
 from arcade_google_sheets.types import CellValue
 
 logging.basicConfig(
@@ -32,6 +41,15 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 
+def remove_none_values(params: dict) -> dict:
+    """
+    Remove None values from a dictionary.
+    :param params: The dictionary to clean
+    :return: A new dictionary with None values removed
+    """
+    return {k: v for k, v in params.items() if v is not None}
+
+
 def build_sheets_service(auth_token: str | None) -> Resource:  # type: ignore[no-any-unimported]
     """
     Build a Sheets service object.
@@ -40,6 +58,14 @@ def build_sheets_service(auth_token: str | None) -> Resource:  # type: ignore[no
     return build("sheets", "v4", credentials=Credentials(auth_token))
 
 
+def build_drive_service(auth_token: str | None) -> Resource:  # type: ignore[no-any-unimported]
+    """
+    Build a Drive service object.
+    """
+    auth_token = auth_token or ""
+    return build("drive", "v3", credentials=Credentials(auth_token))
+
+
 def col_to_index(col: str) -> int:
     """Convert a sheet's column string to a 0-indexed column index
 
@@ -459,6 +485,34 @@ def convert_api_grid_data_to_dict(grids: list[dict]) -> dict:
     return dict(sorted(result.items()))
 
 
+def validate_sheet_data_input(data: str | None) -> SheetDataInput:
+    """
+    Validate and convert data to SheetDataInput, raising RetryableToolError on validation failure.
+    `data` is a JSON string representing a dictionary that maps row numbers to dictionaries that map
+    column letters to cell values.
+
+    Args:
+        data: The data parameter to validate, a JSON string representing a dictionary that maps
+        row numbers to dictionaries that map column letters to cell values.
+        Type hint: dict[int, dict[str, int | float | str | bool]]
+
+    Returns:
+        SheetDataInput: The validated sheet data input object
+
+    Raises:
+        RetryableToolError: If the data is invalid JSON or has an unexpected format
+    """
+    try:
+        return SheetDataInput(data=data)  # type: ignore[arg-type]
+    except Exception as e:
+        msg = "Invalid JSON or unexpected data format for parameter `data`"
+        raise RetryableToolError(
+            message=msg,
+            additional_prompt_content=f"{msg}: {e}",
+            retry_after_ms=100,
+        )
+
+
 def validate_write_to_cell_params(  # type: ignore[no-any-unimported]
     service: Resource,
     spreadsheet_id: str,
@@ -546,3 +600,424 @@ def parse_write_to_cell_response(response: dict) -> dict:
         "updatedCell": response["updatedData"]["range"].split("!")[1],
         "value": response["updatedData"]["values"][0][0],
     }
+
+
+def calculate_a1_sheet_range(
+    sheet_name: str,
+    sheet_row_count: int,
+    sheet_col_count: int,
+    start_row: int,
+    start_col: str,
+    max_rows: int,
+    max_cols: int,
+) -> str | None:
+    """Calculate a single range for a sheet based on start position and limits.
+
+    Args:
+        sheet_name (str): The name of the sheet.
+        sheet_row_count (int): The number of rows in the sheet.
+        sheet_col_count (int): The number of columns in the sheet.
+        start_row (int): The row from which to start fetching data.
+        start_col (str): The column letter(s) from which to start fetching data.
+        max_rows (int): The maximum number of rows to fetch.
+        max_cols (int): The maximum number of columns to fetch.
+
+    Returns:
+        str | None: The A1 range for the sheet, or None if there is no data to fetch.
+    """
+    start_col_index = col_to_index(start_col)
+
+    effective_max_rows = min(sheet_row_count, max_rows or sheet_row_count)
+    effective_max_cols = min(sheet_col_count, max_cols or sheet_col_count)
+
+    end_row = min(start_row + effective_max_rows - 1, sheet_row_count)
+    end_col_index = min(start_col_index + effective_max_cols - 1, sheet_col_count - 1)
+
+    # Only create a range if there's actually data to fetch
+    if start_row <= end_row and start_col_index <= end_col_index:
+        range_start = f"{index_to_col(start_col_index)}{start_row}"
+        range_end = f"{index_to_col(end_col_index)}{end_row}"
+        return f"'{sheet_name}'!{range_start}:{range_end}"
+
+    return None
+
+
+def get_sheet_by_identifier(
+    sheets: list[Sheet], sheet_identifier: str, sheet_identifier_type: SheetIdentifierType
+) -> Sheet | None:
+    """
+    Find a sheet by identifier (name, sheet ID, or 1-based position index).
+
+    Args:
+        sheets (list): List of Sheet objects from the spreadsheet.
+        sheet_identifier (str): The identifier of the sheet to get.
+        sheet_identifier_type (SheetIdentifierType): The type of the identifier.
+
+    Returns:
+        Sheet | None: The matching sheet, or None if not found.
+    """
+    if sheet_identifier_type == SheetIdentifierType.POSITION:
+        index = int(sheet_identifier) - 1
+        if 0 <= index < len(sheets):
+            return sheets[index]
+
+    if sheet_identifier_type == SheetIdentifierType.ID_OR_NAME:
+        for sheet in sheets:
+            sheet_title = sheet.properties.title
+            sheet_id = sheet.properties.sheetId
+            if (
+                sheet_title.casefold() == sheet_identifier.casefold()
+                or str(sheet_id).casefold() == sheet_identifier.casefold()
+            ):
+                return sheet
+
+    return None
+
+
+def get_spreadsheet_metadata_helper(sheets_service: Resource, spreadsheet_id: str) -> Spreadsheet:  # type: ignore[no-any-unimported]
+    """Get the spreadsheet metadata to collect the sheet names and dimensions
+
+    Args:
+        sheets_service (Resource): The Google Sheets service.
+        spreadsheet_id (str): The ID of the spreadsheet provided to the tool.
+
+    Returns:
+        Spreadsheet: The spreadsheet with only the metadata.
+    """
+    metadata_response = (
+        sheets_service.spreadsheets()
+        .get(
+            spreadsheetId=spreadsheet_id,
+            includeGridData=False,
+            fields="spreadsheetId,spreadsheetUrl,properties/title,sheets/properties",
+        )
+        .execute()
+    )
+    return Spreadsheet.model_validate(metadata_response)
+
+
+def batch_update(service: Resource, spreadsheet_id: str, data: list[ValueRange]) -> dict:  # type: ignore[no-any-unimported]
+    """
+    Batch update a spreadsheet with a list of ValueRanges.
+
+    Args:
+        service (Resource): The Google Sheets service.
+        spreadsheet_id (str): The ID of the spreadsheet to update.
+        data (list[ValueRange]): The data to update the spreadsheet with.
+
+    Returns:
+        dict: The response from the batch update.
+    """
+    body = {
+        "valueInputOption": "USER_ENTERED",
+        "data": [value_range.model_dump() for value_range in data],
+    }
+    response = (
+        service.spreadsheets()
+        .values()
+        .batchUpdate(spreadsheetId=spreadsheet_id, body=body)
+        .execute()
+    )
+    updated_ranges = [
+        value_response["updatedRange"] for value_response in response.get("responses", [])
+    ]
+    return {
+        "spreadsheet_id": response["spreadsheetId"],
+        "total_updated_rows": response["totalUpdatedRows"],
+        "total_updated_columns": response["totalUpdatedColumns"],
+        "total_updated_cells": response["totalUpdatedCells"],
+        "updated_ranges": updated_ranges,
+    }
+
+
+def get_spreadsheet_with_pagination(  # type: ignore[no-any-unimported]
+    service: Resource,
+    spreadsheet_id: str,
+    sheet_identifier: str,
+    sheet_identifier_type: SheetIdentifierType,
+    start_row: int,
+    start_col: str,
+    max_rows: int,
+    max_cols: int,
+) -> dict:
+    """
+    Get spreadsheet data with pagination support for large spreadsheets.
+
+    Args:
+        service (Resource): The Google Sheets service.
+        spreadsheet_id (str): The ID of the spreadsheet provided to the tool.
+        sheet_position (int | None): The position/tab of the sheet to get.
+        sheet_id_or_name (str | None): The id or name of the sheet to get.
+        start_row (int): The row from which to start fetching data.
+        start_col (str): The column letter(s) from which to start fetching data.
+        max_rows (int): The maximum number of rows to fetch.
+        max_cols (int): The maximum number of columns to fetch.
+
+    Returns:
+        dict: The spreadsheet data for the specified sheet in the spreadsheet.
+
+    """
+
+    # First, only get the spreadsheet metadata to collect the sheet names and dimensions
+    spreadsheet_with_only_metadata = get_spreadsheet_metadata_helper(service, spreadsheet_id)
+
+    target_sheet = get_sheet_by_identifier(
+        spreadsheet_with_only_metadata.sheets, sheet_identifier, sheet_identifier_type
+    )
+    if not target_sheet:
+        raise ToolExecutionError(
+            message=f"Sheet with identifier '{sheet_identifier}' not found",
+            developer_message=(
+                "Sheet(s) in the spreadsheet: "
+                + ", ".join([
+                    sheet.model_dump_json() for sheet in spreadsheet_with_only_metadata.sheets
+                ])
+            ),
+        )
+
+    a1_ranges = []
+    sheet_name = target_sheet.properties.title
+    grid_props = target_sheet.properties.gridProperties
+    if grid_props:
+        sheet_row_count = grid_props.rowCount
+        sheet_col_count = grid_props.columnCount
+
+        curr_range = calculate_a1_sheet_range(
+            sheet_name,
+            sheet_row_count,
+            sheet_col_count,
+            start_row,
+            start_col,
+            max_rows,
+            max_cols,
+        )
+        if curr_range:
+            a1_ranges.append(curr_range)
+
+    # Next, get the data for the ranges
+    if a1_ranges:
+        response = (
+            service.spreadsheets()
+            .get(
+                spreadsheetId=spreadsheet_id,
+                includeGridData=True,
+                ranges=a1_ranges,
+                fields="spreadsheetId,spreadsheetUrl,properties/title,sheets/properties,sheets/data/rowData/values/userEnteredValue,sheets/data/rowData/values/formattedValue,sheets/data/rowData/values/effectiveValue",
+            )
+            .execute()
+        )
+    else:
+        response = spreadsheet_with_only_metadata.model_dump()
+
+    return parse_get_spreadsheet_response(response)
+
+
+def process_get_spreadsheet_params(
+    sheet_position: int | None,
+    sheet_id_or_name: str | None,
+    start_row: int,
+    start_col: str,
+    max_rows: int,
+    max_cols: int,
+) -> tuple[str, SheetIdentifierType, int, str, int, int]:
+    """Process and validate the input parameters for the get_spreadsheet tool.
+
+    Args:
+        sheet_position (int | None): The position/tab of the sheet to get.
+        sheet_id_or_name (str | None): The id or name of the sheet to get.
+        start_row (int): Processed to be within the range [1, 1000]
+        start_col (str): Processed to be alphabetic column representation. e.g., A, Z, QED
+        max_rows (int): Processed to be within the range [1, 1000]
+        max_cols (int): Processed to be within the range [1, 26]
+
+    Returns:
+        tuple[str, str, int, str, int, int]: The processed parameters.
+
+    Raises:
+        ToolExecutionError:
+            If the start_col is not one of alphabetic or numeric
+    """
+    if sheet_id_or_name:
+        sheet_identifier = sheet_id_or_name
+        sheet_identifier_type = SheetIdentifierType.ID_OR_NAME
+    elif sheet_position:
+        sheet_identifier = str(sheet_position)
+        sheet_identifier_type = SheetIdentifierType.POSITION
+    else:
+        raise RetryableToolError("Either sheet_position or sheet_id_or_name must be provided")
+
+    processed_start_row = max(1, start_row)
+    processed_max_rows = max(1, min(max_rows, 1000))
+    processed_max_cols = max(1, min(max_cols, 26))
+    if not all(c in string.ascii_letters for c in start_col):
+        if not start_col.isdigit():
+            raise ToolExecutionError("Input 'start_col' must be alphabetic (A-Z) or numeric")
+        processed_start_col = index_to_col(int(start_col) - 1)
+    else:
+        processed_start_col = start_col.upper()
+
+    return (
+        sheet_identifier,
+        sheet_identifier_type,
+        processed_start_row,
+        processed_start_col,
+        processed_max_rows,
+        processed_max_cols,
+    )
+
+
+def get_sheet_metadata_from_identifier(  # type: ignore[no-any-unimported]
+    service: Resource,
+    spreadsheet_id: str,
+    sheet_position: int | None,
+    sheet_id_or_name: str | None,
+) -> tuple[str, int, str]:
+    """Get the actual sheet name from position, id, or name identifier.
+
+    Args:
+        service (Resource): The Google Sheets service.
+        spreadsheet_id (str): The ID of the spreadsheet.
+        sheet_position (int | None): The position/tab of the sheet (1-indexed).
+        sheet_id_or_name (str | None): The id or name of the sheet.
+
+    Returns:
+        tuple[str, str, str]: The sheet's title, id, and url.
+
+    Raises:
+        ToolExecutionError: If the sheet is not found.
+    """
+    # Determine the sheet identifier and type
+    if sheet_id_or_name:
+        sheet_identifier = sheet_id_or_name
+        sheet_identifier_type = SheetIdentifierType.ID_OR_NAME
+    elif sheet_position:
+        sheet_identifier = str(sheet_position)
+        sheet_identifier_type = SheetIdentifierType.POSITION
+    else:
+        # Default to first sheet
+        sheet_identifier = "1"
+        sheet_identifier_type = SheetIdentifierType.POSITION
+
+    spreadsheet = get_spreadsheet_metadata_helper(service, spreadsheet_id)
+
+    target_sheet = get_sheet_by_identifier(
+        spreadsheet.sheets, sheet_identifier, sheet_identifier_type
+    )
+
+    if not target_sheet:
+        raise ToolExecutionError(
+            message=f"Sheet with {sheet_identifier_type.value} '{sheet_identifier}' not found",
+            developer_message=(
+                "Sheet(s) in the spreadsheet: "
+                + ", ".join([sheet.properties.title for sheet in spreadsheet.sheets])
+            ),
+        )
+
+    sheet_url = sheet_url_template.format(
+        spreadsheet_id=spreadsheet_id,
+        sheet_id=target_sheet.properties.sheetId,
+    )
+
+    return target_sheet.properties.title, target_sheet.properties.sheetId, sheet_url
+
+
+def raise_for_large_payload(data: dict) -> None:
+    """Enforce a 10MB limit on the data size.
+
+    Args:
+        data (dict): The data to enforce the size limit on.
+
+    Raises:
+        ToolExecutionError:
+            If the data size exceeds 10MB
+    """
+    num_bytes = len(str(data).encode("utf-8"))
+
+    if num_bytes >= (10 * 1024 * 1024):
+        raise ToolExecutionError(
+            message="Spreadsheet size exceeds 10MB limit. "
+            "Please reduce the number of rows and columns you are requesting and try again.",
+            developer_message=f"Data size: {num_bytes / 1024 / 1024:.4f}MB",
+        )
+
+
+# ------------------------------
+# Search Utils
+# ------------------------------
+def build_files_list_query(
+    mime_type: str,
+    document_contains: list[str] | None = None,
+    document_not_contains: list[str] | None = None,
+) -> str:
+    query = [f"(mimeType = '{mime_type}' and trashed = false)"]
+
+    if isinstance(document_contains, str):
+        document_contains = [document_contains]
+
+    if isinstance(document_not_contains, str):
+        document_not_contains = [document_not_contains]
+
+    if document_contains:
+        for keyword in document_contains:
+            name_contains = keyword.replace("'", "\\'")
+            full_text_contains = keyword.replace("'", "\\'")
+            keyword_query = (
+                f"(name contains '{name_contains}' or fullText contains '{full_text_contains}')"
+            )
+            query.append(keyword_query)
+
+    if document_not_contains:
+        for keyword in document_not_contains:
+            name_not_contains = keyword.replace("'", "\\'")
+            full_text_not_contains = keyword.replace("'", "\\'")
+            keyword_query = (
+                f"(name not contains '{name_not_contains}' and "
+                f"fullText not contains '{full_text_not_contains}')"
+            )
+            query.append(keyword_query)
+
+    return " and ".join(query)
+
+
+def build_files_list_params(
+    mime_type: str,
+    page_size: int,
+    order_by: list[OrderBy],
+    pagination_token: str | None,
+    include_shared_drives: bool,
+    search_only_in_shared_drive_id: str | None,
+    include_organization_domain_spreadsheets: bool,
+    spreadsheet_contains: list[str] | None = None,
+    spreadsheet_not_contains: list[str] | None = None,
+) -> dict[str, Any]:
+    query = build_files_list_query(
+        mime_type=mime_type,
+        document_contains=spreadsheet_contains,
+        document_not_contains=spreadsheet_not_contains,
+    )
+
+    params = {
+        "q": query,
+        "pageSize": page_size,
+        "orderBy": ",".join([item.value for item in order_by]),
+        "pageToken": pagination_token,
+    }
+
+    if (
+        include_shared_drives
+        or search_only_in_shared_drive_id
+        or include_organization_domain_spreadsheets
+    ):
+        params["includeItemsFromAllDrives"] = "true"
+        params["supportsAllDrives"] = "true"
+
+    if search_only_in_shared_drive_id:
+        params["driveId"] = search_only_in_shared_drive_id
+        params["corpora"] = Corpora.DRIVE.value
+
+    if include_organization_domain_spreadsheets:
+        params["corpora"] = Corpora.DOMAIN.value
+
+    params = remove_none_values(params)
+
+    return params

{arcade_google_sheets-2.0.0rc1.dist-info → arcade_google_sheets-3.1.0.dist-info}/METADATA

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: arcade_google_sheets
-Version: 2.0.0rc1
+Version: 3.1.0
 Summary: Arcade.dev LLM tools for Google Sheets
 Author-email: Arcade <dev@arcade.dev>
+License: Proprietary - Arcade Software License Agreement v1.0
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: arcade-tdk<3.0.0,>=2.0.0
@@ -12,7 +13,7 @@ Requires-Dist: google-auth-httplib2<1.0.0,>=0.2.0
 Requires-Dist: google-auth<3.0.0,>=2.32.0
 Requires-Dist: googleapis-common-protos<2.0.0,>=1.63.2
 Provides-Extra: dev
-Requires-Dist: arcade-ai[evals]<3.0.0,>=2.0.0rc1; extra == 'dev'
+Requires-Dist: arcade-ai[evals]<3.0.0,>=2.0.0; extra == 'dev'
 Requires-Dist: arcade-serve<3.0.0,>=2.0.0; extra == 'dev'
 Requires-Dist: mypy<1.6.0,>=1.5.1; extra == 'dev'
 Requires-Dist: pre-commit<3.5.0,>=3.4.0; extra == 'dev'