python-google-sheets 0.1.0__py3-none-any.whl

google_sheets/spreadsheet_requests/__init__.py

@@ -0,0 +1,60 @@
+from .conditional_format_rule import (
+    AddConditionalFormatRule,
+    DeleteConditionalFormatRule,
+    UpdateConditionalFormatRule,
+    ConditionalFormatRule,
+    GradientRule,
+    InterpolationPoint,
+    InterpolationPointType,
+)
+from .update_sheet_properties import (
+    UpdateSheetProperties,
+    SheetProperties,
+    GridProperties,
+)
+from .merge_cells import (
+    MergeType,
+    MergeCells,
+    UnmergeCells,
+)
+from .dimension import (
+    InsertDimension,
+    UpdateDimensionProperties,
+    AddDimensionGroup,
+    DeleteDimensionGroup,
+    DimensionProperties,
+    DimensionRange,
+    Dimension,
+)
+from .update_cells import (
+    UpdateCells,
+    RowData,
+    CellData,
+    ExtendedValue,
+    CellFormat,
+    NumberFormat,
+    NumberFormatType,
+    TextFormat,
+    TextDirection,
+    TextRotation,
+    Borders,
+    Border,
+    Style as BorderStyle,
+    HorizontalAlignment,
+    VerticalAlignment,
+    WrapStrategy,
+)
+from .spreadsheet import (
+    Spreadsheet,
+    SpreadsheetProperties,
+    Sheet,
+    AddSheet,
+    DeleteSheet,
+)
+
+from .general_models import (
+    Color,
+    ColorStyle,
+    GridRange,
+    FieldMask,
+)

google_sheets/spreadsheet_requests/conditional_format_rule.py

@@ -0,0 +1,95 @@
+"""
+This module contains the models for the following Google Sheets API requests:
+
+- AddConditionalFormatRule
+- DeleteConditionalFormatRule
+"""
+
+import json
+from enum import StrEnum
+
+from pydantic import BaseModel, Field, model_validator
+
+from .general_models import ColorStyle, GridRange
+
+
+class InterpolationPointType(StrEnum):
+    MIN = 'MIN'
+    MAX = 'MAX'
+    NUMBER = 'NUMBER'
+    PERCENT = 'PERCENT'
+    PERCENTILE = 'PERCENTILE'
+
+
+class InterpolationPoint(BaseModel):
+    color_style: ColorStyle = Field(..., alias='colorStyle')
+    type: InterpolationPointType
+    value: str = None
+
+    class Config:
+        populate_by_name = True
+
+
+class BooleanRule(BaseModel):
+    condition: dict
+    format: dict
+
+
+class GradientRule(BaseModel):
+    minpoint: InterpolationPoint
+    midpoint: InterpolationPoint = None
+    maxpoint: InterpolationPoint
+
+
+class ConditionalFormatRule(BaseModel):
+    ranges: list[GridRange]
+    boolean_rule: BooleanRule = Field(None, alias='booleanRule')
+    gradient_rule: GradientRule = Field(None, alias='gradientRule')
+
+    @model_validator(mode='before')
+    def init_before(cls, values: dict):
+        bool_rule = values.get('boolean_rule', values.get('booleanRule'))
+        grad_rule = values.get('gradient_rule', values.get('gradientRule'))
+        if (bool_rule is None) == (grad_rule is None):
+            raise ValueError('either boolean_rule or gradient_rule must be set, but not both')
+        return values
+
+    class Config:
+        populate_by_name = True
+
+
+class AddConditionalFormatRule(BaseModel):
+    rule: ConditionalFormatRule
+    index: int = 0
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}
+
+
+class DeleteConditionalFormatRule(BaseModel):
+    index: int
+    sheet_id: int
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}
+
+
+class UpdateConditionalFormatRule(BaseModel):
+    index: int
+    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')
+
+    @model_validator(mode='before')
+    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')
+        return values
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}

google_sheets/spreadsheet_requests/dimension.py

