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

numbers_parser/document.py

@@ -1,6 +1,7 @@
-from datetime import datetime, timedelta
+from __future__ import annotations
+
 from pathlib import Path
-from typing import Dict, Iterator, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING
 from warnings import warn
 
 from numbers_parser.cell import (
@@ -33,19 +34,24 @@ from numbers_parser.containers import ItemsList
 from numbers_parser.model import _NumbersModel
 from numbers_parser.numbers_cache import Cacheable
 
+if TYPE_CHECKING:  # pragma: nocover
+    from collections.abc import Iterator
+    from datetime import datetime, timedelta
+
 __all__ = ["Document", "Sheet", "Table"]
 
 
-class Sheet:
-    pass
+# class Sheet:
+#     pass
 
 
-class Table:
-    pass
+# class Table:
+#     pass
 
 
 class Document:
-    """Create an instance of a new Numbers document.
+    """
+    Create an instance of a new Numbers document.
 
     If ``filename`` is ``None``, an empty document is created using the defaults
     defined by the class constructor. You can optionionally override these
@@ -74,17 +80,20 @@ class Document:
         If the sheet name already exists in the document.
     IndexError:
         If the table name already exists in the first sheet.
+    UnsupportedError:
+        If the document is encrypted.
+
     """
 
-    def __init__(  # noqa: PLR0913
+    def __init__(
         self,
-        filename: Optional[Union[str, Path]] = None,
-        sheet_name: Optional[str] = "Sheet 1",
-        table_name: Optional[str] = "Table 1",
-        num_header_rows: Optional[int] = 1,
-        num_header_cols: Optional[int] = 1,
-        num_rows: Optional[int] = DEFAULT_ROW_COUNT,
-        num_cols: Optional[int] = DEFAULT_COLUMN_COUNT,
+        filename: str | Path | None = None,
+        sheet_name: str | None = "Sheet 1",
+        table_name: str | None = "Table 1",
+        num_header_rows: int | None = 1,
+        num_header_cols: int | None = 1,
+        num_rows: int | None = DEFAULT_ROW_COUNT,
+        num_cols: int | None = DEFAULT_COLUMN_COUNT,
     ) -> None:
         self._model = _NumbersModel(None if filename is None else Path(filename))
         refs = self._model.sheet_ids()
@@ -102,7 +111,7 @@ class Document:
             table.num_header_cols = num_header_cols
 
     @property
-    def sheets(self) -> List[Sheet]:
+    def sheets(self) -> list[Sheet]:
         """List[:class:`Sheet`]: A list of sheets in the document."""
         return self._sheets
 
@@ -112,19 +121,21 @@ class Document:
         return self.sheets[0].tables[0]
 
     @property
-    def styles(self) -> Dict[str, Style]:
+    def styles(self) -> dict[str, Style]:
         """Dict[str, :class:`Style`]: A dict mapping style names to to the corresponding style."""
         return self._model.styles
 
     @property
-    def custom_formats(self) -> Dict[str, CustomFormatting]:
-        """Dict[str, :class:`CustomFormatting`]: A dict mapping custom format names
+    def custom_formats(self) -> dict[str, CustomFormatting]:
+        """
+        Dict[str, :class:`CustomFormatting`]: A dict mapping custom format names
         to the corresponding custom format.
         """
         return self._model.custom_formats
 
-    def save(self, filename: Union[str, Path], package: bool = False) -> None:
-        """Save the document in the specified filename.
+    def save(self, filename: str | Path, package: bool = False) -> None:
+        """
+        Save the document in the specified filename.
 
         Parameters
         ----------
@@ -140,6 +151,7 @@ class Document:
         FileFormatError:
             If attempting to write a package into a folder that is not an
             existing Numbers document.
+
         """
         for sheet in self.sheets:
             for table in sheet.tables:
@@ -156,12 +168,13 @@ class Document:
 
     def add_sheet(
         self,
-        sheet_name: Optional[str] = None,
-        table_name: Optional[str] = "Table 1",
-        num_rows: Optional[int] = DEFAULT_ROW_COUNT,
-        num_cols: Optional[int] = DEFAULT_COLUMN_COUNT,
+        sheet_name: str | None = None,
+        table_name: str | None = "Table 1",
+        num_rows: int | None = DEFAULT_ROW_COUNT,
+        num_cols: int | None = DEFAULT_COLUMN_COUNT,
     ) -> None:
-        """Add a new sheet to the current document.
+        """
+        Add a new sheet to the current document.
 
         If no sheet name is provided, the next available numbered sheet
         will be generated in the series ``Sheet 1``, ``Sheet 2``, etc.
@@ -180,6 +193,7 @@ class Document:
         Raises
         ------
             IndexError: If the sheet name already exists in the document.
+
         """
         if sheet_name is not None:
             if sheet_name in self._sheets:
@@ -211,7 +225,8 @@ class Document:
         self._sheets.append(new_sheet)
 
     def add_style(self, **kwargs) -> Style:
-        r"""Add a new style to the current document.
+        r"""
+        Add a new style to the current document.
 
         If no style name is provided, the next available numbered style
         will be generated in the series ``Custom Style 1``, ``Custom Style 2``, etc.
@@ -241,6 +256,7 @@ class Document:
             If ``font_size`` is not a ``float``, ``font_name`` is not a ``str``,
             ``bg_image`` is not a :py:class:`~numbers_parser.BackgroundImage`,
             or if any of the ``bool`` parameters are invalid.
+
         """
         if "name" in kwargs and kwargs["name"] is not None and kwargs["name"] in self._model.styles:
             msg = f"style '{kwargs['name']}' already exists"
@@ -260,13 +276,14 @@ class Document:
         return style
 
     def add_custom_format(self, **kwargs) -> CustomFormatting:
-        r"""Add a new custom format to the current document.
+        r"""
+        Add a new custom format to the current document.
 
         .. code-block:: python
 
             long_date = doc.add_custom_format(
                 name="Long Date",
-                type="date",
+                type="datetime",
                 date_time_format="EEEE, d MMMM yyyy"
             )
             table.set_cell_formatting("C1", "custom", format=long_date)
@@ -276,9 +293,9 @@ class Document:
         depending upon the value of ``kwargs["type"]``.
 
         :Common Args:
-            * **name** (``str``) – The name of the custom format. If no name is provided,
+            * **name** (``str``) - The name of the custom format. If no name is provided,
               one is generated using the scheme ``Custom Format``, ``Custom Format 1``, ``Custom Format 2``, etc.
-            * **type** (``str``, *optional*, default: ``number``) – The type of format to
+            * **type** (``str``, *optional*, default: ``number``) - The type of format to
               create:
 
               * ``"datetime"``: A date and time value with custom formatting.
@@ -286,26 +303,26 @@ class Document:
               * ``"text"``: A simple text string.
 
         :``"number"``:
-            * **integer_format** (``PaddingType``, *optional*, default: ``PaddingType.NONE``) – How
+            * **integer_format** (``PaddingType``, *optional*, default: ``PaddingType.NONE``) - How
               to pad integers.
-            * **decimal_format** (``PaddingType``, *optional*, default: ``PaddingType.NONE``) – How
+            * **decimal_format** (``PaddingType``, *optional*, default: ``PaddingType.NONE``) - How
               to pad decimals.
-            * **num_integers** (``int``, *optional*, default: ``0``) – Integer precision
+            * **num_integers** (``int``, *optional*, default: ``0``) - Integer precision
               when integers are padded.
-            * **num_decimals** (``int``, *optional*, default: ``0``) – Integer precision
+            * **num_decimals** (``int``, *optional*, default: ``0``) - Integer precision
               when decimals are padded.
-            * **show_thousands_separator** (``bool``, *optional*, default: ``False``) – ``True``
+            * **show_thousands_separator** (``bool``, *optional*, default: ``False``) - ``True``
               if the number should include a thousands seperator.
 
         :``"datetime"``:
-            * **format** (``str``, *optional*, default: ``"d MMM y"``) – A POSIX strftime-like
+            * **format** (``str``, *optional*, default: ``"d MMM y"``) - A POSIX strftime-like
               formatting string of `Numbers date/time directives <#datetime-formats>`_.
 
         :``"text"``:
-            * **format** (``str``, *optional*, default: ``"%s"``) – Text format.
+            * **format** (``str``, *optional*, default: ``"%s"``) - Text format.
               The cell value is inserted in place of %s. Only one substitution is allowed by
               Numbers, and multiple %s formatting references raise a TypeError exception
-        """  # noqa: E501
+        """
         if (
             "name" in kwargs
             and kwargs["name"] is not None
@@ -342,7 +359,7 @@ class Sheet:
         self._tables = ItemsList(self._model, refs, Table)
 
     @property
-    def tables(self) -> List[Table]:
+    def tables(self) -> list[Table]:
         """List[:class:`Table`]: A list of tables in the sheet."""
         return self._tables
 
@@ -352,18 +369,19 @@ class Sheet:
         return self._model.sheet_name(self._sheet_id)
 
     @name.setter
-    def name(self, value: str):
+    def name(self, value: str) -> None:
         self._model.sheet_name(self._sheet_id, value)
 
-    def add_table(  # noqa: PLR0913
+    def add_table(
         self,
-        table_name: Optional[str] = None,
-        x: Optional[float] = None,
-        y: Optional[float] = None,
-        num_rows: Optional[int] = DEFAULT_ROW_COUNT,
-        num_cols: Optional[int] = DEFAULT_COLUMN_COUNT,
+        table_name: str | None = None,
+        x: float | None = None,
+        y: float | None = None,
+        num_rows: int | None = DEFAULT_ROW_COUNT,
+        num_cols: int | None = DEFAULT_COLUMN_COUNT,
     ) -> Table:
-        """Add a new table to the current sheet.
+        """
+        Add a new table to the current sheet.
 
         If no table name is provided, the next available numbered table
         will be generated in the series ``Table 1``, ``Table 2``, etc.
@@ -402,11 +420,12 @@ class Sheet:
         Raises
         ------
             IndexError: If the table name already exists.
+
         """
         from_table_id = self._tables[-1]._table_id
         return self._add_table(table_name, from_table_id, x, y, num_rows, num_cols)
 
-    def _add_table(  # noqa: PLR0913
+    def _add_table(
         self,
         table_name,
         from_table_id,
@@ -470,7 +489,7 @@ class Table(Cacheable):
         return self._model.table_name(self._table_id)
 
     @name.setter
-    def name(self, value: str):
+    def name(self, value: str) -> None:
         self._model.table_name(self._table_id, value)
 
     @property
@@ -479,7 +498,7 @@ class Table(Cacheable):
         return self._model.table_name_enabled(self._table_id)
 
     @table_name_enabled.setter
-    def table_name_enabled(self, enabled: bool):
+    def table_name_enabled(self, enabled: bool) -> None:
         self._model.table_name_enabled(self._table_id, enabled)
 
     @property
@@ -502,7 +521,8 @@ class Table(Cacheable):
 
     @property
     def num_header_rows(self) -> int:
-        """int: The number of header rows.
+        """
+        int: The number of header rows.
 
         Example
         -------
@@ -516,6 +536,7 @@ class Table(Cacheable):
         ValueError:
             If the number of headers is negative, exceeds the number of rows in the
             table, or exceeds Numbers maxinum number of headers (``MAX_HEADER_COUNT``).
+
         """
         return self._model.num_header_rows(self._table_id)
 
@@ -524,17 +545,18 @@ class Table(Cacheable):
         if num_headers < 0:
             msg = "Number of headers cannot be negative"
             raise ValueError(msg)
-        elif num_headers > self.num_rows:
+        if num_headers > self.num_rows:
             msg = "Number of headers cannot exceed the number of rows"
             raise ValueError(msg)
-        elif num_headers > MAX_HEADER_COUNT:
+        if num_headers > MAX_HEADER_COUNT:
             msg = f"Number of headers cannot exceed {MAX_HEADER_COUNT} rows"
             raise ValueError(msg)
         return self._model.num_header_rows(self._table_id, num_headers)
 
     @property
     def num_header_cols(self) -> int:
-        """int: The number of header columns.
+        """
+        int: The number of header columns.
 
         Example
         -------
@@ -548,6 +570,7 @@ class Table(Cacheable):
         ValueError:
             If the number of headers is negative, exceeds the number of rows in the
             table, or exceeds Numbers maxinum number of headers (``MAX_HEADER_COUNT``).
+
         """
         return self._model.num_header_cols(self._table_id)
 
@@ -556,10 +579,10 @@ class Table(Cacheable):
         if num_headers < 0:
             msg = "Number of headers cannot be negative"
             raise ValueError(msg)
-        elif num_headers > self.num_cols:
+        if num_headers > self.num_cols:
             msg = "Number of headers cannot exceed the number of columns"
             raise ValueError(msg)
-        elif num_headers > MAX_HEADER_COUNT:
+        if num_headers > MAX_HEADER_COUNT:
             msg = f"Number of headers cannot exceed {MAX_HEADER_COUNT} columns"
             raise ValueError(msg)
         return self._model.num_header_cols(self._table_id, num_headers)
@@ -574,8 +597,9 @@ class Table(Cacheable):
         """int: The table's width in points."""
         return self._model.table_width(self._table_id)
 
-    def row_height(self, row: int, height: Optional[int] = None) -> int:
-        """The height of a table row in points.
+    def row_height(self, row: int, height: int | None = None) -> int:
+        """
+        The height of a table row in points.
 
         .. code-block:: python
 
@@ -593,11 +617,13 @@ class Table(Cacheable):
         -------
         int:
             The height of the table row.
+
         """
         return self._model.row_height(self._table_id, row, height)
 
-    def col_width(self, col: int, width: Optional[int] = None) -> int:
-        """The width of a table column in points.
+    def col_width(self, col: int, width: int | None = None) -> int:
+        """
+        The width of a table column in points.
 
         Parameters
         ----------
@@ -610,16 +636,18 @@ class Table(Cacheable):
         -------
         int:
             The width of the table column.
+
         """
         return self._model.col_width(self._table_id, col, width)
 
     @property
-    def coordinates(self) -> Tuple[float]:
+    def coordinates(self) -> tuple[float]:
         """Tuple[float]: The table's x, y offsets in points."""
         return self._model.table_coordinates(self._table_id)
 
-    def rows(self, values_only: bool = False) -> Union[List[List[Cell]], List[List[str]]]:
-        """Return all rows of cells for the Table.
+    def rows(self, values_only: bool = False) -> list[list[Cell]] | list[list[str]]:
+        """
+        Return all rows of cells for the Table.
 
         Parameters
         ----------
@@ -630,15 +658,16 @@ class Table(Cacheable):
         -------
         List[List[Cell]] | List[List[str]]:
             List of rows; each row is a list of :class:`Cell` objects, or string values.
+
         """
         if values_only:
             return [[cell.value for cell in row] for row in self._data]
-        else:
-            return self._data
+        return self._data
 
     @property
-    def merge_ranges(self) -> List[str]:
-        """List[str]: The merge ranges of cells in A1 notation.
+    def merge_ranges(self) -> list[str]:
+        """
+        List[str]: The merge ranges of cells in A1 notation.
 
         Example
         -------
@@ -650,6 +679,7 @@ class Table(Cacheable):
             <numbers_parser.cell.TextCell object at 0x1035f4a90>
             >>> table.cell("A5")
             <numbers_parser.cell.MergedCell object at 0x1035f5310>
+
         """
         merge_cells = set()
         for row, cells in enumerate(self._data):
@@ -659,8 +689,9 @@ class Table(Cacheable):
                     merge_cells.add(xl_range(row, col, row + size[0] - 1, col + size[1] - 1))
         return sorted(merge_cells)
 
-    def cell(self, *args) -> Union[Cell, MergedCell]:
-        """Return a single cell in the table.
+    def cell(self, *args) -> Cell | MergedCell:  # noqa: D417
+        """
+        Return a single cell in the table.
 
         The ``cell()`` method supports two forms of notation to designate the position
         of cells: **Row-column** notation and **A1** notation:
@@ -699,6 +730,7 @@ class Table(Cacheable):
             <numbers_parser.cell.TextCell object at 0x105a80b90>
             >>> table.cell("B2").value
             1234.50
+
         """
         if isinstance(args[0], str):
             (row, col) = xl_cell_to_rowcol(args[0])
@@ -716,15 +748,16 @@ class Table(Cacheable):
 
         return self._data[row][col]
 
-    def iter_rows(  # noqa: PLR0913
+    def iter_rows(
         self,
-        min_row: Optional[int] = None,
-        max_row: Optional[int] = None,
-        min_col: Optional[int] = None,
-        max_col: Optional[int] = None,
-        values_only: Optional[bool] = False,
-    ) -> Iterator[Union[Tuple[Cell], Tuple[str]]]:
-        """Produces cells from a table, by row.
+        min_row: int | None = None,
+        max_row: int | None = None,
+        min_col: int | None = None,
+        max_col: int | None = None,
+        values_only: bool | None = False,
+    ) -> Iterator[tuple[Cell] | tuple[str]]:
+        """
+        Produces cells from a table, by row.
 
         Specify the iteration range using the indexes of the rows and columns.
 
@@ -758,6 +791,7 @@ class Table(Cacheable):
 
             for row in table.iter_rows(min_row=2, max_row=7, values_only=True):
                 sum += row
+
         """
         min_row = min_row or 0
         max_row = max_row or self.num_rows - 1
@@ -784,15 +818,16 @@ class Table(Cacheable):
             else:
                 yield tuple(rows[row][min_col : max_col + 1])
 
-    def iter_cols(  # noqa: PLR0913
+    def iter_cols(
         self,
-        min_col: Optional[int] = None,
-        max_col: Optional[int] = None,
-        min_row: Optional[int] = None,
-        max_row: Optional[int] = None,
-        values_only: Optional[bool] = False,
-    ) -> Iterator[Union[Tuple[Cell], Tuple[str]]]:
-        """Produces cells from a table, by column.
+        min_col: int | None = None,
+        max_col: int | None = None,
+        min_row: int | None = None,
+        max_row: int | None = None,
+        values_only: bool | None = False,
+    ) -> Iterator[tuple[Cell] | tuple[str]]:
+        """
+        Produces cells from a table, by column.
 
         Specify the iteration range using the indexes of the rows and columns.
 
@@ -826,6 +861,7 @@ class Table(Cacheable):
 
             for col in table.iter_cols(min_row=2, max_row=7):
                 sum += col.value
+
         """
         min_row = min_row or 0
         max_row = max_row or self.num_rows - 1
@@ -877,8 +913,9 @@ class Table(Cacheable):
 
         return (row, col, *tuple(values))
 
-    def write(self, *args, style: Optional[Union[Style, str, None]] = None) -> None:
-        """Write a value to a cell and update the style/cell type.
+    def write(self, *args, style: Style | str | None = None) -> None:  # noqa: D417
+        """
+        Write a value to a cell and update the style/cell type.
 
         The ``write()`` method supports two forms of notation to designate the position
         of cells: **Row-column** notation and **A1** notation:
@@ -919,6 +956,7 @@ class Table(Cacheable):
             If the style parameter is an invalid type.
         ValueError:
             If the cell type cannot be determined from the type of `param3`.
+
         """
         # TODO: write needs to retain/init the border
         (row, col, value) = self._validate_cell_coords(*args)
@@ -933,7 +971,7 @@ class Table(Cacheable):
         if style is not None:
             self.set_cell_style(row, col, style)
 
-    def set_cell_style(self, *args):
+    def set_cell_style(self, *args) -> None:
         (row, col, style) = self._validate_cell_coords(*args)
         if isinstance(style, Style):
             self._data[row][col]._style = style
@@ -948,11 +986,12 @@ class Table(Cacheable):
 
     def add_row(
         self,
-        num_rows: Optional[int] = 1,
-        start_row: Optional[Union[int, None]] = None,
-        default: Optional[Union[str, int, float, bool, datetime, timedelta]] = None,
+        num_rows: int | None = 1,
+        start_row: int | None = None,
+        default: str | float | bool | datetime | timedelta | None = None,
     ) -> None:
-        """Add or insert rows to the table.
+        """
+        Add or insert rows to the table.
 
         Parameters
         ----------
@@ -978,6 +1017,7 @@ class Table(Cacheable):
             If the start_row is out of range for the table.
         ValueError:
             If the default value is unsupported by :py:meth:`numbers_parser.Table.write`.
+
         """
         if start_row is not None and (start_row < 0 or start_row >= self.num_rows):
             msg = "Row number not in range for table"
@@ -994,7 +1034,7 @@ class Table(Cacheable):
                 [
                     Cell._empty_cell(self._table_id, row, col, self._model)
                     for col in range(self.num_cols)
-                ]
+                ],
             )
         self._data[start_row:start_row] = rows
 
@@ -1010,11 +1050,12 @@ class Table(Cacheable):
 
     def add_column(
         self,
-        num_cols: Optional[int] = 1,
-        start_col: Optional[Union[int, None]] = None,
-        default: Optional[Union[str, int, float, bool, datetime, timedelta]] = None,
+        num_cols: int | None = 1,
+        start_col: int | None = None,
+        default: str | float | bool | datetime | timedelta | None = None,
     ) -> None:
-        """Add or insert columns to the table.
+        """
+        Add or insert columns to the table.
 
         Parameters
         ----------
@@ -1040,6 +1081,7 @@ class Table(Cacheable):
             If the start_col is out of range for the table.
         ValueError:
             If the default value is unsupported by :py:meth:`numbers_parser.Table.write`.
+
         """
         if start_col is not None and (start_col < 0 or start_col >= self.num_cols):
             msg = "Column number not in range for table"
@@ -1066,10 +1108,11 @@ class Table(Cacheable):
 
     def delete_row(
         self,
-        num_rows: Optional[int] = 1,
-        start_row: Optional[Union[int, None]] = None,
+        num_rows: int | None = 1,
+        start_row: int | None = None,
     ) -> None:
-        """Delete rows from the table.
+        """
+        Delete rows from the table.
 
         Parameters
         ----------
@@ -1089,6 +1132,7 @@ class Table(Cacheable):
         ------
         IndexError:
             If the start_row is out of range for the table.
+
         """
         if start_row is not None and (start_row < 0 or start_row >= self.num_rows):
             msg = "Row number not in range for table"
@@ -1110,10 +1154,11 @@ class Table(Cacheable):
 
     def delete_column(
         self,
-        num_cols: Optional[int] = 1,
-        start_col: Optional[Union[int, None]] = None,
+        num_cols: int | None = 1,
+        start_col: int | None = None,
     ) -> None:
-        """Add or delete columns columns from the table.
+        """
+        Add or delete columns columns from the table.
 
         Parameters
         ----------
@@ -1127,6 +1172,7 @@ class Table(Cacheable):
         ------
         IndexError:
             If the start_col is out of range for the table.
+
         """
         if start_col is not None and (start_col < 0 or start_col >= self.num_cols):
             msg = "Column number not in range for table"
@@ -1143,8 +1189,9 @@ class Table(Cacheable):
         self.num_cols -= num_cols
         self._model.number_of_columns(self._table_id, self.num_cols)
 
-    def merge_cells(self, cell_range: Union[str, List[str]]) -> None:
-        """Convert a cell range or list of cell ranges into merged cells.
+    def merge_cells(self, cell_range: str | list[str]) -> None:
+        """
+        Convert a cell range or list of cell ranges into merged cells.
 
         Parameters
         ----------
@@ -1162,6 +1209,7 @@ class Table(Cacheable):
             >>> table.merge_cells("B2:C2")
             >>> table.cell("B2").is_merged
             True
+
         """
         if isinstance(cell_range, list):
             for x in cell_range:
@@ -1184,8 +1232,9 @@ class Table(Cacheable):
                 for col, cell in enumerate(cells):
                     cell._set_merge(merge_cells.get((row, col)))
 
-    def set_cell_border(self, *args):
-        """Set the borders for a cell.
+    def set_cell_border(self, *args) -> None:
+        """
+        Set the borders for a cell.
 
         Cell references can be row-column offsers or Excel/Numbers-style A1 notation. Borders
         can be applied to multiple sides of a cell by passing a list of sides. The name(s)
@@ -1221,10 +1270,11 @@ class Table(Cacheable):
             If an invalid number of arguments is passed or if the types of the arguments
             are invalid.
 
-        Warns
+        Warns:
         -----
         RuntimeWarning:
             If any of the sides to which the border is applied have been merged.
+
         """
         (row, col, *args) = self._validate_cell_coords(*args)
         if len(args) == 2:
@@ -1250,20 +1300,17 @@ class Table(Cacheable):
             return
 
         cell = self._data[row][col]
-        if cell.is_merged and (
-            (side == "right" and cell.size[1] > 1) or (side == "bottom" and cell.size[0] > 1)
-        ):
-            warn(
-                f"{side} edge of [{row},{col}] is merged; border not set",
-                RuntimeWarning,
-                stacklevel=2,
+        if (
+            cell.is_merged
+            and ((side == "right" and cell.size[1] > 1) or (side == "bottom" and cell.size[0] > 1))
+        ) or (
+            isinstance(cell, MergedCell)
+            and (
+                (side == "top" and cell.row_start < row)
+                or (side == "right" and cell.col_end > col)
+                or (side == "bottom" and cell.row_end > row)
+                or (side == "left" and cell.col_start < col)
             )
-            return
-        elif isinstance(cell, MergedCell) and (
-            (side == "top" and cell.row_start < row)
-            or (side == "right" and cell.col_end > col)
-            or (side == "bottom" and cell.row_end > row)
-            or (side == "left" and cell.col_start < col)
         ):
             warn(
                 f"{side} edge of [{row},{col}] is merged; border not set",
@@ -1287,7 +1334,8 @@ class Table(Cacheable):
         self._model.add_stroke(self._table_id, row, col, side, border_value, length)
 
     def set_cell_formatting(self, *args: str, **kwargs) -> None:
-        r"""Set the data format for a cell.
+        r"""
+        Set the data format for a cell.
 
         Cell references can be **row-column** offsers or Excel/Numbers-style **A1** notation.
 
@@ -1295,7 +1343,7 @@ class Table(Cacheable):
 
             table.set_cell_formatting(
                 "C1",
-                "date",
+                "datetime",
                 date_time_format="EEEE, d MMMM yyyy"
             )
             table.set_cell_formatting(
@@ -1314,7 +1362,7 @@ class Table(Cacheable):
             )
 
         :Parameters:
-            * **args** (*list*, *optional*) – Positional arguments for cell reference and data format type (see below)
+            * **args** (*list*, *optional*) - Positional arguments for cell reference and data format type (see below)
             * **kwargs** (*dict*, *optional*) - Key-value pairs defining a formatting options for each data format (see below).
 
         :Args (row-column):
@@ -1343,9 +1391,9 @@ class Table(Cacheable):
         depending upon the value of ``kwargs["type"]``.
 
         :Common Args:
-            * **name** (*str*) – The name of the custom format. If no name is provided,
+            * **name** (*str*) - The name of the custom format. If no name is provided,
               one is generated using the scheme ``Custom Format``, ``Custom Format 1``, ``Custom Format 2``, etc.
-            * **type** (*str, optional, default: number*) – The type of format to
+            * **type** (*str, optional, default: number*) - The type of format to
               create:
 
               * ``"base"``: A number base in the range 2-36.
@@ -1363,51 +1411,51 @@ class Table(Cacheable):
               * ``"popup"``: A menu of options.
 
         :``"base"``:
-            * **base_use_minus_sign** (*int, optional, default: 10*) – The integer
+            * **base_use_minus_sign** (*int, optional, default: 10*) - The integer
               base to represent the number from 2-36.
-            * **base_use_minus_sign** (*bool, optional, default: True*) – If ``True``
+            * **base_use_minus_sign** (*bool, optional, default: True*) - If ``True``
               use a standard minus sign, otherwise format as two's compliment (only
               possible for binary, octal and hexadecimal.
-            * **base_places** (*int, optional, default: 0*) – The number of
+            * **base_places** (*int, optional, default: 0*) - The number of
               decimal places, or ``None`` for automatic.
 
         :``"custom"``:
-            * **format** (*str | CustomFormating*) – The name of a custom
+            * **format** (*str | CustomFormating*) - The name of a custom
                 formatin the document or a :py:class:`~numbers_parser.CustomFormatting`
                 object.
 
         :``"currency"``:
-            * **currency** (*str, optional, default: "GBP"*) – An ISO currency
+            * **currency** (*str, optional, default: "GBP"*) - An ISO currency
               code, e.g. ``"GBP"`` or ``"USD"``.
-            * **decimal_places** (*int, optional, default: 2*) – The number of
+            * **decimal_places** (*int, optional, default: 2*) - The number of
               decimal places, or ``None`` for automatic.
-            * **negative_style** (*:py:class:`~numbers_parser.NegativeNumberStyle`, optional, default: NegativeNumberStyle.MINUS*) – How negative numbers are represented.
+            * **negative_style** (*:py:class:`~numbers_parser.NegativeNumberStyle`, optional, default: NegativeNumberStyle.MINUS*) - How negative numbers are represented.
               See `Negative number formats <#negative-formats>`_.
-            * **show_thousands_separator** (*bool, optional, default: False*) – ``True``
+            * **show_thousands_separator** (*bool, optional, default: False*) - ``True``
               if the number should include a thousands seperator, e.g. ``,``
-            * **use_accounting_style** (*bool, optional, default: False*) –  ``True``
+            * **use_accounting_style** (*bool, optional, default: False*) -  ``True``
               if the currency symbol should be formatted to the left of the cell and
               separated from the number value by a tab.
 
         :``"datetime"``:
-            * **date_time_format** (*str, optional, default: "dd MMM YYY HH:MM"*) – A POSIX
+            * **date_time_format** (*str, optional, default: "dd MMM YYY HH:MM"*) - A POSIX
                strftime-like formatting string of `Numbers date/time
                directives <#datetime-formats>`_.
 
         :``"fraction"``:
-            * **fraction_accuracy** (*:py:class:`~numbers_parser.FractionAccuracy`, optional, default: FractionAccuracy.THREE* – The
+            * **fraction_accuracy** (*:py:class:`~numbers_parser.FractionAccuracy`, optional, default: FractionAccuracy.THREE* - The
                 precision of the faction.
 
         :``"percentage"``:
-            * **decimal_places** (*float, optional, default: None*) –  number of
+            * **decimal_places** (*float, optional, default: None*) -  number of
               decimal places, or ``None`` for automatic.
-            * **negative_style** (*:py:class:`~numbers_parser.NegativeNumberStyle`, optional, default: NegativeNumberStyle.MINUS*) – How negative numbers are represented.
+            * **negative_style** (*:py:class:`~numbers_parser.NegativeNumberStyle`, optional, default: NegativeNumberStyle.MINUS*) - How negative numbers are represented.
               See `Negative number formats <#negative-formats>`_.
-            * **show_thousands_separator** (*bool, optional, default: False*) – ``True``
+            * **show_thousands_separator** (*bool, optional, default: False*) - ``True``
               if the number should include a thousands seperator, e.g. ``,``
 
         :``"scientific"``:
-            * **decimal_places** (*float, optional, default: None*) – number of
+            * **decimal_places** (*float, optional, default: None*) - number of
               decimal places, or ``None`` for automatic.
 
         :``"tickbox"``:
@@ -1439,13 +1487,13 @@ class Table(Cacheable):
             * **minimum** (*float, optional, default: 1*) - increment value for the stepper
 
         :`"popup"``:
-            * **popup_values** (*List[str|int|float], optional, default: None*) – values
+            * **popup_values** (*List[str|int|float], optional, default: None*) - values
                 for the popup menu
             * **allow_none** (*bool, optional, default: True*) - If ``True``
                 include a blank value in the list
 
 
-        """  # noqa: E501
+        """
         (row, col, *args) = self._validate_cell_coords(*args)
         if len(args) == 1:
             format_type = args[0]
@@ -1506,9 +1554,9 @@ class Table(Cacheable):
                 msg,
             )
 
-        format = Formatting(type=format_type, **kwargs)
+        formatting = Formatting(type=format_type, **kwargs)
         if format_type_name in FORMATTING_ACTION_CELLS:
-            control_id = self._model.control_cell_archive(self._table_id, format_type, format)
+            control_id = self._model.control_cell_archive(self._table_id, format_type, formatting)
         else:
             control_id = None
 
@@ -1527,20 +1575,20 @@ class Table(Cacheable):
                     ) from None
             else:
                 number_format_type = FormattingType.NUMBER
-            format_id = self._model.format_archive(self._table_id, number_format_type, format)
+            format_id = self._model.format_archive(self._table_id, number_format_type, formatting)
         elif format_type_name == "popup":
-            if cell.value == "" and not format.allow_none:
+            if cell.value == "" and not formatting.allow_none:
                 msg = "none value not allowed for popup"
                 raise IndexError(msg)
-            elif cell.value != "" and cell.value not in format.popup_values:
+            if cell.value != "" and cell.value not in formatting.popup_values:
                 msg = f"current cell value '{cell.value}' does not match any popup values"
                 raise IndexError(
                     msg,
                 )
 
             popup_format_type = FormattingType.TEXT if isinstance(cell, TextCell) else True
-            format_id = self._model.format_archive(self._table_id, popup_format_type, format)
+            format_id = self._model.format_archive(self._table_id, popup_format_type, formatting)
         else:
-            format_id = self._model.format_archive(self._table_id, format_type, format)
+            format_id = self._model.format_archive(self._table_id, format_type, formatting)
 
         cell._set_formatting(format_id, format_type, control_id, is_currency=is_currency)