numbers-parser 4.14.1__py3-none-any.whl → 4.14.3__py3-none-any.whl

numbers_parser/model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 from array import array
 from collections import defaultdict
@@ -5,7 +7,6 @@ from hashlib import sha1
 from math import floor
 from pathlib import Path
 from struct import pack
-from typing import Dict, List, Optional, Tuple, Union
 
 from numbers_parser.bullets import (
     BULLET_CONVERSION,
@@ -91,27 +92,27 @@ class MergeCells:
     def __init__(self) -> None:
         self._references = defaultdict(lambda: False)
 
-    def add_reference(self, row: int, col: int, rect: Tuple):
+    def add_reference(self, row: int, col: int, rect: tuple) -> None:
         self._references[(row, col)] = MergeReference(*rect)
 
-    def add_anchor(self, row: int, col: int, size: Tuple):
+    def add_anchor(self, row: int, col: int, size: tuple) -> None:
         self._references[(row, col)] = MergeAnchor(size)
 
-    def is_merge_reference(self, row_col: Tuple) -> bool:
+    def is_merge_reference(self, row_col: tuple) -> bool:
         # defaultdict will default this to False for missing entries
         return isinstance(self._references[row_col], MergeReference)
 
-    def is_merge_anchor(self, row_col: Tuple) -> bool:
+    def is_merge_anchor(self, row_col: tuple) -> bool:
         # defaultdict will default this to False for missing entries
         return isinstance(self._references[row_col], MergeAnchor)
 
-    def get(self, row_col: Tuple) -> Union[MergeAnchor, MergeReference]:
+    def get(self, row_col: tuple) -> MergeAnchor | MergeReference:
         return self._references[row_col]
 
-    def size(self, row_col: Tuple) -> Tuple:
+    def size(self, row_col: tuple) -> tuple:
         return self._references[row_col].size
 
-    def rect(self, row_col: Tuple) -> Tuple:
+    def rect(self, row_col: tuple) -> tuple:
         return self._references[row_col].rect
 
     def merge_cells(self):
@@ -121,14 +122,14 @@ class MergeCells:
 class DataLists(Cacheable):
     """Model for TST.DataList with caching and key generation for new values."""
 
-    def __init__(self, model: object, datalist_name: str, value_attr: Optional[str] = None) -> None:
+    def __init__(self, model: object, datalist_name: str, value_attr: str | None = None) -> None:
         self._model = model
         self._datalists = {}
         self._value_attr = value_attr
         self._datalist_name = datalist_name
 
     @cache()
-    def add_table(self, table_id: int):
+    def add_table(self, table_id: int) -> None:
         """Cache a new datalist for a table if not already seen."""
         base_data_store = self._model.objects[table_id].base_data_store
         datalist_id = getattr(base_data_store, self._datalist_name).identifier
@@ -162,10 +163,9 @@ class DataLists(Cacheable):
     def value_key(self, value):
         if hasattr(value, "DESCRIPTOR"):
             return repr(value)
-        else:
-            return value
+        return value
 
-    def init(self, table_id: int):
+    def init(self, table_id: int) -> None:
         """Remove all entries from a datalist."""
         self.add_table(table_id)
         self._datalists[table_id]["by_key"] = {}
@@ -176,7 +176,8 @@ class DataLists(Cacheable):
         clear_field_container(self._datalists[table_id]["datalist"].entries)
 
     def lookup_key(self, table_id: int, value) -> int:
-        """Return the key associated with a value for a particular table entry.
+        """
+        Return the key associated with a value for a particular table entry.
         If the value is not in the datalist, allocate a new entry with the
         next available key.
         """
@@ -204,7 +205,8 @@ class DataLists(Cacheable):
 
 
 class _NumbersModel(Cacheable):
-    """Loads all objects from Numbers document and provides decoding
+    """
+    Loads all objects from Numbers document and provides decoding
     methods for other classes in the module to abstract away the
     internal structures of Numbers document data structures.
 
@@ -248,13 +250,11 @@ class _NumbersModel(Cacheable):
         if value is None:
             if sheet_id not in self.objects:
                 return None
-            else:
-                return self.objects[sheet_id].name
-        else:
-            self.objects[sheet_id].name = value
-            return None
+            return self.objects[sheet_id].name
+        self.objects[sheet_id].name = value
+        return None
 
-    def set_table_data(self, table_id: int, data: List):
+    def set_table_data(self, table_id: int, data: list) -> None:
         self._table_data[table_id] = data
 
     # Don't cache: new tables can be added at runtime
@@ -313,27 +313,25 @@ class _NumbersModel(Cacheable):
     def table_name(self, table_id, value=None):
         if value is None:
             return self.objects[table_id].table_name
-        else:
-            self.objects[table_id].table_name = value
-            return None
+        self.objects[table_id].table_name = value
+        return None
 
-    def table_name_enabled(self, table_id: int, enabled: Optional[bool] = None):
+    def table_name_enabled(self, table_id: int, enabled: bool | None = None):
         if enabled is not None:
             self.objects[table_id].table_name_enabled = enabled
             return None
-        else:
-            return self.objects[table_id].table_name_enabled
+        return self.objects[table_id].table_name_enabled
 
-    def caption_enabled(self, table_id: int, enabled: Optional[bool] = None) -> bool:
+    def caption_enabled(self, table_id: int, enabled: bool | None = None) -> bool:
         table_info = self.objects[self.table_info_id(table_id)]
         if enabled is not None:
             table_info.super.caption_hidden = not enabled
-        else:
-            caption_info_id = table_info.super.caption.identifier
-            caption_archive = self.objects[caption_info_id]
-            if caption_archive.DESCRIPTOR.name == "StandinCaptionArchive":
-                return False
-            return not table_info.super.caption_hidden
+            return None
+        caption_info_id = table_info.super.caption.identifier
+        caption_archive = self.objects[caption_info_id]
+        if caption_archive.DESCRIPTOR.name == "StandinCaptionArchive":
+            return False
+        return not table_info.super.caption_hidden
 
     def find_style_id(self, style_substr: str):
         stylesheet = self.objects[self.stylesheet_id()]
@@ -344,18 +342,18 @@ class _NumbersModel(Cacheable):
 
     def caption_paragraph_style_id(self):
         style_map = {
-            id: self.objects[id]
-            for id in self.find_refs("ParagraphStyleArchive")
-            if "Caption" in self.objects[id].super.name
+            x: self.objects[x]
+            for x in self.find_refs("ParagraphStyleArchive")
+            if "Caption" in self.objects[x].super.name
         }
-        return list(style_map.keys())[0]
+        return next(iter(style_map.keys()))
 
     @cache(num_args=0)
     def stylesheet_id(self):
         return self.find_refs("StylesheetArchive")[0]
 
-    def set_reference(self, obj: object, id: int):
-        obj.MergeFrom(TSPMessages.Reference(identifier=id))
+    def set_reference(self, obj: object, ref_id: int) -> None:
+        obj.MergeFrom(TSPMessages.Reference(identifier=ref_id))
 
     def create_path_source_archive(self, table_id):
         box_size = 100.0
@@ -389,12 +387,12 @@ class _NumbersModel(Cacheable):
                             type=TSPMessages.Path.ElementType.moveTo,
                             points=[TSPMessages.Point(x=0.0, y=0.0)],
                         ),
-                    ]
+                    ],
                 ),
             ),
         )
 
-    def create_caption_archive(self, table_id):
+    def create_caption_archive(self, table_id) -> None:
         table_info_id = self.table_info_id(table_id)
         table_info = self.objects[table_info_id]
         caption_placement_id, _ = self.objects.create_object_from_dict(
@@ -421,16 +419,16 @@ class _NumbersModel(Cacheable):
                         {
                             "character_index": 0,
                             "object": {"identifier": self.caption_paragraph_style_id()},
-                        }
-                    ]
+                        },
+                    ],
                 },
                 "table_list_style": {
                     "entries": [
                         {
                             "character_index": 0,
                             "object": {"identifier": self.find_style_id("liststyle")},
-                        }
-                    ]
+                        },
+                    ],
                 },
                 "table_para_starts": {"entries": [{"character_index": 0, "first": 0, "second": 0}]},
                 "table_para_bidi": {"entries": [{"character_index": 0, "first": 0, "second": 0}]},
@@ -445,7 +443,9 @@ class _NumbersModel(Cacheable):
             self.caption_paragraph_style_id(),
         ]:
             self.add_component_reference(
-                object_id, location="CalculationEngine", component_id=self.stylesheet_id()
+                object_id,
+                location="CalculationEngine",
+                component_id=self.stylesheet_id(),
             )
         caption_info.super.MergeFrom(
             TSWPArchives.ShapeInfoArchive(
@@ -458,18 +458,19 @@ class _NumbersModel(Cacheable):
                     strokePatternOffsetDistance=0.0,
                     pathsource=self.create_path_source_archive(table_id),
                 ),
-            )
+            ),
         )
 
         self.set_reference(table_info.super.caption, caption_info_id)
         component = self.metadata_component(self.calc_engine_id())
         component.object_uuid_map_entries.append(
             TSPArchiveMessages.ObjectUUIDMapEntry(
-                identifier=caption_info_id, uuid=NumbersUUID().protobuf2
-            )
+                identifier=caption_info_id,
+                uuid=NumbersUUID().protobuf2,
+            ),
         )
 
-    def caption_text(self, table_id: int, caption: str = None) -> str:
+    def caption_text(self, table_id: int, caption: str | None = None) -> str:
         table_info = self.objects[self.table_info_id(table_id)]
         caption_info_id = table_info.super.caption.identifier
         caption_archive = self.objects[caption_info_id]
@@ -477,19 +478,18 @@ class _NumbersModel(Cacheable):
         if caption_archive.DESCRIPTOR.name == "StandinCaptionArchive":
             if caption is None:
                 return "Caption"
-            else:
-                self.create_caption_archive(table_id)
-                caption_info_id = table_info.super.caption.identifier
-                caption_archive = self.objects[caption_info_id]
+            self.create_caption_archive(table_id)
+            caption_info_id = table_info.super.caption.identifier
+            caption_archive = self.objects[caption_info_id]
 
         caption_storage_id = caption_archive.super.owned_storage.identifier
         if caption is not None:
             clear_field_container(self.objects[caption_storage_id].text)
             self.objects[caption_storage_id].text.append(caption)
-        elif len(self.objects[caption_storage_id].text) == 0:
+            return None
+        if len(self.objects[caption_storage_id].text) == 0:
             return "Caption"
-        else:
-            return self.objects[caption_storage_id].text[0]
+        return self.objects[caption_storage_id].text[0]
 
     @cache()
     def table_tiles(self, table_id):
@@ -511,17 +511,17 @@ class _NumbersModel(Cacheable):
         return self._table_formats.lookup_value(table_id, key).format
 
     @cache(num_args=3)
-    def format_archive(self, table_id: int, format_type: FormattingType, format: Formatting):
+    def format_archive(self, table_id: int, format_type: FormattingType, formatting: 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 = {x: getattr(formatting, 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)
+        format_archive = TSKArchives.FormatStructArchive(**attrs)
+        return self._table_formats.lookup_key(table_id, format_archive)
 
-    def cell_popup_model(self, parent_id: int, format: Formatting):
+    def cell_popup_model(self, parent_id: int, formatting: Formatting):
         tsce_items = [{"cell_value_type": "NIL_TYPE"}]
-        for item in format.popup_values:
+        for item in formatting.popup_values:
             if isinstance(item, str):
                 tsce_items.append(
                     {
@@ -550,7 +550,12 @@ class _NumbersModel(Cacheable):
         )
         return popup_menu_id
 
-    def control_cell_archive(self, table_id: int, format_type: FormattingType, format: Formatting):
+    def control_cell_archive(
+        self,
+        table_id: int,
+        format_type: FormattingType,
+        formatting: Formatting,
+    ):
         """Create control cell archive from a Formatting spec and return the table format ID."""
         if format_type == FormattingType.TICKBOX:
             cell_spec = TSTArchives.CellSpecArchive(interaction_type=CellInteractionType.TOGGLE)
@@ -564,26 +569,26 @@ class _NumbersModel(Cacheable):
         elif format_type == FormattingType.SLIDER:
             cell_spec = TSTArchives.CellSpecArchive(
                 interaction_type=CellInteractionType.SLIDER,
-                range_control_min=format.minimum,
-                range_control_max=format.maximum,
-                range_control_inc=format.increment,
+                range_control_min=formatting.minimum,
+                range_control_max=formatting.maximum,
+                range_control_inc=formatting.increment,
             )
         else:  # POPUP
-            popup_id = self.cell_popup_model(self._control_specs.id(table_id), format)
+            popup_id = self.cell_popup_model(self._control_specs.id(table_id), formatting)
             cell_spec = TSTArchives.CellSpecArchive(
                 interaction_type=CellInteractionType.POPUP,
                 chooser_control_popup_model=TSPMessages.Reference(identifier=popup_id),
-                chooser_control_start_w_first=not (format.allow_none),
+                chooser_control_start_w_first=not (formatting.allow_none),
             )
         return self._control_specs.lookup_key(table_id, cell_spec)
 
-    def add_custom_decimal_format_archive(self, format: CustomFormatting) -> None:
+    def add_custom_decimal_format_archive(self, formatting: 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
+        integer_format = formatting.integer_format
+        decimal_format = formatting.decimal_format
+        num_integers = formatting.num_integers
+        num_decimals = formatting.num_decimals
+        show_thousands_separator = formatting.show_thousands_separator
 
         if num_integers == 0:
             format_string = ""
@@ -618,7 +623,7 @@ class _NumbersModel(Cacheable):
         )
 
         format_archive = TSKArchives.CustomFormatArchive(
-            name=format.name,
+            name=formatting.name,
             format_type_pre_bnc=FormatType.CUSTOM_NUMBER,
             format_type=FormatType.CUSTOM_NUMBER,
             default_format=TSKArchives.FormatStructArchive(
@@ -640,45 +645,49 @@ class _NumbersModel(Cacheable):
                 use_accounting_style=False,
             ),
         )
-        self.add_custom_format_archive(format, format_archive)
+        self.add_custom_format_archive(formatting, format_archive)
 
-    def add_custom_datetime_format_archive(self, format: CustomFormatting) -> None:
+    def add_custom_datetime_format_archive(self, formatting: CustomFormatting) -> None:
         format_archive = TSKArchives.CustomFormatArchive(
-            name=format.name,
+            name=formatting.name,
             format_type_pre_bnc=FormatType.CUSTOM_DATE,
             format_type=FormatType.CUSTOM_DATE,
             default_format=TSKArchives.FormatStructArchive(
-                custom_format_string=format.format,
+                custom_format_string=formatting.format,
                 format_type=FormatType.CUSTOM_DATE,
             ),
         )
-        self.add_custom_format_archive(format, format_archive)
+        self.add_custom_format_archive(formatting, format_archive)
 
-    def add_custom_format_archive(self, format: CustomFormatting, format_archive: object) -> None:
+    def add_custom_format_archive(
+        self,
+        formatting: 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
+        self._custom_formats[formatting.name] = formatting
+        self._custom_format_archives[formatting.name] = format_archive
+        self._custom_format_uuids[formatting.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:
+    def custom_format_id(self, table_id: int, formatting: 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]
+        format_type = CUSTOM_FORMAT_TYPE_MAP[formatting.type]
+        format_uuid = self._custom_format_uuids[formatting.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)
+    def add_custom_text_format_archive(self, formatting: CustomFormatting) -> None:
+        format_string = formatting.format.replace("%s", CUSTOM_TEXT_PLACEHOLDER)
         format_archive = TSKArchives.CustomFormatArchive(
-            name=format.name,
+            name=formatting.name,
             format_type_pre_bnc=FormatType.CUSTOM_TEXT,
             format_type=FormatType.CUSTOM_TEXT,
             default_format=TSKArchives.FormatStructArchive(
@@ -686,7 +695,7 @@ class _NumbersModel(Cacheable):
                 format_type=FormatType.CUSTOM_TEXT,
             ),
         )
-        self.add_custom_format_archive(format, format_archive)
+        self.add_custom_format_archive(formatting, format_archive)
 
     @cache(num_args=2)
     def table_style(self, table_id: int, key: int) -> str:
@@ -699,12 +708,13 @@ class _NumbersModel(Cacheable):
         """Return the string associated with a string ID for a particular table."""
         return self._table_strings.lookup_value(table_id, key).string
 
-    def init_table_strings(self, table_id: int):
+    def init_table_strings(self, table_id: int) -> None:
         """Cache table strings reference and delete all existing keys/values."""
         self._table_strings.init(table_id)
 
     def table_string_key(self, table_id: int, value: str) -> int:
-        """Return the key associated with a string for a particular table. If
+        """
+        Return the key associated with a string for a particular table. If
         the string is not in the strings table, allocate a new entry with the
         next available key.
         """
@@ -712,7 +722,8 @@ class _NumbersModel(Cacheable):
 
     @cache(num_args=0)
     def owner_id_map(self):
-        """ "
+        """
+        "
         Extracts the mapping table from Owner IDs to UUIDs. Returns a
         dictionary mapping the owner ID int to a 128-bit UUID.
         """
@@ -789,8 +800,7 @@ class _NumbersModel(Cacheable):
         ce_id = self.find_refs("CalculationEngineArchive")
         if len(ce_id) == 0:
             return 0
-        else:
-            return ce_id[0]
+        return ce_id[0]
 
     @cache(num_args=0)
     def calc_engine(self):
@@ -798,11 +808,10 @@ class _NumbersModel(Cacheable):
         ce_id = self.calc_engine_id()
         if ce_id == 0:
             return None
-        else:
-            return self.objects[ce_id]
+        return self.objects[ce_id]
 
     @cache()
-    def calculate_merge_cell_ranges(self, table_id):
+    def calculate_merge_cell_ranges(self, table_id) -> None:
         """Exract all the merge cell ranges for the Table."""
         # https://github.com/masaccio/numbers-parser/blob/main/doc/Numbers.md#merge-ranges
         owner_id_map = self.owner_id_map()
@@ -865,10 +874,11 @@ class _NumbersModel(Cacheable):
         for sheet_id in self.sheet_ids():  # pragma: no branch
             if table_id in self.table_ids(sheet_id):
                 return sheet_id
+        return None
 
     @cache()
-    def table_uuids_to_id(self, table_uuid) -> int:
-        for sheet_id in self.sheet_ids():  # pragma: no branch
+    def table_uuids_to_id(self, table_uuid) -> int | None:
+        for sheet_id in self.sheet_ids():  # pragma: no branch   # noqa: RET503
             for table_id in self.table_ids(sheet_id):
                 if table_uuid == self.table_base_id(table_id):
                     return table_id
@@ -891,12 +901,11 @@ class _NumbersModel(Cacheable):
 
         if node.HasField("AST_colon_tract"):
             return self.tract_to_row_col_ref(node, other_table_name, row, col)
-        elif node.HasField("AST_row") and not node.HasField("AST_column"):
+        if node.HasField("AST_row") and not node.HasField("AST_column"):
             return node_to_row_ref(node, other_table_name, row)
-        elif node.HasField("AST_column") and not node.HasField("AST_row"):
+        if node.HasField("AST_column") and not node.HasField("AST_row"):
             return node_to_col_ref(node, other_table_name, col)
-        else:
-            return node_to_row_col_ref(node, other_table_name, row, col)
+        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: int, col: int) -> str:
         if node.AST_sticky_bits.begin_row_is_absolute:
@@ -933,8 +942,7 @@ class _NumbersModel(Cacheable):
         )
         if table_name is not None:
             return f"{table_name}::{begin_ref}:{end_ref}"
-        else:
-            return f"{begin_ref}:{end_ref}"
+        return f"{begin_ref}:{end_ref}"
 
     @cache()
     def formula_ast(self, table_id: int):
@@ -947,7 +955,7 @@ class _NumbersModel(Cacheable):
         return formulas
 
     @cache()
-    def storage_buffers(self, table_id: int) -> List:
+    def storage_buffers(self, table_id: int) -> list:
         buffers = []
         for tile in self.table_tiles(table_id):
             if not tile.last_saved_in_BNC:
@@ -975,7 +983,7 @@ class _NumbersModel(Cacheable):
             return None
         return storage_buffers[row_offset][col]
 
-    def recalculate_row_headers(self, table_id: int, data: List):
+    def recalculate_row_headers(self, table_id: int, data: list) -> None:
         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)
@@ -992,7 +1000,7 @@ class _NumbersModel(Cacheable):
             )
             buckets.headers.append(header)
 
-    def recalculate_column_headers(self, table_id: int, data: List):
+    def recalculate_column_headers(self, table_id: int, data: list) -> None:
         current_column_widths = {}
         for col in range(self.number_of_columns(table_id)):
             current_column_widths[col] = self.col_width(table_id, col)
@@ -1014,7 +1022,7 @@ class _NumbersModel(Cacheable):
             )
             buckets.headers.append(header)
 
-    def recalculate_merged_cells(self, table_id: int):
+    def recalculate_merged_cells(self, table_id: int) -> None:
         merge_cells = self.merge_cells(table_id)
 
         merge_map_id, merge_map = self.objects.create_object_from_dict(
@@ -1037,7 +1045,7 @@ class _NumbersModel(Cacheable):
     def recalculate_row_info(
         self,
         table_id: int,
-        data: List,
+        data: list,
         tile_row_offset: int,
         row: int,
     ) -> TSTArchives.TileRowInfo:
@@ -1068,18 +1076,18 @@ class _NumbersModel(Cacheable):
         return row_info
 
     @cache()
-    def metadata_component(self, reference: Optional[Union[str, int]] = None) -> int:
+    def metadata_component(self, reference: str | int | None = None) -> int:
         """Return the ID of an object in the document metadata given it's name or ID."""
         component_map = {c.identifier: c for c in self.objects[PACKAGE_ID].components}
         if isinstance(reference, str):
             component_ids = [
-                id for id, c in component_map.items() if c.preferred_locator == reference
+                x for x, c in component_map.items() if c.preferred_locator == reference
             ]
         else:
-            component_ids = [id for id, c in component_map.items() if c.identifier == reference]
+            component_ids = [x for x, c in component_map.items() if c.identifier == reference]
         return component_map[component_ids[0]]
 
-    def add_component_metadata(self, object_id: int, parent: str, locator: str):
+    def add_component_metadata(self, object_id: int, parent: str, locator: str) -> None:
         """Add a new ComponentInfo record to the parent object in the document metadata."""
         locator = locator.format(object_id)
         preferred_locator = re.sub(r"\-\d+.*", "", locator)
@@ -1098,10 +1106,10 @@ class _NumbersModel(Cacheable):
     def add_component_reference(
         self,
         object_id: int,
-        location: Optional[str] = None,
-        component_id: Optional[int] = None,
+        location: str | None = None,
+        component_id: int | None = None,
         is_weak: bool = False,
-    ):
+    ) -> None:
         """Add an external reference to an object in a metadata component."""
         component = self.metadata_component(location or component_id)
         if component_id is not None:
