numbers-parser 4.7.1__py3-none-any.whl → 4.8.0__py3-none-any.whl

numbers_parser/model.py

@@ -17,14 +17,18 @@ from numbers_parser.cell import (
     BoolCell,
     Border,
     BorderType,
+    CustomFormatting,
     DateCell,
     DurationCell,
     EmptyCell,
+    Formatting,
+    FormattingType,
     HorizontalJustification,
     MergeAnchor,
     MergedCell,
     MergeReference,
     NumberCell,
+    PaddingType,
     RichTextCell,
     Style,
     TextCell,
@@ -35,7 +39,10 @@ from numbers_parser.cell import (
 )
 from numbers_parser.cell_storage import CellStorage
 from numbers_parser.constants import (
+    ALLOWED_FORMATTING_PARAMETERS,
     CURRENCY_CELL_TYPE,
+    CUSTOM_FORMAT_TYPE_MAP,
+    CUSTOM_TEXT_PLACEHOLDER,
     DEFAULT_COLUMN_WIDTH,
     DEFAULT_DOCUMENT,
     DEFAULT_PRE_BNC_BYTES,
@@ -46,8 +53,10 @@ from numbers_parser.constants import (
     DEFAULT_TILE_SIZE,
     DOCUMENT_ID,
     EPOCH,
+    FORMAT_TYPE_MAP,
     MAX_TILE_SIZE,
     PACKAGE_ID,
+    FormatType,
 )
 from numbers_parser.containers import ObjectStore
 from numbers_parser.exceptions import UnsupportedError, UnsupportedWarning
@@ -55,6 +64,7 @@ from numbers_parser.formula import TableFormulas
 from numbers_parser.generated import TNArchives_pb2 as TNArchives
 from numbers_parser.generated import TSCEArchives_pb2 as TSCEArchives
 from numbers_parser.generated import TSDArchives_pb2 as TSDArchives
+from numbers_parser.generated import TSKArchives_pb2 as TSKArchives
 from numbers_parser.generated import TSPArchiveMessages_pb2 as TSPArchiveMessages
 from numbers_parser.generated import TSPMessages_pb2 as TSPMessages
 from numbers_parser.generated import TSSArchives_pb2 as TSSArchives
@@ -87,11 +97,11 @@ class MergeCells:
     def __init__(self):
         self._references = defaultdict(lambda: False)
 
-    def add_reference(self, row_num: int, col_num: int, rect: Tuple):
-        self._references[(row_num, col_num)] = MergeReference(*rect)
+    def add_reference(self, row: int, col: int, rect: Tuple):
+        self._references[(row, col)] = MergeReference(*rect)
 
-    def add_anchor(self, row_num: int, col_num: int, size: Tuple):
-        self._references[(row_num, col_num)] = MergeAnchor(size)
+    def add_anchor(self, row: int, col: int, size: Tuple):
+        self._references[(row, col)] = MergeAnchor(size)
 
     def is_merge_reference(self, row_col: Tuple) -> bool:
         return isinstance(self._references[row_col], MergeReference)
@@ -217,6 +227,9 @@ class _NumbersModel(Cacheable):
         self._table_strings = DataLists(self, "stringTable", "string")
         self._table_data = {}
         self._styles = None
+        self._custom_formats = None
+        self._custom_format_archives = None
+        self._custom_format_ids = None
         self._strokes = {
             "top": defaultdict(),
             "right": defaultdict(),
@@ -346,11 +359,126 @@ class _NumbersModel(Cacheable):
         """Return the format associated with a format ID for a particular table."""
         return self._table_formats.lookup_value(table_id, key).format
 
-    @cache(num_args=2)
-    def table_format_id(self, table_id: int, format) -> id:
-        """Return the table format ID for a format string, creating a new one if required."""
+    @cache(num_args=3)
+    def format_archive(self, table_id: int, format_type: FormattingType, format: Formatting):
+        """Create a table format from a Formatting spec and return the table format ID"""
+        attrs = {x: getattr(format, x) for x in ALLOWED_FORMATTING_PARAMETERS[format_type]}
+        attrs["format_type"] = FORMAT_TYPE_MAP[format_type]
+
+        format = TSKArchives.FormatStructArchive(**attrs)
         return self._table_formats.lookup_key(table_id, format)
 
+    def add_custom_decimal_format_archive(self, format: CustomFormatting) -> None:
+        """Create a custom format from the format spec"""
+        integer_format = format.integer_format
+        decimal_format = format.decimal_format
+        num_integers = format.num_integers
+        num_decimals = format.num_decimals
+        show_thousands_separator = format.show_thousands_separator
+
+        if num_integers == 0:
+            format_string = ""
+        elif integer_format == PaddingType.NONE:
+            format_string = "#" * num_integers
+        else:
+            format_string = "0" * num_integers
+        if num_integers > 6:
+            format_string = re.sub(r"(...)(...)$", r",\1,\2", format_string)
+        elif num_integers > 3:
+            format_string = re.sub(r"(...)$", r",\1", format_string)
+        if num_decimals > 0:
+            if decimal_format == PaddingType.NONE:
+                format_string += "." + "#" * num_decimals
+            else:
+                format_string += "." + "0" * num_decimals
+
+        min_integer_width = (
+            num_integers if num_integers > 0 and integer_format != PaddingType.NONE else 0
+        )
+        num_nonspace_decimal_digits = num_decimals if decimal_format == PaddingType.ZEROS else 0
+        num_nonspace_integer_digits = num_integers if integer_format == PaddingType.ZEROS else 0
+        index_from_right_last_integer = num_decimals + 1 if num_integers > 0 else num_decimals
+        # Empirically correct:
+        if index_from_right_last_integer == 1:
+            index_from_right_last_integer = 0
+        elif index_from_right_last_integer == 0:
+            index_from_right_last_integer = 1
+        decimal_width = num_decimals if decimal_format == PaddingType.SPACES else 0
+        is_complex = "0" in format_string and (
+            min_integer_width > 0 or num_nonspace_decimal_digits == 0
+        )
+
+        format_archive = TSKArchives.CustomFormatArchive(
+            name=format.name,
+            format_type_pre_bnc=FormatType.CUSTOM_NUMBER,
+            format_type=FormatType.CUSTOM_NUMBER,
+            default_format=TSKArchives.FormatStructArchive(
+                contains_integer_token=num_integers > 0,
+                custom_format_string=format_string,
+                decimal_width=decimal_width,
+                format_type=FormatType.CUSTOM_NUMBER,
+                fraction_accuracy=0xFFFFFFFD,
+                index_from_right_last_integer=index_from_right_last_integer,
+                is_complex=is_complex,
+                min_integer_width=min_integer_width,
+                num_hash_decimal_digits=0,
+                num_nonspace_decimal_digits=num_nonspace_decimal_digits,
+                num_nonspace_integer_digits=num_nonspace_integer_digits,
+                requires_fraction_replacement=False,
+                scale_factor=1.0,
+                show_thousands_separator=show_thousands_separator and num_integers > 0,
+                total_num_decimal_digits=decimal_width,
+                use_accounting_style=False,
+            ),
+        )
+        self.add_custom_format_archive(format, format_archive)
+
+    def add_custom_datetime_format_archive(self, format: CustomFormatting) -> None:
+        format_archive = TSKArchives.CustomFormatArchive(
+            name=format.name,
+            format_type_pre_bnc=FormatType.CUSTOM_DATE,
+            format_type=FormatType.CUSTOM_DATE,
+            default_format=TSKArchives.FormatStructArchive(
+                custom_format_string=format.format,
+                format_type=FormatType.CUSTOM_DATE,
+            ),
+        )
+        self.add_custom_format_archive(format, format_archive)
+
+    def add_custom_format_archive(self, format: CustomFormatting, format_archive: object) -> None:
+        format_uuid = NumbersUUID().protobuf2
+        self._custom_formats[format.name] = format
+        self._custom_format_archives[format.name] = format_archive
+        self._custom_format_uuids[format.name] = format_uuid
+
+        custom_format_list_id = self.objects[DOCUMENT_ID].super.custom_format_list.identifier
+        custom_format_list = self.objects[custom_format_list_id]
+        custom_format_list.custom_formats.append(format_archive)
+        custom_format_list.uuids.append(format_uuid)
+
+    def custom_format_id(self, table_id: int, format: CustomFormatting) -> int:
+        """Look up the custom format and return the format ID for the table"""
+        format_type = CUSTOM_FORMAT_TYPE_MAP[format.type]
+        format_uuid = self._custom_format_uuids[format.name]
+        custom_format = TSKArchives.FormatStructArchive(
+            format_type=format_type,
+            custom_uid=TSPMessages.UUID(lower=format_uuid.lower, upper=format_uuid.upper),
+        )
+        return self._table_formats.lookup_key(table_id, custom_format)
+
+    def add_custom_text_format_archive(self, format: CustomFormatting) -> None:
+        format_string = format.format.replace("%s", CUSTOM_TEXT_PLACEHOLDER)
+        format_archive = TSKArchives.CustomFormatArchive(
+            name=format.name,
+            format_type_pre_bnc=FormatType.CUSTOM_TEXT,
+            format_type=FormatType.CUSTOM_TEXT,
+            default_format=TSKArchives.FormatStructArchive(
+                custom_format_string=format_string,
+                format_type=FormatType.CUSTOM_TEXT,
+            ),
+        )
+        self.add_custom_format_archive(format, format_archive)
+
     @cache(num_args=2)
     def table_style(self, table_id: int, key: int) -> str:
         """Return the style associated with a style ID for a particular table."""
@@ -481,10 +609,10 @@ class _NumbersModel(Cacheable):
                     col_start = rect.origin.column
                     col_end = col_start + rect.size.num_columns - 1
                     size = (row_end - row_start + 1, col_end - col_start + 1)
-                    for row_num in range(row_start, row_end + 1):
-                        for col_num in range(col_start, col_end + 1):
+                    for row in range(row_start, row_end + 1):
+                        for col in range(col_start, col_end + 1):
                             self._merge_cells[table_id].add_reference(
-                                row_num, col_num, (row_start, col_start, row_end, col_end)
+                                row, col, (row_start, col_start, row_end, col_end)
                             )
                     self._merge_cells[table_id].add_anchor(row_start, col_start, size)
 
@@ -504,10 +632,10 @@ class _NumbersModel(Cacheable):
             )
             row_end = row_start + num_rows - 1
             col_end = col_start + num_columns - 1
-            for row_num in range(row_start, row_end + 1):
-                for col_num in range(col_start, col_end + 1):
+            for row in range(row_start, row_end + 1):
+                for col in range(col_start, col_end + 1):
                     self._merge_cells[table_id].add_reference(
-                        row_num, col_num, (row_start, col_start, row_end, col_end)
+                        row, col, (row_start, col_start, row_end, col_end)
                     )
             self._merge_cells[table_id].add_anchor(row_start, col_start, (num_rows, num_columns))
 
@@ -527,7 +655,7 @@ class _NumbersModel(Cacheable):
                 if table_uuid == self.table_base_id(table_id):
                     return table_id
 
-    def node_to_ref(self, this_table_id: int, row_num: int, col_num: int, node):
+    def node_to_ref(self, this_table_id: int, row: int, col: int, node):
         if node.HasField("AST_cross_table_reference_extra_info"):
             table_uuid = NumbersUUID(node.AST_cross_table_reference_extra_info.table_id).hex
             other_table_id = self.table_uuids_to_id(table_uuid)
@@ -544,36 +672,34 @@ class _NumbersModel(Cacheable):
                 other_table_name = f"{other_sheet_name}::" + other_table_name
 
         if node.HasField("AST_colon_tract"):
-            return self.tract_to_row_col_ref(node, other_table_name, row_num, col_num)
+            return self.tract_to_row_col_ref(node, other_table_name, row, col)
         elif node.HasField("AST_row") and not node.HasField("AST_column"):
-            return node_to_row_ref(node, other_table_name, row_num)
+            return node_to_row_ref(node, other_table_name, row)
         elif node.HasField("AST_column") and not node.HasField("AST_row"):
-            return node_to_col_ref(node, other_table_name, col_num)
+            return node_to_col_ref(node, other_table_name, col)
         else:
-            return node_to_row_col_ref(node, other_table_name, row_num, col_num)
+            return node_to_row_col_ref(node, other_table_name, row, col)
 
-    def tract_to_row_col_ref(
-        self, node: object, table_name: str, row_num: int, col_num: int
-    ) -> str:
+    def tract_to_row_col_ref(self, node: object, table_name: str, row: int, col: int) -> str:
         if node.AST_sticky_bits.begin_row_is_absolute:
             row_begin = node.AST_colon_tract.absolute_row[0].range_begin
         else:
-            row_begin = row_num + node.AST_colon_tract.relative_row[0].range_begin
+            row_begin = row + node.AST_colon_tract.relative_row[0].range_begin
 
         if node.AST_sticky_bits.end_row_is_absolute:
             row_end = range_end(node.AST_colon_tract.absolute_row[0])
         else:
-            row_end = row_num + range_end(node.AST_colon_tract.relative_row[0])
+            row_end = row + range_end(node.AST_colon_tract.relative_row[0])
 
         if node.AST_sticky_bits.begin_column_is_absolute:
             col_begin = node.AST_colon_tract.absolute_column[0].range_begin
         else:
-            col_begin = col_num + node.AST_colon_tract.relative_column[0].range_begin
+            col_begin = col + node.AST_colon_tract.relative_column[0].range_begin
 
         if node.AST_sticky_bits.end_column_is_absolute:
             col_end = range_end(node.AST_colon_tract.absolute_column[0])
         else:
-            col_end = col_num + range_end(node.AST_colon_tract.relative_column[0])
+            col_end = col + range_end(node.AST_colon_tract.relative_column[0])
 
         begin_ref = xl_rowcol_to_cell(
             row_begin,
@@ -619,29 +745,29 @@ class _NumbersModel(Cacheable):
         return buffers
 
     @cache(num_args=3)
-    def storage_buffer(self, table_id: int, row_num: int, col_num: int) -> bytes:
-        row_offset = self.row_storage_map(table_id)[row_num]
+    def storage_buffer(self, table_id: int, row: int, col: int) -> bytes:
+        row_offset = self.row_storage_map(table_id)[row]
         if row_offset is None:
             return None
         storage_buffers = self.storage_buffers(table_id)
         if row_offset >= len(storage_buffers):
             return None
-        if col_num >= len(storage_buffers[row_offset]):
+        if col >= len(storage_buffers[row_offset]):
             return None
-        return storage_buffers[row_offset][col_num]
+        return storage_buffers[row_offset][col]
 
     def recalculate_row_headers(self, table_id: int, data: List):
         base_data_store = self.objects[table_id].base_data_store
         buckets = self.objects[base_data_store.rowHeaders.buckets[0].identifier]
         clear_field_container(buckets.headers)
-        for row_num in range(len(data)):
-            if table_id in self._row_heights and row_num in self._row_heights[table_id]:
-                height = self._row_heights[table_id][row_num]
+        for row in range(len(data)):
+            if table_id in self._row_heights and row in self._row_heights[table_id]:
+                height = self._row_heights[table_id][row]
             else:
                 height = 0.0
             header = TSTArchives.HeaderStorageBucket.Header(
-                index=row_num,
-                numberOfCells=len(data[row_num]),
+                index=row,
+                numberOfCells=len(data[row]),
                 size=height,
                 hidingState=0,
             )
@@ -649,8 +775,8 @@ class _NumbersModel(Cacheable):
 
     def recalculate_column_headers(self, table_id: int, data: List):
         current_column_widths = {}
-        for col_num in range(self.number_of_columns(table_id)):
-            current_column_widths[col_num] = self.col_width(table_id, col_num)
+        for col in range(self.number_of_columns(table_id)):
+            current_column_widths[col] = self.col_width(table_id, col)
 
         base_data_store = self.objects[table_id].base_data_store
         buckets = self.objects[base_data_store.columnHeaders.identifier]
@@ -658,14 +784,14 @@ class _NumbersModel(Cacheable):
         # Transpose data to get columns
         col_data = [list(x) for x in zip(*data)]
 
-        for col_num, col in enumerate(col_data):
-            num_rows = len(col) - sum([isinstance(x, MergedCell) for x in col])
-            if table_id in self._col_widths and col_num in self._col_widths[table_id]:
-                width = self._col_widths[table_id][col_num]
+        for col, cells in enumerate(col_data):
+            num_rows = len(cells) - sum([isinstance(x, MergedCell) for x in cells])
+            if table_id in self._col_widths and col in self._col_widths[table_id]:
+                width = self._col_widths[table_id][col]
             else:
-                width = current_column_widths[col_num]
+                width = current_column_widths[col]
             header = TSTArchives.HeaderStorageBucket.Header(
-                index=col_num, numberOfCells=num_rows, size=width, hidingState=0
+                index=col, numberOfCells=num_rows, size=width, hidingState=0
             )
             buckets.headers.append(header)
 
@@ -690,23 +816,23 @@ class _NumbersModel(Cacheable):
         base_data_store.merge_region_map.CopyFrom(TSPMessages.Reference(identifier=merge_map_id))
 
     def recalculate_row_info(
-        self, table_id: int, data: List, tile_row_offset: int, row_num: int
+        self, table_id: int, data: List, tile_row_offset: int, row: int
     ) -> TSTArchives.TileRowInfo:
         row_info = TSTArchives.TileRowInfo()
         row_info.storage_version = 5
-        row_info.tile_row_index = row_num - tile_row_offset
+        row_info.tile_row_index = row - tile_row_offset
         row_info.cell_count = 0
         cell_storage = b""
 
         offsets = [-1] * len(data[0])
         current_offset = 0
 
-        for col_num in range(len(data[row_num])):
-            buffer = self.pack_cell_storage(table_id, data, row_num, col_num)
+        for col in range(len(data[row])):
+            buffer = self.pack_cell_storage(table_id, data, row, col)
             if buffer is not None:
                 cell_storage += buffer
                 # Always use wide offsets
-                offsets[col_num] = current_offset >> 2
+                offsets[col] = current_offset >> 2
                 current_offset += len(buffer)
 
                 row_info.cell_count += 1
@@ -808,8 +934,8 @@ class _NumbersModel(Cacheable):
             tile_id, tile = self.objects.create_object_from_dict(
                 "Index/Tables/Tile-{}", tile_dict, TSTArchives.Tile
             )
-            for row_num in range(row_start, row_end):
-                row_info = self.recalculate_row_info(table_id, data, row_start, row_num)
+            for row in range(row_start, row_end):
+                row_info = self.recalculate_row_info(table_id, data, row_start, row)
                 tile.rowInfos.append(row_info)
 
             tile_ref = TSTArchives.TileStorage.Tile()
@@ -849,23 +975,23 @@ class _NumbersModel(Cacheable):
                 height += table_model.default_row_height
         return round(height)
 
-    def row_height(self, table_id: int, row_num: int, height: int = None) -> int:
+    def row_height(self, table_id: int, row: int, height: int = None) -> int:
         if height is not None:
             if table_id not in self._row_heights:
                 self._row_heights[table_id] = {}
-            self._row_heights[table_id][row_num] = height
+            self._row_heights[table_id][row] = height
             return height
 
-        if table_id in self._row_heights and row_num in self._row_heights[table_id]:
-            return self._row_heights[table_id][row_num]
+        if table_id in self._row_heights and row in self._row_heights[table_id]:
+            return self._row_heights[table_id][row]
 
         table_model = self.objects[table_id]
         bds = self.objects[table_id].base_data_store
         bucket_id = bds.rowHeaders.buckets[0].identifier
         buckets = self.objects[bucket_id].headers
         bucket_map = {x.index: x for x in buckets}
-        if row_num in bucket_map and bucket_map[row_num].size != 0.0:
-            return round(bucket_map[row_num].size)
+        if row in bucket_map and bucket_map[row].size != 0.0:
+            return round(bucket_map[row].size)
         else:
             return round(table_model.default_row_height)
 
@@ -885,23 +1011,23 @@ class _NumbersModel(Cacheable):
                 width += table_model.default_column_width
         return round(width)
 
-    def col_width(self, table_id: int, col_num: int, width: int = None) -> int:
+    def col_width(self, table_id: int, col: int, width: int = None) -> int:
         if width is not None:
             if table_id not in self._col_widths:
                 self._col_widths[table_id] = {}
-            self._col_widths[table_id][col_num] = width
+            self._col_widths[table_id][col] = width
             return width
 
-        if table_id in self._col_widths and col_num in self._col_widths[table_id]:
-            return self._col_widths[table_id][col_num]
+        if table_id in self._col_widths and col in self._col_widths[table_id]:
+            return self._col_widths[table_id][col]
 
         table_model = self.objects[table_id]
         bds = self.objects[table_id].base_data_store
         bucket_id = bds.columnHeaders.identifier
         buckets = self.objects[bucket_id].headers
         bucket_map = {x.index: x for x in buckets}
-        if col_num in bucket_map and bucket_map[col_num].size != 0.0:
-            return round(bucket_map[col_num].size)
+        if col in bucket_map and bucket_map[col].size != 0.0:
+            return round(bucket_map[col].size)
         else:
             return round(table_model.default_column_width)
 
@@ -926,6 +1052,11 @@ class _NumbersModel(Cacheable):
             table_info.super.geometry.position.y,
         )
 
+    def is_a_pivot_table(self, table_id: int) -> bool:
+        """Table is a pivot table."""
+        table_info = self.objects[self.table_info_id(table_id)]
+        return table_info.is_a_pivot_table
+
     def last_table_offset(self, sheet_id):
         """Y offset of the last table in a sheet."""
         table_id = self.table_ids(sheet_id)[-1]
@@ -1046,10 +1177,7 @@ class _NumbersModel(Cacheable):
             )
         )
 