@@ -0,0 +1,77 @@
+"""
+This module contains the models for the following Google Sheets API requests:
+
+- InsertDimension
+- UpdateDimensionProperties
+"""
+
+import json
+from enum import StrEnum
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class Dimension(StrEnum):
+    ROWS = 'ROWS'
+    COLUMNS = 'COLUMNS'
+
+
+class DimensionRange(BaseModel):
+    sheet_id: int = Field(..., serialization_alias='sheetId', ge=0)
+    dimension: Dimension
+    start_index: int = Field(..., serialization_alias='startIndex', ge=0)
+    end_index: int = Field(..., serialization_alias='endIndex', gt=0)
+
+    @model_validator(mode='after')
+    def check_indexes(self):
+        if self.start_index >= self.end_index:
+            raise ValueError(f'start_index ({self.start_index}) must be less than end_index ({self.end_index})')
+        return self
+
+
+class DimensionProperties(BaseModel):
+    hidden_by_user: bool = Field(None, alias='hiddenByUser')
+    pixel_size: int = Field(None, alias='pixelSize')
+    developer_metadata: dict = Field(None, alias='developerMetadata')
+    data_source_column_reference: dict = Field(None, alias='dataSourceColumnReference')
+
+    # Read-only
+    hidden_by_filter: bool = Field(None, alias='hiddenByFilter')
+
+    class Config:
+        populate_by_name = True
+
+
+class InsertDimension(BaseModel):
+    range: DimensionRange
+    inherit_from_before: bool = Field(..., serialization_alias='inheritFromBefore')
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}
+
+
+class UpdateDimensionProperties(BaseModel):
+    range: DimensionRange
+    properties: DimensionProperties
+    fields: str
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}
+
+
+class AddDimensionGroup(BaseModel):
+    range: DimensionRange
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}
+
+
+class DeleteDimensionGroup(BaseModel):
+    range: DimensionRange
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}

google_sheets/spreadsheet_requests/general_models.py

@@ -0,0 +1,79 @@
+from enum import StrEnum
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class ThemeColorType(StrEnum):
+    TEXT = 'TEXT'
+    BACKGROUND = 'BACKGROUND'
+    ACCENT1 = 'ACCENT1'
+    ACCENT2 = 'ACCENT2'
+    ACCENT3 = 'ACCENT3'
+    ACCENT4 = 'ACCENT4'
+    ACCENT5 = 'ACCENT5'
+    ACCENT6 = 'ACCENT6'
+    LINK = 'LINK'
+
+
+class Color(BaseModel):
+    red: float = Field(1, ge=0, le=1)
+    green: float = Field(1, ge=0, le=1)
+    blue: float = Field(1, ge=0, le=1)
+    alpha: float = Field(1, ge=0, le=1)
+
+
+class ColorStyle(BaseModel):
+    rgb_color: Color = Field(..., alias='rgbColor')
+    theme_color: ThemeColorType = Field(None, alias='themeColor')
+
+    class Config:
+        populate_by_name = True
+
+
+class GridRange(BaseModel):
+    """
+    A range on a sheet. All indexes are zero-based. Indexes are half open, i.e. the start index is inclusive and the
+    end index is exclusive -- [startIndex, endIndex). Missing indexes indicate the range is unbounded on that side.
+    """
+
+    sheet_id: int = Field(None, alias='sheetId', ge=0)
+    start_row_index: int = Field(..., alias='startRowIndex', ge=0)
+    end_row_index: int = Field(..., alias='endRowIndex', gt=0)
+    start_column_index: int = Field(..., alias='startColumnIndex', ge=0)
+    end_column_index: int = Field(..., alias='endColumnIndex', gt=0)
+
+    @model_validator(mode='after')
+    def check_indexes(self):
+        if self.start_row_index >= self.end_row_index:
+            raise ValueError(f'start_row_index ({self.start_row_index}) must be less than end_row_index ({self.end_row_index})')
+        if self.start_column_index >= self.end_column_index:
+            raise ValueError(f'start_column_index ({self.start_column_index}) must be less than end_column_index ({self.end_column_index})')
+        return self
+
+    class Config:
+        populate_by_name = True
+
+
+class FieldMask:
+    TITLE = 'title'
+    PIXEL_SIZE = 'pixelSize'
+
+    class GridProperties:
+        ALL = 'gridProperties'
+        ROW_COUNT = 'gridProperties.rowCount'
+        COLUMN_COUNT = 'gridProperties.columnCount'
+        FROZEN_ROW_COUNT = 'gridProperties.frozenRowCount'
+        FROZEN_COLUMN_COUNT = 'gridProperties.frozenColumnCount'
+        HIDE_GRID_LINES = 'gridProperties.hideGridlines'
+        ROW_GROUP_CONTROL_AFTER = 'gridProperties.rowGroupControlAfter'
+        COLUMN_GROUP_CONTROL_AFTER = 'gridProperties.columnGroupControlAfter'
+
+    class CellData:
+        USER_ENTERED_VALUE = 'userEnteredValue'
+        USER_ENTERED_FORMAT = 'userEnteredFormat'
+
+    class Spreadsheet:
+        ID = 'spreadsheetId'
+        URL = 'spreadsheetUrl'
+        PROPERTIES = 'properties'
+        SHEETS = 'sheets'