@@ -1114,7 +1122,7 @@ class _NumbersModel(Cacheable):
             TSPArchiveMessages.ComponentExternalReference(**params),
         )
 
-    def recalculate_table_data(self, table_id: int, data: List):
+    def recalculate_table_data(self, table_id: int, data: list) -> None:
         table_model = self.objects[table_id]
         table_model.number_of_rows = len(data)
         table_model.number_of_columns = len(data[0])
@@ -1191,7 +1199,7 @@ class _NumbersModel(Cacheable):
             height += self.row_height(table_id, row)
         return floor(height)
 
-    def row_height(self, table_id: int, row: int, height: Optional[int] = None) -> int:
+    def row_height(self, table_id: int, row: int, height: int | None = None) -> int:
         if height is not None:
             if table_id not in self._row_heights:
                 self._row_heights[table_id] = {}
@@ -1218,7 +1226,7 @@ class _NumbersModel(Cacheable):
                 data[row][col].border.top.width
                 for col in range(len(data[row]))
                 if data[row][col].border.top is not None
-            ]
+            ],
         )
         max_bottom_border = max(
             [0.0]
@@ -1226,7 +1234,7 @@ class _NumbersModel(Cacheable):
                 data[row][col].border.bottom.width
                 for col in range(len(data[row]))
                 if data[row][col].border.bottom is not None
-            ]
+            ],
         )
         height += max_top_border / 2
         height += max_bottom_border / 2