-        data = [
-            [EmptyCell(row_num, col_num) for col_num in range(num_cols)]
-            for row_num in range(num_rows)
-        ]
+        data = [[EmptyCell(row, col) for col in range(num_cols)] for row in range(num_rows)]
 
         row_headers_id, _ = self.objects.create_object_from_dict(
             "Index/Tables/HeaderStorageBucket-{}",
@@ -1184,7 +1312,7 @@ class _NumbersModel(Cacheable):
         return self._styles
 
     @cache(num_args=0)
-    def available_paragraph_styles(self) -> List[Style]:
+    def available_paragraph_styles(self) -> Dict[str, Style]:
         theme_id = self.objects[DOCUMENT_ID].theme.identifier
         presets = find_extension(self.objects[theme_id].super, "paragraph_style_presets")
         presets_map = {
@@ -1337,8 +1465,8 @@ class _NumbersModel(Cacheable):
         have changes that require a cell style.
         """
         cell_styles = {}
-        for _, row in enumerate(data):
-            for _, cell in enumerate(row):
+        for _, cells in enumerate(data):
+            for _, cell in enumerate(cells):
                 if cell._style is not None and cell._style._update_cell_style:
                     fingerprint = (
                         str(cell.style.alignment.vertical)
@@ -1422,7 +1550,7 @@ class _NumbersModel(Cacheable):
         entry = self._table_styles.lookup_value(cell_storage.table_id, cell_storage.cell_style_id)
         return entry.reference.identifier
 
-    def custom_style_name(self) -> Tuple[str, str]:
+    def custom_style_name(self) -> str:
         """Find custom styles in the current document and return the next
         highest numbered style.
         """
@@ -1442,11 +1570,44 @@ class _NumbersModel(Cacheable):
         else:
             return "Custom Style 1"
 
+    @property
+    def custom_formats(self) -> Dict[str, CustomFormatting]:
+        if self._custom_formats is None:
+            custom_format_list_id = self.objects[DOCUMENT_ID].super.custom_format_list.identifier
+            custom_formats = self.objects[custom_format_list_id].custom_formats
+            custom_format_names = [x.name for x in custom_formats]
+            custom_format_uuids = [x for x in self.objects[custom_format_list_id].uuids]
+            self._custom_formats = {}
+            self._custom_format_archives = {}
+            self._custom_format_uuids = {}
+            for i, format_name in enumerate(custom_format_names):
+                self._custom_formats[format_name] = CustomFormatting.from_archive(custom_formats[i])
+                self._custom_format_archives[format_name] = custom_formats[i]
+                self._custom_format_uuids[format_name] = custom_format_uuids[i]
+
+        return self._custom_formats
+
+    def custom_format_name(self) -> str:
+        """Find custom formats in the current document and return the next
+        highest numbered format.
+        """
+        current_formats = self.custom_formats.keys()
+        if "Custom Format" not in current_formats:
+            return "Custom Format"
+        current_formats = [
+            m.group(1) for x in current_formats if (m := re.fullmatch(r"Custom Format (\d+)", x))
+        ]
+        if len(current_formats) > 0:
+            last_id = int(current_formats[-1])
+            return f"Custom Format {last_id + 1}"
+        else:
+            return "Custom Format 1"
+
     def pack_cell_storage(  # noqa: PLR0912, PLR0915
-        self, table_id: int, data: List, row_num: int, col_num: int
+        self, table_id: int, data: List, row: int, col: int
     ) -> bytearray:
         """Create a storage buffer for a cell using v5 (modern) layout."""
-        cell = data[row_num][col_num]
+        cell = data[row][col]
         if cell._style is not None:
             if cell._style._text_style_obj_id is not None:
                 cell._storage.text_style_id = self._table_styles.lookup_key(
@@ -1516,7 +1677,7 @@ class _NumbersModel(Cacheable):
             data_type = type(cell).__name__
             table_name = self.table_name(table_id)
             warn(
-                f"@{table_name}:[{row_num},{col_num}]: unsupported data type {data_type} for save",
+                f"@{table_name}:[{row},{col}]: unsupported data type {data_type} for save",
                 UnsupportedWarning,
                 stacklevel=1,
             )
@@ -1551,20 +1712,23 @@ class _NumbersModel(Cacheable):
             flags |= 0x2000
             length += 4
             storage += pack("<i", cell._storage.num_format_id)
-            storage[4:6] = pack("<h", 2)
-            storage[6:8] = pack("<h", 1)
+            storage[6] |= 1
+            # storage[6:8] = pack("<h", 1)
         if cell._storage.currency_format_id is not None:
             flags |= 0x4000
             length += 4
             storage += pack("<i", cell._storage.currency_format_id)
+            storage[6] |= 2
         if cell._storage.date_format_id is not None:
             flags |= 0x8000
             length += 4
             storage += pack("<i", cell._storage.date_format_id)
+            storage[6] |= 8
         if cell._storage.duration_format_id is not None:
             flags |= 0x10000
             length += 4
             storage += pack("<i", cell._storage.duration_format_id)
+            storage[6] |= 4
         if cell._storage.text_format_id is not None:
             flags |= 0x20000
             length += 4
@@ -1573,6 +1737,9 @@ class _NumbersModel(Cacheable):
             flags |= 0x40000
             length += 4
             storage += pack("<i", cell._storage.bool_format_id)
+            storage[6] |= 0x20
+        if cell._storage.string_id is not None:
+            storage[6] |= 0x80
 
         storage[8:12] = pack("<i", flags)
         if len(storage) < 32:
@@ -1585,12 +1752,12 @@ class _NumbersModel(Cacheable):
         return TableFormulas(self, table_id)
 
     @cache(num_args=3)
-    def table_cell_decode(self, table_id: int, row_num: int, col_num: int) -> Dict:
-        buffer = self.storage_buffer(table_id, row_num, col_num)
+    def table_cell_decode(self, table_id: int, row: int, col: int) -> Dict:
+        buffer = self.storage_buffer(table_id, row, col)
         if buffer is None:
             return None
 
-        return CellStorage(self, table_id, buffer, row_num, col_num)
+        return CellStorage(self, table_id, buffer, row, col)
 
     @cache(num_args=2)
     def table_rich_text(self, table_id: int, string_key: int) -> Dict:
@@ -1691,14 +1858,14 @@ class _NumbersModel(Cacheable):
             return self.table_style(cell_storage.table_id, cell_storage.text_style_id)
 
         table_model = self.objects[cell_storage.table_id]
-        if cell_storage.row_num in range(table_model.number_of_header_rows):
+        if cell_storage.row in range(table_model.number_of_header_rows):
             return self.objects[table_model.header_row_text_style.identifier]
-        elif cell_storage.col_num in range(table_model.number_of_header_columns):
+        elif cell_storage.col in range(table_model.number_of_header_columns):
             return self.objects[table_model.header_column_text_style.identifier]
         elif table_model.number_of_footer_rows > 0:
             start_row_num = table_model.number_of_rows - table_model.number_of_footer_rows
             end_row_num = start_row_num + table_model.number_of_footer_rows
-            if cell_storage.row_num in range(start_row_num, end_row_num):
+            if cell_storage.row in range(start_row_num, end_row_num):
                 return self.objects[table_model.footer_row_text_style.identifier]
         return self.objects[table_model.body_text_style.identifier]
 
@@ -1831,19 +1998,19 @@ class _NumbersModel(Cacheable):
         else:
             return "none"
 
-    def cell_for_stroke(self, table_id: int, side: str, row_num: int, col_num: int) -> object:
+    def cell_for_stroke(self, table_id: int, side: str, row: int, col: int) -> object:
         data = self._table_data[table_id]
-        if row_num < 0 or col_num < 0:
+        if row < 0 or col < 0:
             return None
-        if row_num >= len(data) or col_num >= len(data[row_num]):
+        if row >= len(data) or col >= len(data[row]):
             return None
-        cell = self._table_data[table_id][row_num][col_num]
+        cell = self._table_data[table_id][row][col]
         if isinstance(cell, MergedCell):
             if (
-                (side == "top" and row_num == cell.row_start)
-                or (side == "right" and col_num == cell.col_end)
-                or (side == "bottom" and row_num == cell.row_end)
-                or (side == "left" and col_num == cell.col_start)
+                (side == "top" and row == cell.row_start)
+                or (side == "right" and col == cell.col_end)
+                or (side == "bottom" and row == cell.row_end)
+                or (side == "left" and col == cell.col_start)
             ):
                 return cell
         elif cell.is_merged:
@@ -1854,28 +2021,28 @@ class _NumbersModel(Cacheable):
         return None
 
     def set_cell_border(  # noqa: PLR0913
-        self, table_id: int, row_num: int, col_num: int, side: str, border_value: Border
+        self, table_id: int, row: int, col: int, side: str, border_value: Border
     ):
         """Set the 2 borders adjacent to a stroke if within the table range."""
         if side == "top":
-            if (cell := self.cell_for_stroke(table_id, "top", row_num, col_num)) is not None:
+            if (cell := self.cell_for_stroke(table_id, "top", row, col)) is not None:
                 cell._border.top = border_value
-            if (cell := self.cell_for_stroke(table_id, "bottom", row_num - 1, col_num)) is not None:
+            if (cell := self.cell_for_stroke(table_id, "bottom", row - 1, col)) is not None:
                 cell._border.bottom = border_value
         elif side == "right":
-            if (cell := self.cell_for_stroke(table_id, "right", row_num, col_num)) is not None:
+            if (cell := self.cell_for_stroke(table_id, "right", row, col)) is not None:
                 cell._border.right = border_value
-            if (cell := self.cell_for_stroke(table_id, "left", row_num, col_num + 1)) is not None:
+            if (cell := self.cell_for_stroke(table_id, "left", row, col + 1)) is not None:
                 cell._border.left = border_value
         elif side == "bottom":
-            if (cell := self.cell_for_stroke(table_id, "bottom", row_num, col_num)) is not None:
+            if (cell := self.cell_for_stroke(table_id, "bottom", row, col)) is not None:
                 cell._border.bottom = border_value
-            if (cell := self.cell_for_stroke(table_id, "top", row_num + 1, col_num)) is not None:
+            if (cell := self.cell_for_stroke(table_id, "top", row + 1, col)) is not None:
                 cell._border.top = border_value
         else:  # left border
-            if (cell := self.cell_for_stroke(table_id, "left", row_num, col_num)) is not None:
+            if (cell := self.cell_for_stroke(table_id, "left", row, col)) is not None:
                 cell._border.left = border_value
-            if (cell := self.cell_for_stroke(table_id, "right", row_num, col_num - 1)) is not None:
+            if (cell := self.cell_for_stroke(table_id, "right", row, col - 1)) is not None:
                 cell._border.right = border_value
 
     def extract_strokes_in_layers(self, table_id: int, layer_ids: List, side: str):
@@ -1891,13 +2058,13 @@ class _NumbersModel(Cacheable):
                 if side in ["top", "bottom"]:
                     start_row = stroke_layer.row_column_index
                     start_column = stroke_run.origin
-                    for col_num in range(start_column, start_column + stroke_run.length):
-                        self.set_cell_border(table_id, start_row, col_num, side, border_value)
+                    for col in range(start_column, start_column + stroke_run.length):
+                        self.set_cell_border(table_id, start_row, col, side, border_value)
                 else:
                     start_row = stroke_run.origin
                     start_column = stroke_layer.row_column_index
-                    for row_num in range(start_row, start_row + stroke_run.length):
-                        self.set_cell_border(table_id, row_num, start_column, side, border_value)
+                    for row in range(start_row, start_row + stroke_run.length):
+                        self.set_cell_border(table_id, row, start_column, side, border_value)
 
     @cache()
     def extract_strokes(self, table_id: int):
@@ -1968,8 +2135,8 @@ class _NumbersModel(Cacheable):
     def add_stroke(  # noqa: PLR0913
         self,
         table_id: int,
-        row_num: int,
-        col_num: int,
+        row: int,
+        col: int,
         side: str,
         border_value: Border,
         length: int,
@@ -1983,20 +2150,20 @@ class _NumbersModel(Cacheable):
 
         if side == "top":
             layer_ids = sidecar_obj.top_row_stroke_layers
-            row_column_index = row_num
-            origin = col_num
+            row_column_index = row
+            origin = col
         elif side == "right":
             layer_ids = sidecar_obj.right_column_stroke_layers
-            row_column_index = col_num
-            origin = row_num
+            row_column_index = col
+            origin = row
         elif side == "bottom":
             layer_ids = sidecar_obj.bottom_row_stroke_layers
-            row_column_index = row_num
-            origin = col_num
+            row_column_index = row
+            origin = col
         else:  # left border
             layer_ids = sidecar_obj.left_column_stroke_layers
-            row_column_index = col_num
-            origin = row_num
+            row_column_index = col
+            origin = row
 
         stroke_layer = None
         for layer_id in layer_ids:
@@ -2065,8 +2232,8 @@ def formatted_number(number_type, index):
     return bullet_char
 
 
-def node_to_col_ref(node: object, table_name: str, col_num: int) -> str:
-    col = node.AST_column.column if node.AST_column.absolute else col_num + node.AST_column.column
+def node_to_col_ref(node: object, table_name: str, col: int) -> str:
+    col = node.AST_column.column if node.AST_column.absolute else col + node.AST_column.column
 
     col_name = xl_col_to_name(col, node.AST_column.absolute)
     if table_name is not None:
@@ -2075,8 +2242,8 @@ def node_to_col_ref(node: object, table_name: str, col_num: int) -> str:
         return col_name
 
 
-def node_to_row_ref(node: object, table_name: str, row_num: int) -> str:
-    row = node.AST_row.row if node.AST_row.absolute else row_num + node.AST_row.row
+def node_to_row_ref(node: object, table_name: str, row: int) -> str:
+    row = node.AST_row.row if node.AST_row.absolute else row + node.AST_row.row
 
     row_name = f"${row+1}" if node.AST_row.absolute else f"{row+1}"
     if table_name is not None:
@@ -2085,9 +2252,9 @@ def node_to_row_ref(node: object, table_name: str, row_num: int) -> str:
         return f"{row_name}:{row_name}"
 
 
-def node_to_row_col_ref(node: object, table_name: str, row_num: int, col_num: int) -> str:
-    row = node.AST_row.row if node.AST_row.absolute else row_num + node.AST_row.row
-    col = node.AST_column.column if node.AST_column.absolute else col_num + node.AST_column.column
+def node_to_row_col_ref(node: object, table_name: str, row: int, col: int) -> str:
+    row = node.AST_row.row if node.AST_row.absolute else row + node.AST_row.row
+    col = node.AST_column.column if node.AST_column.absolute else col + node.AST_column.column
 
     ref = xl_rowcol_to_cell(
         row,
@@ -2120,23 +2287,23 @@ def get_storage_buffers_for_row(
         offsets = [o * 4 for o in offsets]
 
     data = []
-    for col_num in range(num_cols):
-        if col_num >= len(offsets):
+    for col in range(num_cols):
+        if col >= len(offsets):
             break
 
-        start = offsets[col_num]
+        start = offsets[col]
         if start < 0:
             data.append(None)
             continue
 
-        if col_num == (len(offsets) - 1):
+        if col == (len(offsets) - 1):
             end = len(storage_buffer)
         else:
             end = None
             # Find next positive offset
-            for i, x in enumerate(offsets[col_num + 1 :]):
+            for i, x in enumerate(offsets[col + 1 :]):
                 if x >= 0:
-                    end = offsets[col_num + i + 1]
+                    end = offsets[col + i + 1]
                     break
             if end is None:
                 end = len(storage_buffer)