google_sheets/spreadsheet_requests/merge_cells.py

@@ -0,0 +1,35 @@
+"""
+This module contains the models for the following Google Sheets API requests:
+
+- MergeCells
+- UnmergeCells
+"""
+
+import json
+from enum import StrEnum
+from pydantic import BaseModel, Field
+
+from .general_models import GridRange
+
+
+class MergeType(StrEnum):
+    MERGE_ALL = 'MERGE_ALL'
+    MERGE_COLUMNS = 'MERGE_COLUMNS'
+    MERGE_ROWS = 'MERGE_ROWS'
+
+
+class MergeCells(BaseModel):
+    range: GridRange
+    merge_type: MergeType = Field(..., serialization_alias='mergeType')
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}
+
+
+class UnmergeCells(BaseModel):
+    range: GridRange
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}

google_sheets/spreadsheet_requests/spreadsheet.py

@@ -0,0 +1,91 @@
+import json
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+from .update_sheet_properties import SheetProperties
+from .update_cells import RowData
+from .dimension import DimensionProperties
+from .conditional_format_rule import ConditionalFormatRule
+from .general_models import GridRange
+
+
+class RecalculationInterval(StrEnum):
+    ON_CHANGE = 'ON_CHANGE'
+    MINUTE = 'MINUTE'
+    HOUR = 'HOUR'
+
+
+class SpreadsheetProperties(BaseModel):
+    title: str
+    locale: str = 'ru_RU'
+    auto_recalc: RecalculationInterval = Field(None, alias='autoRecalc')
+    time_zone: str = Field('Europe/Moscow', alias='timeZone')
+    iterative_calculation_settings: dict = Field(None, alias='iterativeCalculationSettings')
+    spreadsheet_theme: dict = Field(None, alias='spreadsheetTheme')
+    import_functions_external_url_access_allowed: bool = Field(None, alias='importFunctionsExternalUrlAccessAllowed')
+
+    # Read-only
+    default_format: dict = Field(None, alias='defaultFormat')
+
+    class Config:
+        populate_by_name = True
+
+
+class GridData(BaseModel):
+    start_row: int = Field(None, alias='startRow')
+    start_column: int = Field(None, alias='startColumn')
+    row_data: list[RowData] = Field(None, alias='rowData')
+    row_metadata: list[DimensionProperties] = Field(None, alias='rowMetadata')
+    column_metadata: list[DimensionProperties] = Field(None, alias='columnMetadata')
+
+
+class Sheet(BaseModel):
+    properties: SheetProperties = None
+    data: list[GridData] = None
+    merges: list[GridRange] = None
+    conditional_formats: list[ConditionalFormatRule] = Field(None, alias='conditionalFormats')
+    filter_views: list[dict] = Field(None, alias='filterViews')
+    protected_ranges: list[dict] = Field(None, alias='protectedRanges')
+    basic_filter: dict = Field(None, alias='basicFilter')
+    charts: list[dict] = None
+    banded_ranges: list[dict] = Field(None, alias='bandedRanges')
+    developer_metadata: list[dict] = Field(None, alias='developerMetadata')
+    row_groups: list[dict] = Field(None, alias='rowGroups')
+    column_groups: list[dict] = Field(None, alias='columnGroups')
+    slicers: list[dict] = None
+
+    class Config:
+        populate_by_name = True
+
+
+class Spreadsheet(BaseModel):
+    properties: SpreadsheetProperties = None
+    sheets: list[Sheet] = None
+    named_ranges: list[dict] = Field(None, alias='namedRanges')
+    developer_metadata: list[dict] = Field(None, alias='developerMetadata')
+    data_sources: list[dict] = Field(None, alias='dataSources')
+
+    # Read-only
+    spreadsheet_id: str = Field(None, alias='spreadsheetId')
+    spreadsheet_url: str = Field(None, alias='spreadsheetUrl')
+    data_source_schedules: list[dict] = Field(None, alias='dataSourceSchedules')
+
+    class Config:
+        populate_by_name = True
+
+
+class DeleteSheet(BaseModel):
+    sheet_id: int = Field(..., serialization_alias='sheetId')
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}
+
+
+class AddSheet(BaseModel):
+    properties: SheetProperties = None
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}

google_sheets/spreadsheet_requests/update_cells.py