@@ -1243,7 +1251,7 @@ class _NumbersModel(Cacheable):
             width += self.col_width(table_id, row)
         return round(width)
 
-    def col_width(self, table_id: int, col: int, width: Optional[int] = None) -> int:
+    def col_width(self, table_id: int, col: int, width: int | None = None) -> int:
         if width is not None:
             if table_id not in self._col_widths:
                 self._col_widths[table_id] = {}
@@ -1270,7 +1278,7 @@ class _NumbersModel(Cacheable):
                 data[row][col].border.left.width
                 for row in range(len(data))
                 if data[row][col].border.left is not None
-            ]
+            ],
         )
         max_right_border = max(
             [0.0]
@@ -1278,7 +1286,7 @@ class _NumbersModel(Cacheable):
                 data[row][col].border.right.width
                 for row in range(len(data))
                 if data[row][col].border.right is not None
-            ]
+            ],
         )
         width += max_left_border / 2
         width += max_right_border / 2
@@ -1288,21 +1296,21 @@ class _NumbersModel(Cacheable):
         self._col_widths[table_id][col] = floor(width)
         return self._col_widths[table_id][col]
 
-    def num_header_rows(self, table_id: int, num_headers: Optional[int] = None) -> int:
+    def num_header_rows(self, table_id: int, num_headers: int | None = None) -> int:
         """Return/set the number of header rows."""
         table_model = self.objects[table_id]
         if num_headers is not None:
             table_model.number_of_header_rows = num_headers
         return table_model.number_of_header_rows
 
