python-google-sheets 0.1.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

google_sheets/__init__.py

@@ -1,3 +1,5 @@
+from .google_sheets import GoogleSheets
+from .api_request import ApiRequest
 from .styles import Color_, Border_
 from .spreadsheet_requests import (
     ColorStyle,
@@ -16,7 +18,23 @@ from .spreadsheet_requests import (
     WrapStrategy,
     Spreadsheet,
     SheetProperties,
+    ConditionType,
+    ConditionValue,
+    InterpolationPointType,
+    InterpolationPoint,
+    RelativeDate,
+    BooleanCondition,
+    BooleanRule,
+    GradientRule,
+    GridRange,
+    ConditionalFormatRule,
+    MergeType,
 )
-from .utils import col_num_to_letter, float_sum, rowcol_to_a1
-from .api_request import ApiRequest
-from .google_sheets import GoogleSheets
+from .utils import (
+    get_spreadsheet_id_from_url,
+    col_num_to_letter,
+    col_letter_to_num,
+    rowcol_to_a1,
+    a1_to_rowcol,
+    float_sum,
+)

google_sheets/api_request.py

@@ -1,11 +1,18 @@
 import re
+from enum import StrEnum
 
+from .styles import Color_
 from .spreadsheet_requests import (
     # conditional_format_rule
     AddConditionalFormatRule,
     DeleteConditionalFormatRule,
     UpdateConditionalFormatRule,
     ConditionalFormatRule,
+    BooleanRule,
+    BooleanCondition,
+    ConditionType,
+    ConditionValue,
+    RelativeDate,
     GradientRule,
     InterpolationPoint,
     InterpolationPointType,
@@ -36,14 +43,15 @@ from .spreadsheet_requests import (
     ExtendedValue,
     CellFormat,
 
+    # spreadsheet
+    AddSheet,
+    DeleteSheet,
+
     # general_models
     ColorStyle,
     GridRange,
     FieldMask,
-
-    # spreadsheet
-    AddSheet,
-    DeleteSheet,
+    SimpleType,
 )
 
 
@@ -52,11 +60,11 @@ class ApiRequest:
     def update_cells(
             sheet_id: int,
             range_: str,
-            values: list[list[int | float | bool | str]] | list[int | float | bool | str] = None,
+            values: list[list[SimpleType]] | list[SimpleType] = None,
             cell_formats: list[list[CellFormat]] | list[CellFormat] = None
     ) -> dict:
         assert values or cell_formats, 'At least one of the parameters must be specified: values or cell_formats'
-        start_row, end_row, start_col, end_col = ApiRequest.__split_excel_range(range_)
+        start_row, end_row, start_col, end_col = ApiRequest._split_excel_range(range_)
 
         # syntax sugar for single row or column
         if values and not isinstance(values[0], list):
@@ -102,52 +110,169 @@ class ApiRequest:
         ).dict()
 
     @staticmethod
-    def add_conditional_format_rule(
+    def add_boolean_format_rule(
             *,
             sheet_id: int,
             ranges: list[str],
-            gradient_colors: tuple[ColorStyle, ColorStyle, ColorStyle] | tuple[ColorStyle, ColorStyle],
-            gradient_points: tuple[float, float, float] = None
+            condition_type: ConditionType,
+            condition_values: list[ConditionValue] = None,
+            cell_format: CellFormat,
     ) -> dict:
-        grid_ranges = [GridRange(sheet_id=sheet_id, **ApiRequest.__split_excel_range(range_, return_as_dict=True)) for range_ in ranges]
-        if gradient_points is None:
-            gradient_points = (None,) * len(gradient_colors)
-        if len(gradient_colors) == 2:
+        assert not any([
+            cell_format.number_format, cell_format.borders, cell_format.padding,
+            cell_format.horizontal_alignment, cell_format.vertical_alignment,
+            cell_format.wrap_strategy, cell_format.text_direction, cell_format.text_rotation,
+            cell_format.hyperlink_display_type
+        ]), 'Conditional formatting can only apply a subset of formatting: bold, italic, strikethrough, foreground ' \
+            'color and background color (background_color_style and text_format)'
+        grid_ranges = [GridRange(sheet_id=sheet_id, **ApiRequest._split_excel_range(range_, return_as_dict=True)) for range_ in ranges]
+        return AddConditionalFormatRule(rule=ConditionalFormatRule(
+            ranges=grid_ranges,
+            boolean_rule=BooleanRule(
+                condition=BooleanCondition(
+                    type=condition_type,
+                    values=condition_values or []
+                ),
+                format=cell_format
+            )
+        )).dict()
+
+    class GradientRule:
+        IPTypeAndValue = tuple[InterpolationPointType, int | None]  # Type and Value of Interpolation Point
+
+        @staticmethod
+        def add(
+                *,
+                sheet_id: int,
+                ranges: list[str],
+                interpolation_points: tuple[IPTypeAndValue, IPTypeAndValue] | tuple[IPTypeAndValue, IPTypeAndValue, IPTypeAndValue],
+                interpolation_point_colors: tuple[ColorStyle, ColorStyle] | tuple[ColorStyle, ColorStyle, ColorStyle],
+        ) -> dict:
+            assert len(interpolation_points) == len(interpolation_point_colors), 'The number of interpolation points must match the number of its colors'
+            grid_ranges = [GridRange(sheet_id=sheet_id, **ApiRequest._split_excel_range(range_, return_as_dict=True)) for range_ in ranges]
+
+            if len(interpolation_points) == 2:
+                return AddConditionalFormatRule(rule=ConditionalFormatRule(
+                    ranges=grid_ranges,
+                    gradient_rule=GradientRule(
+                        minpoint=InterpolationPoint(
+                            color_style=interpolation_point_colors[0],
+                            type=interpolation_points[0][0],
+                            value=str(interpolation_points[0][1]) if interpolation_points[0][1] is not None else None
+                        ),
+                        maxpoint=InterpolationPoint(
+                            color_style=interpolation_point_colors[1],
+                            type=interpolation_points[1][0],
+                            value=str(interpolation_points[1][1]) if interpolation_points[1][1] is not None else None
+                        )
+                    )
+                )).dict()
+
             return AddConditionalFormatRule(rule=ConditionalFormatRule(
                 ranges=grid_ranges,
                 gradient_rule=GradientRule(
                     minpoint=InterpolationPoint(
-                        color_style=gradient_colors[0],
-                        type=InterpolationPointType.MIN,
-                        value=str(gradient_points[0])
+                        color_style=interpolation_point_colors[0],
+                        type=interpolation_points[0][0],
+                        value=str(interpolation_points[0][1]) if interpolation_points[0][1] is not None else None
+                    ),
+                    midpoint=InterpolationPoint(
+                        color_style=interpolation_point_colors[1],
+                        type=interpolation_points[1][0],
+                        value=str(interpolation_points[1][1]) if interpolation_points[1][1] is not None else None
                     ),
                     maxpoint=InterpolationPoint(
-                        color_style=gradient_colors[1],
-                        type=InterpolationPointType.MAX,
-                        value=str(gradient_points[1])
+                        color_style=interpolation_point_colors[2],
+                        type=interpolation_points[2][0],
+                        value=str(interpolation_points[2][1]) if interpolation_points[2][1] is not None else None
                     )
                 )
             )).dict()
-        return AddConditionalFormatRule(rule=ConditionalFormatRule(
-            ranges=grid_ranges,
-            gradient_rule=GradientRule(
-                minpoint=InterpolationPoint(
-                    color_style=gradient_colors[0],
-                    type=InterpolationPointType.NUMBER,
-                    value=str(gradient_points[0])
-                ),
-                midpoint=InterpolationPoint(
-                    color_style=gradient_colors[1],
-                    type=InterpolationPointType.NUMBER,
-                    value=str(gradient_points[1])
-                ),
-                maxpoint=InterpolationPoint(
-                    color_style=gradient_colors[2],
-                    type=InterpolationPointType.NUMBER,
-                    value=str(gradient_points[2])
-                )
-            )
-        )).dict()
+
+        class Preset(StrEnum):
+            # Two interpolation points
+            WHITE_GREEN = 'WHITE_GREEN'
+            WHITE_YELLOW = 'WHITE_YELLOW'
+            WHITE_RED = 'WHITE_RED'
+            GREEN_WHITE = 'GREEN_WHITE'
+            YELLOW_WHITE = 'YELLOW_WHITE'
+            RED_WHITE = 'RED_WHITE'
+
+            # Three interpolation points
+            RED_WHITE_GREEN_PERCENTILE = 'RED_WHITE_GREEN_PERCENTILE'
+            RED_WHITE_GREEN_PERCENT = 'RED_WHITE_GREEN_PERCENT'
+            GREEN_YELLOW_RED_PERCENTILE = 'GREEN_YELLOW_RED_PERCENTILE'
+            GREEN_YELLOW_RED_PERCENT = 'GREEN_YELLOW_RED_PERCENT'
+            GREEN_WHITE_RED_PERCENTILE = 'GREEN_WHITE_RED_PERCENTILE'
+            GREEN_WHITE_RED_PERCENT = 'GREEN_WHITE_RED_PERCENT'
+            RED_YELLOW_GREEN_PERCENTILE = 'RED_YELLOW_GREEN_PERCENTILE'
+            RED_YELLOW_GREEN_PERCENT = 'RED_YELLOW_GREEN_PERCENT'
+
+        @staticmethod
+        def add_preset(*, sheet_id: int, ranges: list[str], preset: Preset) -> dict:
+            grid_ranges = [GridRange(sheet_id=sheet_id, **ApiRequest._split_excel_range(range_, return_as_dict=True)) for range_ in ranges]
+            AGP = ApiRequest.GradientRule.Preset
+
+            if preset in (AGP.WHITE_GREEN, AGP.WHITE_YELLOW, AGP.WHITE_RED, AGP.GREEN_WHITE, AGP.YELLOW_WHITE, AGP.RED_WHITE):
+                if preset == AGP.WHITE_YELLOW:
+                    minpoint_color_style, maxpoint_color_style = Color_.Basic.WHITE, Color_.ConditionalFormatting.YELLOW
+                elif preset == AGP.WHITE_RED:
+                    minpoint_color_style, maxpoint_color_style = Color_.Basic.WHITE, Color_.ConditionalFormatting.RED
+                elif preset == AGP.GREEN_WHITE:
+                    minpoint_color_style, maxpoint_color_style = Color_.ConditionalFormatting.GREEN, Color_.Basic.WHITE
+                elif preset == AGP.YELLOW_WHITE:
+                    minpoint_color_style, maxpoint_color_style = Color_.ConditionalFormatting.YELLOW, Color_.Basic.WHITE
+                elif preset == AGP.RED_WHITE:
+                    minpoint_color_style, maxpoint_color_style = Color_.ConditionalFormatting.RED, Color_.Basic.WHITE
+                else:  # preset == AGP.WHITE_GREEN and default
+                    minpoint_color_style, maxpoint_color_style = Color_.Basic.WHITE, Color_.ConditionalFormatting.GREEN
+
+                return AddConditionalFormatRule(rule=ConditionalFormatRule(
+                    ranges=grid_ranges,
+                    gradient_rule=GradientRule(
+                        minpoint=InterpolationPoint(
+                            color_style=minpoint_color_style,
+                            type=InterpolationPointType.MIN,
+                        ),
+                        maxpoint=InterpolationPoint(
+                            color_style=maxpoint_color_style,
+                            type=InterpolationPointType.MAX,
+                        )
+                    )
+                )).dict()
+
+            else:  # three interpolation points
+                if preset in (AGP.RED_WHITE_GREEN_PERCENTILE, AGP.RED_WHITE_GREEN_PERCENT):
+                    minpoint_cs, midpoint_cs, maxpoint_cs = Color_.ConditionalFormatting.RED, Color_.Basic.WHITE, Color_.ConditionalFormatting.GREEN
+                    midpoint_type = InterpolationPointType.PERCENTILE if preset == AGP.RED_WHITE_GREEN_PERCENTILE else InterpolationPointType.PERCENT
+                elif preset in (AGP.GREEN_YELLOW_RED_PERCENTILE, AGP.GREEN_YELLOW_RED_PERCENT):
+                    minpoint_cs, midpoint_cs, maxpoint_cs = Color_.ConditionalFormatting.GREEN, Color_.ConditionalFormatting.YELLOW, Color_.ConditionalFormatting.RED
+                    midpoint_type = InterpolationPointType.PERCENTILE if preset == AGP.GREEN_YELLOW_RED_PERCENTILE else InterpolationPointType.PERCENT
+                elif preset in (AGP.GREEN_WHITE_RED_PERCENTILE, AGP.GREEN_WHITE_RED_PERCENT):
+                    minpoint_cs, midpoint_cs, maxpoint_cs = Color_.ConditionalFormatting.GREEN, Color_.Basic.WHITE, Color_.ConditionalFormatting.RED
+                    midpoint_type = InterpolationPointType.PERCENTILE if preset == AGP.GREEN_WHITE_RED_PERCENTILE else InterpolationPointType.PERCENT
+                else:  # preset in (AGP.RED_YELLOW_GREEN_PERCENTILE, AGP.RED_YELLOW_GREEN_PERCENT):
+                    minpoint_cs, midpoint_cs, maxpoint_cs = Color_.ConditionalFormatting.RED, Color_.ConditionalFormatting.YELLOW, Color_.ConditionalFormatting.GREEN
+                    midpoint_type = InterpolationPointType.PERCENTILE if preset == AGP.RED_YELLOW_GREEN_PERCENTILE else InterpolationPointType.PERCENT
+
+                return AddConditionalFormatRule(rule=ConditionalFormatRule(
+                    ranges=grid_ranges,
+                    gradient_rule=GradientRule(
+                        minpoint=InterpolationPoint(
+                            color_style=minpoint_cs,
+                            type=InterpolationPointType.MIN,
+                        ),
+                        midpoint=InterpolationPoint(
+                            color_style=midpoint_cs,
+                            type=midpoint_type,
+                            value=50
+                        ),
+                        maxpoint=InterpolationPoint(
+                            color_style=maxpoint_cs,
+                            type=InterpolationPointType.MAX,
+                        )
+                    )
+                )).dict()
 
     @staticmethod
     def delete_conditional_format_rule(*, sheet_id: int, index: int) -> dict:
@@ -200,7 +325,7 @@ class ApiRequest:
 
     @staticmethod
     def merge_cells(sheet_id: int, range_: str, merge_type: MergeType = MergeType.MERGE_ALL) -> dict:
-        start_row, end_row, start_col, end_col = ApiRequest.__split_excel_range(range_)
+        start_row, end_row, start_col, end_col = ApiRequest._split_excel_range(range_)
         return MergeCells(
             range=GridRange(
                 sheet_id=sheet_id,
@@ -223,10 +348,10 @@ class ApiRequest:
     ) -> dict:
         assert range_ or (start_row and end_row and start_column and end_column), 'Either range_ or start_row, end_row, start_column, end_column must be specified'
         if range_:  # range_ has priority
-            start_row, end_row, start_column, end_column = ApiRequest.__split_excel_range(range_)
+            start_row, end_row, start_column, end_column = ApiRequest._split_excel_range(range_)
         else:
-            start_column = ApiRequest.__get_column_index(start_column) if isinstance(start_column, str) else start_column
-            end_column = ApiRequest.__get_column_index(end_column) if isinstance(end_column, str) else end_column
+            start_column = ApiRequest._get_column_index(start_column) if isinstance(start_column, str) else start_column
+            end_column = ApiRequest._get_column_index(end_column) if isinstance(end_column, str) else end_column
         return UnmergeCells(
             range=GridRange(
                 sheet_id=sheet_id,
@@ -304,7 +429,7 @@ class ApiRequest:
     @staticmethod
     def set_column_width(sheet_id: int, col_no_or_letter: int | str, width: int) -> dict:
         if isinstance(col_no_or_letter, str):
-            col_no = ApiRequest.__get_column_index(col_no_or_letter)
+            col_no = ApiRequest._get_column_index(col_no_or_letter)
         else:
             col_no = col_no_or_letter
         return UpdateDimensionProperties(
@@ -417,22 +542,22 @@ class ApiRequest:
         )).dict()
 
     @staticmethod
-    def __split_excel_range(range_: str, return_as_dict: bool = False) -> tuple[int, int, int, int] | dict[str, int]:
+    def _split_excel_range(range_: str, return_as_dict: bool = False) -> tuple[int, int, int, int] | dict[str, int]:
         if ':' in range_:
-            match = re.match(r"([A-Z]+)(\d+):([A-Z]+)(\d+)$", range_)
+            match = re.match(r'([A-Z]+)(\d+):([A-Z]+)(\d+)$', range_)
             if not match:
                 raise ValueError(f'Unsupported range format: {range_}')
             start_column, start_row, end_column, end_row = match.groups()
 
         else:
-            match = re.match(r"([A-Z]+)(\d+)$", range_)
+            match = re.match(r'([A-Z]+)(\d+)$', range_)
             if not match:
                 raise ValueError(f'Unsupported range format: {range_}')
             start_column, start_row = match.groups()
             end_column, end_row = start_column, start_row
 
         start_row, end_row = int(start_row), int(end_row)
-        start_column, end_column = ApiRequest.__get_column_index(start_column), ApiRequest.__get_column_index(end_column)
+        start_column, end_column = ApiRequest._get_column_index(start_column), ApiRequest._get_column_index(end_column)
         if start_row > end_row or start_column > end_column:
             raise ValueError(f'Invalid range: {range_}')
 
@@ -446,7 +571,7 @@ class ApiRequest:
         return start_row, end_row, start_column, end_column
 
     @staticmethod
-    def __get_column_index(column_letters: str) -> int:
+    def _get_column_index(column_letters: str) -> int:
         column_index = 0
         for i, letter in enumerate(column_letters[::-1].upper()):
             column_index += (ord(letter) - 64) * (26 ** i)

google_sheets/google_sheets.py

@@ -1,17 +1,20 @@
+from typing import TYPE_CHECKING
+
 from google.oauth2.service_account import Credentials
 from googleapiclient.discovery import build
 from googleapiclient.errors import HttpError
 
-from .spreadsheet_requests import Spreadsheet, SheetProperties
+from .spreadsheet_requests import Spreadsheet, SheetProperties, SimpleType
 
-SimpleType = str | int | float | bool
+if TYPE_CHECKING:
+    from googleapiclient.discovery import Resource  # noqa
 
 DEFAULT_PATH_TO_CREDS = 'service_account.json'
 
 
 class GoogleSheets:
     @staticmethod
-    def build_service(path_to_creds: str = DEFAULT_PATH_TO_CREDS):
+    def build_service(path_to_creds: str = DEFAULT_PATH_TO_CREDS) -> 'Resource':
         SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
         try:
             credentials = Credentials.from_service_account_file(path_to_creds, scopes=SCOPES)
@@ -82,7 +85,7 @@ class GoogleSheets:
         return spreadsheet_id, f'https://docs.google.com/spreadsheets/d/{spreadsheet_id}'
 
     @staticmethod
-    def update_spreadsheet(spreadsheet_id: str, api_requests: list[dict], service=None) -> None:
+    def update_spreadsheet(spreadsheet_id: str, api_requests: list[dict], service: 'Resource') -> None:
         """
         Updates Google Sheet with the specified API requests.
 
@@ -91,19 +94,13 @@ class GoogleSheets:
             api_requests (list[dict]): List of API requests to update the table
             service (googleapiclient.discovery.Resource): Google Sheets service object
         """
-        if service is None:
-            service = GoogleSheets.build_service()
-
         try:
             service.spreadsheets().batchUpdate(spreadsheetId=spreadsheet_id, body={'requests': api_requests}).execute(num_retries=5)
         except HttpError as e:
             raise e
 
     @staticmethod
-    def copy_sheet(source_spreadsheet_id: str, destination_spreadsheet_id: str, source_sheet_id: str = 0, service=None) -> SheetProperties:
-        if service is None:
-            service = GoogleSheets.build_service()
-
+    def copy_sheet(source_spreadsheet_id: str, source_sheet_id: str, destination_spreadsheet_id: str, service: 'Resource') -> SheetProperties:
         request = service.spreadsheets().sheets().copyTo(
             spreadsheetId=source_spreadsheet_id,
             sheetId=source_sheet_id,
@@ -115,14 +112,16 @@ class GoogleSheets:
             raise e
 
     @staticmethod
-    def get_spreadsheet(spreadsheet_id: str, service=None) -> Spreadsheet:
-        if service is None:
-            service = GoogleSheets.build_service()
-
+    def get_spreadsheet(spreadsheet_id: str, service: 'Resource') -> Spreadsheet:
         return Spreadsheet.model_validate(service.spreadsheets().get(spreadsheetId=spreadsheet_id).execute(num_retries=5))
 
     @staticmethod
-    def get_spreadsheet_range_values(spreadsheet_id: str, sheet: str | int, ranges: list[str], service=None) -> list[list[SimpleType] | list[list[SimpleType]]]:
+    def get_spreadsheet_range_values(
+            spreadsheet_id: str,
+            sheets: list[str | int],
+            ranges: list[list[str]],
+            service: 'Resource'
+    ) -> list[list[SimpleType] | list[list[SimpleType]]]:
         """
         Reads values from the specified ranges of the table.
         IMPORTANT: If the last cells in the range are empty, they will be omitted. If all cells are empty, an empty
@@ -131,30 +130,32 @@ class GoogleSheets:
 
         Args:
             spreadsheet_id (str): ID of the table
-            sheet (str | int): Name or ID of the sheet
-            ranges (list[str]): List of ranges to read in A1 notation
+            sheets (list[str | int]): Name or ID of the sheets to read from
+            ranges (list[list[str]]): List of ranges from each sheet to read in A1 notation
             service (googleapiclient.discovery.Resource): Google Sheets service object
 
         Returns:
-            list[list[str]]: List of values from the specified ranges in the same order
+            list[list[SimpleType] | list[list[SimpleType]]]: List of values from the specified ranges. Each range
+            corresponds to an element in the list. If the range is a single row or a single column, a list of values
+            is returned Otherwise, a list of lists of values is returned.
         """
-        if service is None:
-            service = GoogleSheets.build_service()
+        assert len(sheets) == len(ranges), 'sheets and ranges must have the same length'
 
-        if isinstance(sheet, int):
+        ranges_processed = []
+        if any(isinstance(sheet, int) for sheet in sheets):
             ss = GoogleSheets.get_spreadsheet(spreadsheet_id, service)
-            try:
-                sheet_name = next(sht.properties.title for sht in ss.sheets if sht.properties.sheet_id == sheet)
-            except StopIteration:
-                return []
-        else:
-             sheet_name = sheet
-        ranges = [f'{sheet_name}!{range_}' for range_ in ranges]
+            for i in range(len(sheets)):
+                if isinstance(sheets[i], int):
+                    try:
+                        sheets[i] = next(sht.properties.title for sht in ss.sheets if sht.properties.sheet_id == sheets[i])
+                    except StopIteration:
+                        return [[]]
+                ranges_processed.extend([f'{sheets[i]}!{range_}' for range_ in ranges[i]])
 
         try:
             response = service.spreadsheets().values().batchGet(
                 spreadsheetId=spreadsheet_id,
-                ranges=ranges,
+                ranges=ranges_processed,
                 valueRenderOption='UNFORMATTED_VALUE',
                 dateTimeRenderOption='FORMATTED_STRING'
             ).execute(num_retries=5)
@@ -177,18 +178,3 @@ class GoogleSheets:
                         result.append(values)
 
             return result
-
-    @staticmethod
-    def get_spreadsheet_id_from_url(url: str) -> str:
-        """
-        Extracts the ID of the spreadsheet from the URL.
-
-        Args:
-            url (str): URL of the table
-
-        Returns:
-            str: ID of the table
-        """
-        if '/edit' in url:
-            url = url[:url.index('/edit')]
-        return url.split('/')[-1]

google_sheets/spreadsheet_requests/__init__.py

@@ -3,6 +3,11 @@ from .conditional_format_rule import (
     DeleteConditionalFormatRule,
     UpdateConditionalFormatRule,
     ConditionalFormatRule,
+    BooleanRule,
+    BooleanCondition,
+    ConditionType,
+    ConditionValue,
+    RelativeDate,
     GradientRule,
     InterpolationPoint,
     InterpolationPointType,
@@ -57,4 +62,5 @@ from .general_models import (
     ColorStyle,
     GridRange,
     FieldMask,
+    SimpleType,
 )

google_sheets/spreadsheet_requests/conditional_format_rule.py

@@ -8,9 +8,10 @@ This module contains the models for the following Google Sheets API requests:
 import json
 from enum import StrEnum
 
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, Field, model_validator, field_validator
 
-from .general_models import ColorStyle, GridRange
+from .general_models import ColorStyle, GridRange, SimpleType
+from .update_cells import CellFormat
 
 
 class InterpolationPointType(StrEnum):
@@ -24,29 +25,104 @@ class InterpolationPointType(StrEnum):
 class InterpolationPoint(BaseModel):
     color_style: ColorStyle = Field(..., alias='colorStyle')
     type: InterpolationPointType
-    value: str = None
+    value: SimpleType | None = None  # Required only for types NUMBER, PERCENT and PERCENTILE
+
+    @field_validator('value', mode='before')
+    @classmethod
+    def coerce_to_str(cls, v: SimpleType | None):
+        if v is not None and not isinstance(v, str):
+            return str(v)
+        return v
+
+    class Config:
+        populate_by_name = True
+
+
+class RelativeDate(StrEnum):
+    PAST_YEAR = 'PAST_YEAR'  # One year before today
+    PAST_MONTH = 'PAST_MONTH'  # One month before today
+    PAST_WEEK = 'PAST_WEEK'  # One week before today
+    YESTERDAY = 'YESTERDAY'
+    TODAY = 'TODAY'
+    TOMORROW = 'TOMORROW'
+
+
+class ConditionValue(BaseModel):
+    """ Union field, exactly one must be set """
+    relative_date: RelativeDate | None = Field(None, alias='relativeDate')
+    user_entered_value: SimpleType | None = Field(None, alias='userEnteredValue')
+
+    @field_validator('user_entered_value', mode='before')
+    @classmethod
+    def coerce_to_str(cls, v: SimpleType | None):
+        if v is not None and not isinstance(v, str):
+            return str(v)
+        return v
 
     class Config:
         populate_by_name = True
 
 
+class ConditionType(StrEnum):
+    NUMBER_GREATER = 'NUMBER_GREATER'  # Requires ONE ConditionValue
+    NUMBER_GREATER_THAN_EQ = 'NUMBER_GREATER_THAN_EQ'  # Requires ONE ConditionValue
+    NUMBER_LESS = 'NUMBER_LESS'  # Requires ONE ConditionValue
+    NUMBER_LESS_THAN_EQ = 'NUMBER_LESS_THAN_EQ'  # Requires ONE ConditionValue
+    NUMBER_EQ = 'NUMBER_EQ'  # Requires ONE ConditionValue ...
+    NUMBER_NOT_EQ = 'NUMBER_NOT_EQ'  # Requires ONE ConditionValue ...
+    NUMBER_BETWEEN = 'NUMBER_BETWEEN'  # Requires TWO ConditionValue
+    NUMBER_NOT_BETWEEN = 'NUMBER_NOT_BETWEEN'  # Requires TWO ConditionValue
+    TEXT_CONTAINS = 'TEXT_CONTAINS'  # Requires ONE ConditionValue
+    TEXT_NOT_CONTAINS = 'TEXT_NOT_CONTAINS'  # Requires ONE ConditionValue
+    TEXT_STARTS_WITH = 'TEXT_STARTS_WITH'  # Requires ONE ConditionValue
+    TEXT_ENDS_WITH = 'TEXT_ENDS_WITH'  # Requires ONE ConditionValue
+    TEXT_EQ = 'TEXT_EQ'  # Requires ONE ConditionValue ...
+    TEXT_IS_EMAIL = 'TEXT_IS_EMAIL'  # Requires NO ConditionValue
+    TEXT_IS_URL = 'TEXT_IS_URL'  # Requires NO ConditionValue
+    DATE_EQ = 'DATE_EQ'  # Requires ONE ConditionValue ...
+    DATE_BEFORE = 'DATE_BEFORE'  # Requires ONE ConditionValue (may be a RelativeDate)
+    DATE_AFTER = 'DATE_AFTER'  # Requires ONE ConditionValue (may be a RelativeDate)
+    DATE_ON_OR_BEFORE = 'DATE_ON_OR_BEFORE'  # Requires ONE ConditionValue (may be a RelativeDate)
+    DATE_ON_OR_AFTER = 'DATE_ON_OR_AFTER'  # Requires ONE ConditionValue (may be a RelativeDate)
+    DATE_BETWEEN = 'DATE_BETWEEN'  # Requires TWO ConditionValue
+    DATE_NOT_BETWEEN = 'DATE_NOT_BETWEEN'  # Requires TWO ConditionValue
+    DATE_IS_VALID = 'DATE_IS_VALID'  # Requires NO ConditionValue
+    ONE_OF_RANGE = 'ONE_OF_RANGE'  # Requires ONE ConditionValue
+    ONE_OF_LIST = 'ONE_OF_LIST'  # Supports ANY NUMBER of ConditionValue
+    BLANK = 'BLANK'  # Requires NO ConditionValue
+    NOT_BLANK = 'NOT_BLANK'  # Requires NO ConditionValue
+    CUSTOM_FORMULA = 'CUSTOM_FORMULA'  # Requires ONE ConditionValue
+    BOOLEAN = 'BOOLEAN'  # Supports ZERO, ONE or TWO ConditionValue
+    TEXT_NOT_EQ = 'TEXT_NOT_EQ'  # Requires AT LEAST ONE ConditionValue
+    DATE_NOT_EQ = 'DATE_NOT_EQ'  # Requires AT LEAST ONE ConditionValue
+    FILTER_EXPRESSION = 'FILTER_EXPRESSION'  # Requires ONE ConditionValue
+
+
+class BooleanCondition(BaseModel):
+    type: ConditionType
+    values: list[ConditionValue]
+
+
 class BooleanRule(BaseModel):
-    condition: dict
-    format: dict
+    condition: BooleanCondition
+    format: CellFormat
 
 
 class GradientRule(BaseModel):
     minpoint: InterpolationPoint
-    midpoint: InterpolationPoint = None
+    midpoint: InterpolationPoint | None = None
     maxpoint: InterpolationPoint
 
 
 class ConditionalFormatRule(BaseModel):
     ranges: list[GridRange]
-    boolean_rule: BooleanRule = Field(None, alias='booleanRule')
-    gradient_rule: GradientRule = Field(None, alias='gradientRule')
+
+    # Union field rule, exactly one must be set
+    boolean_rule: BooleanRule | None = Field(None, alias='booleanRule')
+    gradient_rule: GradientRule | None = Field(None, alias='gradientRule')
 
     @model_validator(mode='before')
+    @classmethod
     def init_before(cls, values: dict):
         bool_rule = values.get('boolean_rule', values.get('booleanRule'))
         grad_rule = values.get('gradient_rule', values.get('gradientRule'))
@@ -81,10 +157,11 @@ class UpdateConditionalFormatRule(BaseModel):
     sheet_id: int = Field(..., serialization_alias='sheetId')
 
     # Union field instruction can be only one of the following:
-    rule: ConditionalFormatRule = None
-    new_index: int = Field(None, serialization_alias='newIndex')
+    rule: ConditionalFormatRule | None = None
+    new_index: int | None = Field(None, serialization_alias='newIndex')
 
     @model_validator(mode='before')
+    @classmethod
     def init_before(cls, values: dict):
         if ('rule' in values) == ('new_index' in values):
             raise ValueError('either rule or new_index must be set, but not both')

google_sheets/spreadsheet_requests/general_models.py

@@ -3,6 +3,9 @@ from enum import StrEnum
 from pydantic import BaseModel, Field, model_validator
 
 
+SimpleType = str | int | float | bool
+
+
 class ThemeColorType(StrEnum):
     TEXT = 'TEXT'
     BACKGROUND = 'BACKGROUND'