@@ -0,0 +1,242 @@
+"""
+This module contains models for the following Google Sheets API requests:
+- UpdateCells
+"""
+
+from __future__ import annotations
+
+import json
+from enum import StrEnum
+from typing import Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+from .general_models import GridRange, ColorStyle
+
+
+class NumberFormatType(StrEnum):
+    TEXT = 'TEXT'
+    NUMBER = 'NUMBER'
+    PERCENT = 'PERCENT'
+    CURRENCY = 'CURRENCY'
+    DATE = 'DATE'
+    TIME = 'TIME'
+    DATE_TIME = 'DATE_TIME'
+    SCIENTIFIC = 'SCIENTIFIC'
+
+class NumberFormat(BaseModel):
+    type_: NumberFormatType = Field(..., alias='type')
+    pattern: str = None
+
+
+class Style(StrEnum):
+    DOTTED = 'DOTTED'
+    DASHED = 'DASHED'
+    SOLID = THIN = 'SOLID'
+    SOLID_MEDIUM = MEDIUM = 'SOLID_MEDIUM'
+    SOLID_THICK = THICK = 'SOLID_THICK'
+    NONE = 'NONE'
+    DOUBLE = 'DOUBLE'
+
+class Border(BaseModel):
+    style: Style
+    color_style: ColorStyle = Field(None, serialization_alias='colorStyle')
+
+class Borders(BaseModel):
+    top: Optional[Border] = None
+    bottom: Optional[Border] = None
+    left: Optional[Border] = None
+    right: Optional[Border] = None
+
+    @model_validator(mode='before')
+    def check_exclusive_fields(cls, values):
+        filled_fields = [key for key, value in values.items() if value is not None]
+        if len(filled_fields) == 0:
+            raise ValueError('at least one border must be set')
+        return values
+
+
+class Padding(BaseModel):
+    top: Optional[int]
+    right: Optional[int]
+    bottom: Optional[int]
+    left: Optional[int]
+
+    @model_validator(mode='before')
+    def check_exclusive_fields(cls, values):
+        filled_fields = [key for key, value in values.items() if value is not None]
+        if len(filled_fields) == 0:
+            raise ValueError('at least one padding must be set')
+        return values
+
+
+class HorizontalAlignment(StrEnum):
+    LEFT = 'LEFT'
+    CENTER = 'CENTER'
+    RIGHT = 'RIGHT'
+
+class VerticalAlignment(StrEnum):
+    TOP = 'TOP'
+    MIDDLE = 'MIDDLE'
+    BOTTOM = 'BOTTOM'
+
+
+class WrapStrategy(StrEnum):
+    OVERFLOW_CELL = 'OVERFLOW_CELL'
+    # LEGACY_WRAP = 'LEGACY_WRAP'  # Not supported on all platforms
+    CLIP = 'CLIP'
+    WRAP = 'WRAP'
+
+
+class TextDirection(StrEnum):
+    LEFT_TO_RIGHT = 'LEFT_TO_RIGHT'
+    RIGHT_TO_LEFT = 'RIGHT_TO_LEFT'
+
+
+class Link:
+    uri: str = None
+
+class TextFormat(BaseModel):
+    foreground_color_style: Optional[ColorStyle] = Field(None, serialization_alias='foregroundColorStyle')
+    font_family: Optional[str] = Field(None, serialization_alias='fontFamily')
+    font_size: Optional[int] = Field(None, serialization_alias='fontSize')
+    bold: Optional[bool] = None
+    italic: Optional[bool] = None
+    strikethrough: Optional[bool] = None
+    underline: Optional[bool] = None
+    link: Optional[Link] = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class HyperlinkDisplayType(StrEnum):
+    LINKED = 'LINKED'
+    PLAIN_TEXT = 'PLAIN_TEXT'
+
+
+class TextRotation(BaseModel):
+    angle: int = Field(None, ge=-90, le=90)  # Angle between the standard orientation and the desired orientation, direction is counterclockwise
+    vertical: bool = None  # Text reads top to bottom, but the orientation of individual characters is unchanged
+
+    @model_validator(mode='before')
+    def check_exclusive_fields(cls, values):
+        filled_fields = [key for key, value in values.items() if value is not None]
+        if len(filled_fields) != 1:
+            raise ValueError(f'only one field must be set, but got {filled_fields}')
+        return values
+
+
+class CellFormat(BaseModel):
+    number_format: Optional[NumberFormat] = Field(None, alias='numberFormat')
+    background_color_style: Optional[ColorStyle] = Field(None, alias='backgroundColorStyle')
+    borders: Optional[Borders] = None
+    padding: Optional[Padding] = None
+    horizontal_alignment: Optional[HorizontalAlignment] = Field(None, alias='horizontalAlignment')
+    vertical_alignment: Optional[VerticalAlignment] = Field(None, alias='verticalAlignment')
+    wrap_strategy: Optional[WrapStrategy] = Field(None, alias='wrapStrategy')
+    text_direction: Optional[TextDirection] = Field(None, alias='textDirection')
+    text_format: Optional[TextFormat] = Field(None, alias='textFormat')
+    hyperlink_display_type: Optional[HyperlinkDisplayType] = Field(None, alias='hyperlinkDisplayType')
+    text_rotation: Optional[TextRotation] = Field(None, alias='textRotation')
+
+    def __add__(self, other) -> CellFormat:
+        number_format = other.number_format or self.number_format
+        if other.number_format and self.number_format:
+            number_format = NumberFormat(
+                type=other.number_format.type_ or self.number_format.type_,
+                pattern=other.number_format.pattern or self.number_format.pattern,
+            )
+
+        borders = other.borders or self.borders
+        if other.borders and self.borders:
+            borders = Borders(
+                top=other.borders.top or self.borders.top,
+                bottom=other.borders.bottom or self.borders.bottom,
+                left=other.borders.left or self.borders.left,
+                right=other.borders.right or self.borders.right,
+            )
+
+        text_format = other.text_format or self.text_format
+        if other.text_format and self.text_format:
+            text_format = TextFormat(
+                foreground_color_style=other.text_format.foreground_color_style or self.text_format.foreground_color_style,
+                font_family=other.text_format.font_family or self.text_format.font_family,
+                font_size=other.text_format.font_size or self.text_format.font_size,
+                bold=other.text_format.bold or self.text_format.bold,
+                italic=other.text_format.italic or self.text_format.italic,
+                strikethrough=other.text_format.strikethrough or self.text_format.strikethrough,
+                underline=other.text_format.underline or self.text_format.underline,
+                link=other.text_format.link or self.text_format.link,
+            )
+
+        return CellFormat(
+            number_format=number_format,
+            background_color_style=other.background_color_style or self.background_color_style,
+            borders=borders,
+            padding=other.padding or self.padding,
+            horizontal_alignment=other.horizontal_alignment or self.horizontal_alignment,
+            vertical_alignment=other.vertical_alignment or self.vertical_alignment,
+            wrap_strategy=other.wrap_strategy or self.wrap_strategy,
+            text_direction=other.text_direction or self.text_direction,
+            text_format=text_format,
+            hyperlink_display_type=other.hyperlink_display_type or self.hyperlink_display_type,
+            text_rotation=other.text_rotation or self.text_rotation,
+        )
+
+    class Config:
+        populate_by_name = True
+
+
+class ExtendedValue(BaseModel):
+    number_value: Optional[float] = Field(None, alias='numberValue')
+    string_value: Optional[str] = Field(None, alias='stringValue')
+    bool_value: Optional[bool] = Field(None, alias='boolValue')
+    formula_value: Optional[str] = Field(None, alias='formulaValue')
+
+    # Read-only
+    error_value: dict = Field(None, alias='errorValue')
+
+    @model_validator(mode='before')
+    def check_exclusive_fields(cls, values):
+        filled_fields = [key for key, value in values.items() if value is not None]
+        if len(filled_fields) != 1:
+            raise ValueError(f'only one field must be set, but got {filled_fields}')
+        return values
+
+    class Config:
+        populate_by_name = True
+
+
+class CellData(BaseModel):
+    user_entered_value: Optional[ExtendedValue] = Field(None, alias='userEnteredValue')
+    user_entered_format: Optional[CellFormat] = Field(None, alias='userEnteredFormat')
+    note: str = None
+    text_format_runs: list[dict] = Field(None, alias='textFormatRuns')
+    data_validation: dict = Field(None, alias='dataValidation')
+    pivot_table: dict = Field(None, alias='pivotTable')
+    data_source_table: dict = Field(None, alias='dataSourceTable')
+    data_source_formula: dict = Field(None, alias='dataSourceFormula')
+
+    # Read-only
+    effective_value: ExtendedValue = Field(None, alias='effectiveValue')
+    formatted_value: str = Field(None, alias='formattedValue')
+    effective_format: CellFormat = Field(None, alias='effectiveFormat')
+    hyperlink: str = None
+    
+    class Config:
+        populate_by_name = True
+
+
+class RowData(BaseModel):
+    values: list[CellData]
+
+
+class UpdateCells(BaseModel):
+    range: GridRange
+    rows: list[RowData] = []
+    fields: str
+
+    def dict(self, *args, **kwargs):
+        class_name = self.__class__.__name__[0].lower() + self.__class__.__name__[1:]
+        return {class_name: json.loads(super().json(*args, **kwargs, by_alias=True, exclude_none=True))}