-    def num_header_cols(self, table_id: int, num_headers: Optional[int] = None) -> int:
+    def num_header_cols(self, table_id: int, num_headers: int | None = None) -> int:
         """Return/set the number of header columns."""
         table_model = self.objects[table_id]
         if num_headers is not None:
             table_model.number_of_header_columns = num_headers
         return table_model.number_of_header_columns
 
-    def table_coordinates(self, table_id: int) -> Tuple[float]:
+    def table_coordinates(self, table_id: int) -> tuple[float]:
         table_info = self.objects[self.table_info_id(table_id)]
         return (
             table_info.super.geometry.position.x,
@@ -1347,7 +1355,7 @@ class _NumbersModel(Cacheable):
             ),
         )
 
-    def add_table(  # noqa: PLR0913
+    def add_table(
         self,
         sheet_id: int,
         table_name: str,
@@ -1484,7 +1492,9 @@ class _NumbersModel(Cacheable):
         table_info.super.MergeFrom(self.create_drawable(sheet_id, x, y))
 
         self.add_component_reference(
-            table_info_id, location="Document", component_id=self.calc_engine_id()
+            table_info_id,
+            location="Document",
+            component_id=self.calc_engine_id(),
         )
         self.create_caption_archive(table_model_id)
         self.caption_enabled(table_model_id, False)
@@ -1502,15 +1512,16 @@ class _NumbersModel(Cacheable):
         )
         return table_model_id
 
-    def add_formula_owner(  # noqa: PLR0913
+    def add_formula_owner(
         self,
         table_info_id: int,
         num_rows: int,
         num_cols: int,
         number_of_header_rows: int,
         number_of_header_columns: int,
-    ):
-        """Create a FormulaOwnerDependenciesArchive that references a TableInfoArchive
+    ) -> None:
+        """
+        Create a FormulaOwnerDependenciesArchive that references a TableInfoArchive
         so that cross-references to cells in this table will work.
         """
         formula_owner_uuid = NumbersUUID()
@@ -1589,7 +1600,10 @@ class _NumbersModel(Cacheable):
         )
 
         self.add_component_reference(
-            sheet_id, location="CalculationEngine", component_id=DOCUMENT_ID, is_weak=True
+            sheet_id,
+            location="CalculationEngine",
+            component_id=DOCUMENT_ID,
+            is_weak=True,
         )
 
         self.objects[DOCUMENT_ID].sheets.append(TSPMessages.Reference(identifier=sheet_id))
@@ -1603,7 +1617,7 @@ class _NumbersModel(Cacheable):
         return self._styles
 
     @cache(num_args=0)
-    def available_paragraph_styles(self) -> Dict[str, 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 = {
@@ -1707,7 +1721,7 @@ class _NumbersModel(Cacheable):
         self._styles[style.name] = style
         return para_style_id
 
-    def update_paragraph_style(self, style: Style):
+    def update_paragraph_style(self, style: Style) -> None:
         if style.underline:
             underline = CharacterStyle.UnderlineType.kSingleUnderline
         else:
@@ -1734,8 +1748,9 @@ class _NumbersModel(Cacheable):
         style_obj.para_properties.left_indent = style.left_indent
         style_obj.para_properties.right_indent = style.right_indent
 
-    def update_paragraph_styles(self):
-        """Create new paragraph style archives for any new styles that
+    def update_paragraph_styles(self) -> None:
+        """
+        Create new paragraph style archives for any new styles that
         have been created for this document.
         """
         new_styles = [x for x in self.styles.values() if x._text_style_obj_id is None]
@@ -1751,8 +1766,9 @@ class _NumbersModel(Cacheable):
         for style in updated_styles:
             self.update_paragraph_style(style)
 
-    def update_cell_styles(self, table_id: int, data: List):
-        """Create new cell style archives for any cells whose styles
+    def update_cell_styles(self, table_id: int, data: list) -> None:
+        """
+        Create new cell style archives for any cells whose styles
         have changes that require a cell style.
         """
         cell_styles = {}
@@ -1781,7 +1797,7 @@ class _NumbersModel(Cacheable):
 
     def add_cell_style(self, style: Style) -> int:
         if style.bg_image is not None:
-            digest = sha1(style.bg_image.data).digest()
+            digest = sha1(style.bg_image.data).digest()  # noqa: S324
             if digest in self._images:
                 image_id = self._images[digest]
             else:
@@ -1871,7 +1887,8 @@ class _NumbersModel(Cacheable):
         return entry.reference.identifier
 
     def custom_style_name(self) -> str:
-        """Find custom styles in the current document and return the next
+        """
+        Find custom styles in the current document and return the next
         highest numbered style.
         """
         stylesheet_id = self.objects[DOCUMENT_ID].stylesheet.identifier
@@ -1887,11 +1904,10 @@ class _NumbersModel(Cacheable):
             offset = len("Custom Style ")
             custom_style_ids = [int(x[offset:]) for x in custom_styles]
             return "Custom Style " + str(custom_style_ids[-1] + 1)
-        else:
-            return "Custom Style 1"
+        return "Custom Style 1"
 
     @property
-    def custom_formats(self) -> Dict[str, CustomFormatting]:
+    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
@@ -1908,7 +1924,8 @@ class _NumbersModel(Cacheable):
         return self._custom_formats
 
     def custom_format_name(self) -> str:
-        """Find custom formats in the current document and return the next
+        """
+        Find custom formats in the current document and return the next
         highest numbered format.
         """
         current_formats = self.custom_formats.keys()
@@ -1920,15 +1937,14 @@ class _NumbersModel(Cacheable):
         if len(current_formats) > 0:
             last_id = int(current_formats[-1])
             return f"Custom Format {last_id + 1}"
-        else:
-            return "Custom Format 1"
+        return "Custom Format 1"
 
     @cache()
     def table_formulas(self, table_id: int):
         return TableFormulas(self, table_id)
 
     @cache(num_args=2)
-    def table_rich_text(self, table_id: int, string_key: int) -> Dict:
+    def table_rich_text(self, table_id: int, string_key: int) -> dict:
         """Extract bullets and hyperlinks from a rich text data cell."""
         # The table model base data store contains a richTextTable field
         # which is a reference to a TST.TableDataList. The TableDataList
@@ -1963,12 +1979,12 @@ class _NumbersModel(Cacheable):
         # a string with a new bullet character
         bds = self.objects[table_id].base_data_store
         rich_text_table = self.objects[bds.rich_text_table.identifier]
-        for entry in rich_text_table.entries:  # pragma: no branch
+        for entry in rich_text_table.entries:  # pragma: no branch  # noqa: RET503
             if string_key == entry.key:
                 payload = self.objects[entry.rich_text_payload.identifier]
                 payload_storage = self.objects[payload.storage.identifier]
                 smartfield_entries = payload_storage.table_smartfield.entries
-                cell_text = payload_storage.text[0]
+                cell_text = payload_storage.text[0] if len(payload_storage.text) > 0 else ""
 
                 hyperlinks = []
                 for i, e in enumerate(smartfield_entries):
@@ -2019,7 +2035,8 @@ class _NumbersModel(Cacheable):
                 }
 
     def cell_text_style(self, cell: Cell) -> object:
-        """Return the text style object for the cell or, if none
+        """
+        Return the text style object for the cell or, if none
         is defined, the default header, footer or body style.
         """
         if cell._text_style_id is not None:
@@ -2028,9 +2045,9 @@ class _NumbersModel(Cacheable):
         table_model = self.objects[cell._table_id]
         if cell.row in range(table_model.number_of_header_rows):
             return self.objects[table_model.header_row_text_style.identifier]
-        elif cell.col in range(table_model.number_of_header_columns):
+        if cell.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:
+        if 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.row in range(start_row_num, end_row_num):
@@ -2048,7 +2065,7 @@ class _NumbersModel(Cacheable):
             vertical = VerticalJustification(self.cell_property(style, "vertical_alignment"))
         return Alignment(horizontal, vertical)
 
-    def cell_bg_color(self, cell: Cell) -> Union[Tuple, List[Tuple]]:
+    def cell_bg_color(self, cell: Cell) -> tuple | list[tuple]:
         if cell._cell_style_id is None:
             return None
 
@@ -2057,115 +2074,111 @@ class _NumbersModel(Cacheable):
 
         if cell_properties.HasField("color"):
             return rgb(cell_properties.color)
-        elif cell_properties.HasField("gradient"):
+        if cell_properties.HasField("gradient"):
             return [(rgb(s.color)) for s in cell_properties.gradient.stops]
         return None
 
     def char_property(self, style: object, field: str):
-        """Return a char_property field from a style if present
+        """
+        Return a char_property field from a style if present
         in the style, or from the parent if not.
         """
         if not style.char_properties.HasField(field):
             parent = self.objects[style.super.parent.identifier]
             return getattr(parent.char_properties, field)
-        else:
-            return getattr(style.char_properties, field)
+        return getattr(style.char_properties, field)
 
     def para_property(self, style: object, field: str) -> float:
-        """Return a para_property field from a style if present
+        """
+        Return a para_property field from a style if present
         in the style, or from the parent if not.
         """
         if not style.para_properties.HasField(field):
             parent = self.objects[style.super.parent.identifier]
             return getattr(parent.para_properties, field)
-        else:
-            return getattr(style.para_properties, field)
+        return getattr(style.para_properties, field)
 
     def cell_property(self, style: object, field: str) -> float:
-        """Return a cell_property field from a style if present
+        """
+        Return a cell_property field from a style if present
         in the style, or from the parent if not.
         """
         if not style.cell_properties.HasField(field):
             parent = self.objects[style.super.parent.identifier]
             return getattr(parent.cell_properties, field)
-        else:
-            return getattr(style.cell_properties, field)
+        return getattr(style.cell_properties, field)
 
-    def cell_is_bold(self, obj: Union[Cell, object]) -> bool:
+    def cell_is_bold(self, obj: Cell | object) -> bool:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         return self.char_property(style, "bold")
 
-    def cell_is_italic(self, obj: Union[Cell, object]) -> bool:
+    def cell_is_italic(self, obj: Cell | object) -> bool:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         return self.char_property(style, "italic")
 
-    def cell_is_underline(self, obj: Union[Cell, object]) -> bool:
+    def cell_is_underline(self, obj: Cell | object) -> bool:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         underline = self.char_property(style, "underline")
         return underline != CharacterStyle.UnderlineType.kNoUnderline
 
-    def cell_is_strikethrough(self, obj: Union[Cell, object]) -> bool:
+    def cell_is_strikethrough(self, obj: Cell | object) -> bool:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         strikethru = self.char_property(style, "strikethru")
         return strikethru != CharacterStyle.StrikethruType.kNoStrikethru
 
-    def cell_style_name(self, obj: Union[Cell, object]) -> bool:
+    def cell_style_name(self, obj: Cell | object) -> bool:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         return style.super.name
 
-    def cell_font_color(self, obj: Union[Cell, object]) -> Tuple:
+    def cell_font_color(self, obj: Cell | object) -> tuple:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         return rgb(self.char_property(style, "font_color"))
 
-    def cell_font_size(self, obj: Union[Cell, object]) -> float:
+    def cell_font_size(self, obj: Cell | object) -> float:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         return self.char_property(style, "font_size")
 
-    def cell_font_name(self, obj: Union[Cell, object]) -> str:
+    def cell_font_name(self, obj: Cell | object) -> str:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         font_name = self.char_property(style, "font_name")
         return FONT_NAME_TO_FAMILY[font_name]
 
-    def cell_first_indent(self, obj: Union[Cell, object]) -> float:
+    def cell_first_indent(self, obj: Cell | object) -> float:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         return self.para_property(style, "first_line_indent")
 
-    def cell_left_indent(self, obj: Union[Cell, object]) -> float:
+    def cell_left_indent(self, obj: Cell | object) -> float:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         return self.para_property(style, "left_indent")
 
-    def cell_right_indent(self, obj: Union[Cell, object]) -> float:
+    def cell_right_indent(self, obj: Cell | object) -> float:
         style = self.cell_text_style(obj) if isinstance(obj, Cell) else obj
         return self.para_property(style, "right_indent")
 
     def cell_text_inset(self, cell: Cell) -> float:
         if cell._cell_style_id is None:
             return DEFAULT_TEXT_INSET
-        else:
-            style = self.table_style(cell._table_id, cell._cell_style_id)
-            padding = self.cell_property(style, "padding")
-            # Padding is always identical (only one UI setting)
-            return padding.left
+        style = self.table_style(cell._table_id, cell._cell_style_id)
+        padding = self.cell_property(style, "padding")
+        # Padding is always identical (only one UI setting)
+        return padding.left
 
     def cell_text_wrap(self, cell: Cell) -> float:
         if cell._cell_style_id is None:
             return DEFAULT_TEXT_WRAP
-        else:
-            style = self.table_style(cell._table_id, cell._cell_style_id)
-            return self.cell_property(style, "text_wrap")
+        style = self.table_style(cell._table_id, cell._cell_style_id)
+        return self.cell_property(style, "text_wrap")
 
     def stroke_type(self, stroke_run: object) -> str:
         """Return the stroke type for a stroke run."""
         stroke_type = stroke_run.stroke.pattern.type
         if stroke_type == StrokePattern.StrokePatternType.TSDSolidPattern:
             return "solid"
-        elif stroke_type == StrokePattern.StrokePatternType.TSDPattern:
+        if stroke_type == StrokePattern.StrokePatternType.TSDPattern:
             if stroke_run.stroke.pattern.pattern[0] < 1.0:
                 return "dots"
-            else:
-                return "dashes"
-        else:
-            return "none"
+            return "dashes"
+        return "none"
 
     def cell_for_stroke(self, table_id: int, side: str, row: int, col: int) -> object:
         data = self._table_data[table_id]
@@ -2189,14 +2202,14 @@ class _NumbersModel(Cacheable):
             return cell
         return None
 
-    def set_cell_border(  # noqa: PLR0913
+    def set_cell_border(
         self,
         table_id: int,
         row: int,
         col: int,
         side: str,
         border_value: Border,
-    ):
+    ) -> None:
         """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, col)) is not None:
@@ -2231,7 +2244,7 @@ class _NumbersModel(Cacheable):
                 self._col_widths[table_id].pop(col, None)
                 self._col_widths[table_id].pop(col - 1, None)
 
-    def extract_strokes_in_layers(self, table_id: int, layer_ids: List, side: str):
+    def extract_strokes_in_layers(self, table_id: int, layer_ids: list, side: str) -> None:
         for layer_id in layer_ids:
             stroke_layer = self.objects[layer_id.identifier]
             for stroke_run in stroke_layer.stroke_runs:
@@ -2253,7 +2266,7 @@ class _NumbersModel(Cacheable):
                         self.set_cell_border(table_id, row, start_column, side, border_value)
 
     @cache()
-    def extract_strokes(self, table_id: int):
+    def extract_strokes(self, table_id: int) -> None:
         table_obj = self.objects[table_id]
         sidecar_obj = self.objects[table_obj.stroke_sidecar.identifier]
         self.extract_strokes_in_layers(table_id, sidecar_obj.top_row_stroke_layers, "top")
@@ -2318,7 +2331,7 @@ class _NumbersModel(Cacheable):
             ),
         )
 
-    def add_stroke(  # noqa: PLR0913
+    def add_stroke(
         self,
         table_id: int,
         row: int,
@@ -2326,7 +2339,7 @@ class _NumbersModel(Cacheable):
         side: str,
         border_value: Border,
         length: int,
-    ):
+    ) -> None:
         table_obj = self.objects[table_id]
         sidecar_obj = self.objects[table_obj.stroke_sidecar.identifier]
         sidecar_obj.max_order += 1
@@ -2420,8 +2433,7 @@ def range_end(obj):
     """Select end range for a IndexSetArchive.IndexSetEntry."""
     if obj.HasField("range_end"):
         return obj.range_end
-    else:
-        return obj.range_begin
+    return obj.range_begin
 
 
 def formatted_number(number_type, index):
@@ -2439,18 +2451,16 @@ def node_to_col_ref(node: object, table_name: str, col: int) -> str:
     col_name = xl_col_to_name(col, node.AST_column.absolute)
     if table_name is not None:
         return f"{table_name}::{col_name}"
-    else:
-        return col_name
+    return col_name
 
 
 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}"
+    row_name = f"${row + 1}" if node.AST_row.absolute else f"{row + 1}"
     if table_name is not None:
         return f"{table_name}::{row_name}:{row_name}"
-    else:
-        return f"{row_name}:{row_name}"
+    return f"{row_name}:{row_name}"
 
 
 def node_to_row_col_ref(node: object, table_name: str, row: int, col: int) -> str:
@@ -2465,8 +2475,7 @@ def node_to_row_col_ref(node: object, table_name: str, row: int, col: int) -> st
     )
     if table_name is not None:
         return f"{table_name}::{ref}"
-    else:
-        return ref
+    return ref
 
 
 def get_storage_buffers_for_row(
@@ -2474,8 +2483,9 @@ def get_storage_buffers_for_row(
     offsets: list,
     num_cols: int,
     has_wide_offsets: bool,
-) -> List[bytes]:
-    """Extract storage buffers for each cell in a table row.
+) -> list[bytes]:
+    """
+    Extract storage buffers for each cell in a table row.
 
     Args:
     ----
@@ -2487,6 +2497,7 @@ def get_storage_buffers_for_row(
     Returns:
     -------
          data: list of bytes for each cell in a row, or None if empty
+
     """
     offsets = array("h", offsets).tolist()
     if has_wide_offsets:
@@ -2518,8 +2529,9 @@ def get_storage_buffers_for_row(
     return data
 
 
-def clear_field_container(obj):
-    """Remove all entries from a protobuf RepeatedCompositeFieldContainer
+def clear_field_container(obj) -> None:
+    """
+    Remove all entries from a protobuf RepeatedCompositeFieldContainer
     in a portable fashion.
     """
     while len(obj) > 0:
@@ -2531,5 +2543,5 @@ def field_references(obj: object) -> dict:
     return {
         x[0].name: {"identifier": getattr(obj, x[0].name).identifier}
         for x in obj.ListFields()
-        if type(getattr(obj, x[0].name)) == TSPMessages.Reference
+        if isinstance(getattr(obj, x[0].name), TSPMessages.Reference)
     }