numbers-parser 4.13.3__py3-none-any.whl → 4.14.2__py3-none-any.whl

numbers_parser/cell.py

@@ -1,25 +1,21 @@
+from __future__ import annotations
+
 import logging
 import math
 import re
-from collections import namedtuple
 from dataclasses import asdict, dataclass, field, fields
-from datetime import datetime as builtin_datetime
-from datetime import timedelta as builtin_timedelta
+from datetime import datetime, timedelta
 from enum import IntEnum
 from fractions import Fraction
 from hashlib import sha1
 from os.path import basename
 from struct import pack, unpack
-from typing import Any, List, Optional, Tuple, Union
+from typing import Any, NamedTuple
 from warnings import warn
 
-import sigfig
-from pendulum import DateTime, Duration, datetime, duration
-from pendulum import instance as pendulum_instance
+from sigfig import round as sigfig
 
 from numbers_parser import __name__ as numbers_parser_name
-
-# from numbers_parser.cell_storage import CellStorage, CellType
 from numbers_parser.constants import (
     CHECKBOX_FALSE_VALUE,
     CHECKBOX_TRUE_VALUE,
@@ -104,7 +100,8 @@ __all__ = [
 
 
 class BackgroundImage:
-    """A named document style that can be applied to cells.
+    """
+    A named document style that can be applied to cells.
 
     .. code-block:: python
 
@@ -126,9 +123,10 @@ class BackgroundImage:
         Raw image data for a cell background image.
     filename: str
         Path to the image file.
+
     """
 
-    def __init__(self, data: Optional[bytes] = None, filename: Optional[str] = None) -> None:
+    def __init__(self, data: bytes | None = None, filename: str | None = None) -> None:
         self._data = data
         self._filename = basename(filename)
 
@@ -171,7 +169,12 @@ VERTICAL_MAP = {
     "bottom": VerticalJustification.BOTTOM,
 }
 
-_Alignment = namedtuple("Alignment", ["horizontal", "vertical"])
+
+class _Alignment(NamedTuple):
+    """Class for internal alignment type."""
+
+    horizontal: str
+    vertical: str
 
 
 class Alignment(_Alignment):
@@ -195,12 +198,23 @@ class Alignment(_Alignment):
 
 DEFAULT_ALIGNMENT_CLASS = Alignment(*DEFAULT_ALIGNMENT)
 
-RGB = namedtuple("RGB", ["r", "g", "b"])
+
+class RGB(NamedTuple):
+    """A color in RGB."""
+
+    r: int
+    g: int
+    b: int
+
+
+def default_color() -> RGB:
+    return RGB(0, 0, 0)
 
 
 @dataclass
 class Style:
-    """A named document style that can be applied to cells.
+    """
+    A named document style that can be applied to cells.
 
     Parameters
     ----------
@@ -240,12 +254,13 @@ class Style:
         If arguments do not match the specified type or for objects have invalid arguments
     IndexError:
         If an image filename already exists in document
+
     """
 
     alignment: Alignment = DEFAULT_ALIGNMENT_CLASS  # : horizontal and vertical alignment
     bg_image: object = None  # : backgroung image
-    bg_color: Union[RGB, List[RGB]] = None
-    font_color: RGB = RGB(0, 0, 0)
+    bg_color: RGB | list[RGB] = None
+    font_color: RGB = field(default_factory=default_color)
     font_size: float = DEFAULT_FONT_SIZE
     font_name: str = DEFAULT_FONT
     bold: bool = False
@@ -335,7 +350,8 @@ class Style:
                 raise TypeError(msg)
 
     def __setattr__(self, name: str, value: Any) -> None:
-        """Detect changes to cell styles and flag the style for
+        """
+        Detect changes to cell styles and flag the style for
         possible updates when saving the document.
         """
         if name in ["bg_color", "font_color"]:
@@ -362,7 +378,7 @@ def rgb_color(color) -> RGB:
             msg = "RGB color must be an RGB or a tuple of 3 integers"
             raise TypeError(msg)
         return RGB(*color)
-    elif isinstance(color, list):
+    if isinstance(color, list):
         return [rgb_color(c) for c in color]
     msg = "RGB color must be an RGB or a tuple of 3 integers"
     raise TypeError(msg)
@@ -394,7 +410,8 @@ class BorderType(IntEnum):
 
 
 class Border:
-    """Create a cell border to use with the :py:class:`~numbers_parser.Table` method
+    """
+    Create a cell border to use with the :py:class:`~numbers_parser.Table` method
     :py:meth:`~numbers_parser.Table.set_cell_border`.
 
     .. code-block:: python
@@ -421,6 +438,7 @@ class Border:
     ------
     TypeError:
         If the width is not a float, or the border type is invalid.
+
     """
 
     def __init__(
@@ -481,62 +499,46 @@ class CellBorder:
 
     @property
     def top(self):
-        if self._top_merged:
-            return None
-        elif self._top is None:
+        if self._top_merged or self._top is None:
             return None
         return self._top
 
     @top.setter
-    def top(self, value):
-        if self._top is None:
-            self._top = value
-        elif value._order > self.top._order:
+    def top(self, value) -> None:
+        if self._top is None or value._order > self.top._order:
             self._top = value
 
     @property
     def right(self):
-        if self._right_merged:
-            return None
-        elif self._right is None:
+        if self._right_merged or self._right is None:
             return None
         return self._right
 
     @right.setter
-    def right(self, value):
-        if self._right is None:
-            self._right = value
-        elif value._order > self._right._order:
+    def right(self, value) -> None:
+        if self._right is None or value._order > self._right._order:
             self._right = value
 
     @property
     def bottom(self):
-        if self._bottom_merged:
-            return None
-        elif self._bottom is None:
+        if self._bottom_merged or self._bottom is None:
             return None
         return self._bottom
 
     @bottom.setter
-    def bottom(self, value):
-        if self._bottom is None:
-            self._bottom = value
-        elif value._order > self._bottom._order:
+    def bottom(self, value) -> None:
+        if self._bottom is None or value._order > self._bottom._order:
             self._bottom = value
 
     @property
     def left(self):
-        if self._left_merged:
-            return None
-        elif self._left is None:
+        if self._left_merged or self._left is None:
             return None
         return self._left
 
     @left.setter
-    def left(self, value):
-        if self._left is None:
-            self._left = value
-        elif value._order > self._left._order:
+    def left(self, value) -> None:
+        if self._left is None or value._order > self._left._order:
             self._left = value
 
 
@@ -550,7 +552,7 @@ class MergeReference:
 class MergeAnchor:
     """Cell reference for the merged cell."""
 
-    def __init__(self, size: Tuple) -> None:
+    def __init__(self, size: tuple) -> None:
         self.size = size
 
 
@@ -586,10 +588,11 @@ class CellStorageFlags:
 
 
 class Cell(CellStorageFlags, Cacheable):
-    """.. NOTE::
+    """
+    .. NOTE::
 
-          Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
-    """  # fmt: skip
+       Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
+    """
 
     def __init__(self, row: int, col: int, value) -> None:
         self._value = value
@@ -621,8 +624,7 @@ class Cell(CellStorageFlags, Cacheable):
         )
         if self.style is not None and self.style.bg_image is not None:
             return self.style.bg_image.filename
-        else:
-            return None
+        return None
 
     @property
     def image_data(self):
@@ -634,8 +636,7 @@ class Cell(CellStorageFlags, Cacheable):
         )
         if self.style is not None and self.style.bg_image is not None:
             return self.style.bg_image.data
-        else:
-            return None
+        return None
 
     @property
     def is_formula(self) -> bool:
@@ -646,7 +647,8 @@ class Cell(CellStorageFlags, Cacheable):
     @property
     @cache(num_args=0)
     def formula(self) -> str:
-        """str: The formula in a cell.
+        """
+        str: The formula in a cell.
 
         Formula evaluation relies on Numbers storing current values which should
         usually be the case. In cells containing a formula, :py:meth:`numbers_parser.Cell.value`
@@ -657,12 +659,12 @@ class Cell(CellStorageFlags, Cacheable):
             str:
                 The text of the foruma in a cell, or `None` if there is no formula
                 present in a cell.
+
         """
         if self._formula_id is not None:
             table_formulas = self._model.table_formulas(self._table_id)
             return table_formulas.formula(self._formula_id, self.row, self.col)
-        else:
-            return None
+        return None
 
     @property
     def is_bulleted(self) -> bool:
@@ -670,8 +672,9 @@ class Cell(CellStorageFlags, Cacheable):
         return self._is_bulleted
 
     @property
-    def bullets(self) -> Union[List[str], None]:
-        r"""List[str] | None: The bullets in a cell, or ``None``.
+    def bullets(self) -> list[str] | None:
+        r"""
+        List[str] | None: The bullets in a cell, or ``None``.
 
         Cells that contain bulleted or numbered lists are identified
         by :py:attr:`numbers_parser.Cell.is_bulleted`. For these cells,
@@ -694,12 +697,14 @@ class Cell(CellStorageFlags, Cacheable):
                 bullets = ["* " + s for s in table.cell(0, 1).bullets]
                 print("\n".join(bullets))
                     return None
+
         """
         return None
 
     @property
     def formatted_value(self) -> str:
-        """str: The formatted value of the cell as it appears in Numbers.
+        """
+        str: The formatted value of the cell as it appears in Numbers.
 
         Interactive elements are converted into a suitable text format where
         supported, or as their number values where there is no suitable
@@ -726,33 +731,34 @@ class Cell(CellStorageFlags, Cacheable):
         """
         if self._duration_format_id is not None and self._double is not None:
             return self._duration_format()
-        elif self._date_format_id is not None and self._seconds is not None:
+        if self._date_format_id is not None and self._seconds is not None:
             return self._date_format()
-        elif (
+        if (
             self._text_format_id is not None
             or self._num_format_id is not None
             or self._currency_format_id is not None
             or self._bool_format_id is not None
         ):
             return self._custom_format()
-        else:
-            return str(self.value)
+        return str(self.value)
 
     @property
-    def style(self) -> Union[Style, None]:
-        """Style | None: The :class:`Style` associated with the cell or ``None``.
+    def style(self) -> Style | None:
+        """
+        Style | None: The :class:`Style` associated with the cell or ``None``.
 
         Warns
         -----
             UnsupportedWarning: On assignment; use
                 :py:meth:`numbers_parser.Table.set_cell_style` instead.
+
         """
         if self._style is None:
             self._style = Style.from_storage(self, self._model)
         return self._style
 
     @style.setter
-    def style(self, _):
+    def style(self, _) -> None:
         warn(
             "cell style cannot be set; use Table.set_cell_style() instead",
             UnsupportedWarning,
@@ -760,19 +766,21 @@ class Cell(CellStorageFlags, Cacheable):
         )
 
     @property
-    def border(self) -> Union[CellBorder, None]:
-        """CellBorder| None: The :class:`CellBorder` associated with the cell or ``None``.
+    def border(self) -> CellBorder | None:
+        """
+        CellBorder| None: The :class:`CellBorder` associated with the cell or ``None``.
 
         Warns
         -----
             UnsupportedWarning: On assignment; use
                 :py:meth:`numbers_parser.Table.set_cell_border` instead.
+
         """
         self._model.extract_strokes(self._table_id)
         return self._border
 
     @border.setter
-    def border(self, _):
+    def border(self, _) -> None:
         warn(
             "cell border values cannot be set; use Table.set_cell_border() instead",
             UnsupportedWarning,
@@ -802,7 +810,7 @@ class Cell(CellStorageFlags, Cacheable):
         elif isinstance(value, int):
             cell = NumberCell(row, col, value)
         elif isinstance(value, float):
-            rounded_value = sigfig.round(value, sigfigs=MAX_SIGNIFICANT_DIGITS, warn=False)
+            rounded_value = sigfig(value, sigfigs=MAX_SIGNIFICANT_DIGITS, warn=False)
             if rounded_value != value:
                 warn(
                     f"'{value}' rounded to {MAX_SIGNIFICANT_DIGITS} significant digits",
@@ -810,17 +818,18 @@ class Cell(CellStorageFlags, Cacheable):
                     stacklevel=2,
                 )
             cell = NumberCell(row, col, rounded_value)
-        elif isinstance(value, (DateTime, builtin_datetime)):
-            cell = DateCell(row, col, pendulum_instance(value))
-        elif isinstance(value, (Duration, builtin_timedelta)):
+        elif isinstance(value, datetime):
+            cell = DateCell(row, col, value)
+        elif isinstance(value, timedelta):
             cell = DurationCell(row, col, value)
         else:
-            raise ValueError("Can't determine cell type from type " + type(value).__name__)
+            msg = "Can't determine cell type from type " + type(value).__name__
+            raise ValueError(msg)  # noqa: TRY004
 
         return cell
 
     @classmethod
-    def _from_storage(  # noqa: PLR0913, PLR0912
+    def _from_storage(  # noqa: PLR0912
         cls,
         table_id: int,
         row: int,
@@ -882,7 +891,6 @@ class Cell(CellStorageFlags, Cacheable):
             offset += 4
         # Skip unused flags
         offset += 4 * bin(flags & 0x900).count("1")
-        #
         if flags & 0x2000:
             storage_flags._num_format_id = unpack("<i", buffer[offset : offset + 4])[0]
             offset += 4
@@ -916,12 +924,12 @@ class Cell(CellStorageFlags, Cacheable):
         elif cell_type == TSTArchives.textCellType:
             cell = TextCell(row, col, model.table_string(table_id, storage_flags._string_id))
         elif cell_type == TSTArchives.dateCellType:
-            cell = DateCell(row, col, EPOCH + duration(seconds=seconds))
+            cell = DateCell(row, col, EPOCH + timedelta(seconds=seconds))
             cell._datetime = cell._value
         elif cell_type == TSTArchives.boolCellType:
             cell = BoolCell(row, col, double > 0.0)
         elif cell_type == TSTArchives.durationCellType:
-            cell = DurationCell(row, col, duration(seconds=double))
+            cell = DurationCell(row, col, timedelta(seconds=double))
         elif cell_type == TSTArchives.formulaErrorCellType:
             cell = ErrorCell(row, col)
         elif cell_type == TSTArchives.automaticCellType:
@@ -951,11 +959,11 @@ class Cell(CellStorageFlags, Cacheable):
 
         return cell
 
-    def _copy_flags(self, storage_flags: CellStorageFlags):
+    def _copy_flags(self, storage_flags: CellStorageFlags) -> None:
         for flag in storage_flags.flags():
             setattr(self, flag, getattr(storage_flags, flag))
 
-    def _set_merge(self, merge_ref):
+    def _set_merge(self, merge_ref) -> None:
         if isinstance(merge_ref, MergeAnchor):
             self.is_merged = True
             self.size = merge_ref.size
@@ -1024,7 +1032,11 @@ class Cell(CellStorageFlags, Cacheable):
             flags = 4
             length += 8
             cell_type = TSTArchives.dateCellType
-            date_delta = self._value.astimezone() - EPOCH
+            # date_delta = self._value.astimezone() - EPOCH
+            if self._value.tzinfo is None:
+                date_delta = self._value - EPOCH
+            else:
+                date_delta = self._value - EPOCH.astimezone(self._value.tzinfo)
             value = pack("<d", float(date_delta.total_seconds()))
         elif isinstance(self, BoolCell):
             flags = 2
@@ -1135,7 +1147,7 @@ class Cell(CellStorageFlags, Cacheable):
 
     @property
     @cache(num_args=0)
-    def _image_data(self) -> Tuple[bytes, str]:
+    def _image_data(self) -> tuple[bytes, str]:
         """Return the background image data for a cell or None if no image."""
         if self._cell_style_id is None:
             return None
@@ -1161,30 +1173,34 @@ class Cell(CellStorageFlags, Cacheable):
                 stacklevel=3,
             )
             return None
-        else:
-            image_data = self._model.objects.file_store[image_pathnames[0]]
-            digest = sha1(image_data).digest()
-            if digest not in self._model._images:
-                self._model._images[digest] = image_id
+        image_data = self._model.objects.file_store[image_pathnames[0]]
+        digest = sha1(image_data).digest()  # noqa: S324
+        if digest not in self._model._images:
+            self._model._images[digest] = image_id
 
-            return (image_data, preferred_filename)
+        return (image_data, preferred_filename)
 
     def _custom_format(self) -> str:  # noqa: PLR0911
         if self._text_format_id is not None and self._type == CellType.TEXT:
-            format = self._model.table_format(self._table_id, self._text_format_id)
+            custom_format = self._model.table_format(self._table_id, self._text_format_id)
         elif self._currency_format_id is not None:
-            format = self._model.table_format(self._table_id, self._currency_format_id)
+            custom_format = self._model.table_format(self._table_id, self._currency_format_id)
         elif self._bool_format_id is not None and self._type == CellType.BOOL:
-            format = self._model.table_format(self._table_id, self._bool_format_id)
+            custom_format = self._model.table_format(self._table_id, self._bool_format_id)
         elif self._num_format_id is not None:
-            format = self._model.table_format(self._table_id, self._num_format_id)
+            custom_format = self._model.table_format(self._table_id, self._num_format_id)
         else:
             return str(self.value)
 
-        debug("custom_format: @[%d,%d]: format_type=%s, ", self.row, self.col, format.format_type)
+        debug(
+            "custom_format: @[%d,%d]: format_type=%s, ",
+            self.row,
+            self.col,
+            custom_format.format_type,
+        )
 
-        if format.HasField("custom_uid"):
-            format_uuid = NumbersUUID(format.custom_uid).hex
+        if custom_format.HasField("custom_uid"):
+            format_uuid = NumbersUUID(custom_format.custom_uid).hex
             format_map = self._model.custom_format_map()
             custom_format = format_map[format_uuid].default_format
             if custom_format.requires_fraction_replacement:
@@ -1200,32 +1216,32 @@ class Cell(CellStorageFlags, Cacheable):
                     self._d128,
                     format_map[format_uuid].name,
                 )
-        elif format.format_type == FormatType.DECIMAL:
-            return _format_decimal(self._d128, format)
-        elif format.format_type == FormatType.CURRENCY:
-            return _format_currency(self._d128, format)
-        elif format.format_type == FormatType.BOOLEAN:
+        elif custom_format.format_type == FormatType.DECIMAL:
+            return _format_decimal(self._d128, custom_format)
+        elif custom_format.format_type == FormatType.CURRENCY:
+            return _format_currency(self._d128, custom_format)
+        elif custom_format.format_type == FormatType.BOOLEAN:
             return "TRUE" if self.value else "FALSE"
-        elif format.format_type == FormatType.PERCENT:
-            return _format_decimal(self._d128 * 100, format, percent=True)
-        elif format.format_type == FormatType.BASE:
-            return _format_base(self._d128, format)
-        elif format.format_type == FormatType.FRACTION:
-            return _format_fraction(self._d128, format)
-        elif format.format_type == FormatType.SCIENTIFIC:
-            return _format_scientific(self._d128, format)
-        elif format.format_type == FormatType.CHECKBOX:
+        elif custom_format.format_type == FormatType.PERCENT:
+            return _format_decimal(self._d128 * 100, custom_format, percent=True)
+        elif custom_format.format_type == FormatType.BASE:
+            return _format_base(self._d128, custom_format)
+        elif custom_format.format_type == FormatType.FRACTION:
+            return _format_fraction(self._d128, custom_format)
+        elif custom_format.format_type == FormatType.SCIENTIFIC:
+            return _format_scientific(self._d128, custom_format)
+        elif custom_format.format_type == FormatType.CHECKBOX:
             return CHECKBOX_TRUE_VALUE if self.value else CHECKBOX_FALSE_VALUE
-        elif format.format_type == FormatType.RATING:
+        elif custom_format.format_type == FormatType.RATING:
             return STAR_RATING_VALUE * int(self._d128)
         else:
             formatted_value = str(self.value)
         return formatted_value
 
     def _date_format(self) -> str:
-        format = self._model.table_format(self._table_id, self._date_format_id)
-        if format.HasField("custom_uid"):
-            format_uuid = NumbersUUID(format.custom_uid).hex
+        date_format = self._model.table_format(self._table_id, self._date_format_id)
+        if date_format.HasField("custom_uid"):
+            format_uuid = NumbersUUID(date_format.custom_uid).hex
             format_map = self._model.custom_format_map()
             custom_format = format_map[format_uuid].default_format
             custom_format_string = custom_format.custom_format_string
@@ -1239,25 +1255,25 @@ class Cell(CellStorageFlags, Cacheable):
                 )
                 return ""
         else:
-            formatted_value = _decode_date_format(format.date_time_format, self._datetime)
+            formatted_value = _decode_date_format(date_format.date_time_format, self._datetime)
         return formatted_value
 
     def _duration_format(self) -> str:
-        format = self._model.table_format(self._table_id, self._duration_format_id)
+        duration_format = self._model.table_format(self._table_id, self._duration_format_id)
         debug(
             "duration_format: @[%d,%d]: table_id=%d, duration_format_id=%d, duration_style=%s",
             self.row,
             self.col,
             self._table_id,
             self._duration_format_id,
-            format.duration_style,
+            duration_format.duration_style,
         )
 
-        duration_style = format.duration_style
-        unit_largest = format.duration_unit_largest
-        unit_smallest = format.duration_unit_smallest
-        if format.use_automatic_duration_units:
-            unit_smallest, unit_largest = _auto_units(self._double, format)
+        duration_style = duration_format.duration_style
+        unit_largest = duration_format.duration_unit_largest
+        unit_smallest = duration_format.duration_unit_smallest
+        if duration_format.use_automatic_duration_units:
+            unit_smallest, unit_largest = _auto_units(self._double, duration_format)
 
         d = self._double
         dd = int(self._double)
@@ -1324,8 +1340,8 @@ class Cell(CellStorageFlags, Cacheable):
     def _set_formatting(
         self,
         format_id: int,
-        format_type: Union[FormattingType, CustomFormattingType],
-        control_id: Optional[int] = None,
+        format_type: FormattingType | CustomFormattingType,
+        control_id: int | None = None,
         is_currency: bool = False,
     ) -> None:
         self._is_currency = is_currency
@@ -1357,10 +1373,11 @@ class Cell(CellStorageFlags, Cacheable):
 
 
 class NumberCell(Cell):
-    """.. NOTE::
+    """
+    .. NOTE::
 
-          Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
-    """  # fmt: skip
+       Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
+    """
 
     def __init__(self, row: int, col: int, value: float, cell_type=CellType.NUMBER) -> None:
         self._type = cell_type
@@ -1382,10 +1399,11 @@ class TextCell(Cell):
 
 
 class RichTextCell(Cell):
-    """.. NOTE::
+    """
+    .. NOTE::
 
-          Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
-    """  # fmt: skip
+       Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
+    """
 
     def __init__(self, row: int, col: int, value) -> None:
         super().__init__(row, col, value["text"])
@@ -1408,7 +1426,7 @@ class RichTextCell(Cell):
         return self._value
 
     @property
-    def bullets(self) -> List[str]:
+    def bullets(self) -> list[str]:
         """List[str]: A list of the text bullets in the cell."""
         return self._bullets
 
@@ -1418,8 +1436,9 @@ class RichTextCell(Cell):
         return self._formatted_bullets
 
     @property
-    def hyperlinks(self) -> Union[List[Tuple], None]:
-        """List[Tuple] | None: the hyperlinks in a cell or ``None``.
+    def hyperlinks(self) -> list[tuple] | None:
+        """
+        List[Tuple] | None: the hyperlinks in a cell or ``None``.
 
         Numbers does not support hyperlinks to cells within a spreadsheet, but does
         allow embedding links in cells. When cells contain hyperlinks,
@@ -1433,6 +1452,7 @@ class RichTextCell(Cell):
 
             cell = table.cell(0, 0)
             (text, url) = cell.hyperlinks[0]
+
         """
         return self._hyperlinks
 
@@ -1443,29 +1463,31 @@ class BulletedTextCell(RichTextCell):
 
 
 class EmptyCell(Cell):
-    """.. NOTE::
+    """
+    .. NOTE::
 
-          Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
-    """  # fmt: skip
+       Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
+    """
 
     def __init__(self, row: int, col: int) -> None:
         super().__init__(row, col, None)
         self._type = CellType.EMPTY
 
     @property
-    def value(self):
+    def value(self) -> None:
         return None
 
     @property
-    def formatted_value(self):
+    def formatted_value(self) -> str:
         return ""
 
 
 class BoolCell(Cell):
-    """.. NOTE::
+    """
+    .. NOTE::
 
-          Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
-    """  # fmt: skip
+       Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
+    """
 
     def __init__(self, row: int, col: int, value: bool) -> None:
         super().__init__(row, col, value)
@@ -1478,12 +1500,13 @@ class BoolCell(Cell):
 
 
 class DateCell(Cell):
-    """.. NOTE::
+    """
+    .. NOTE::
 
-          Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
-    """  # fmt: skip
+       Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
+    """
 
-    def __init__(self, row: int, col: int, value: DateTime) -> None:
+    def __init__(self, row: int, col: int, value: datetime) -> None:
         super().__init__(row, col, value)
         self._type = CellType.DATE
 
@@ -1493,42 +1516,44 @@ class DateCell(Cell):
 
 
 class DurationCell(Cell):
-    def __init__(self, row: int, col: int, value: Duration) -> None:
+    def __init__(self, row: int, col: int, value: timedelta) -> None:
         super().__init__(row, col, value)
         self._type = CellType.DURATION
 
     @property
-    def value(self) -> duration:
+    def value(self) -> timedelta:
         return self._value
 
 
 class ErrorCell(Cell):
-    """.. NOTE::
+    """
+    .. NOTE::
 
-          Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
-    """  # fmt: skip
+       Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
+    """
 
     def __init__(self, row: int, col: int) -> None:
         super().__init__(row, col, None)
         self._type = CellType.ERROR
 
     @property
-    def value(self):
+    def value(self) -> None:
         return None
 
 
 class MergedCell(Cell):
-    """.. NOTE::
+    """
+    .. NOTE::
 
-          Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
-    """  # fmt: skip
+       Do not instantiate directly. Cells are created by :py:class:`~numbers_parser.Document`.
+    """
 
     def __init__(self, row: int, col: int) -> None:
         super().__init__(row, col, None)
         self._type = CellType.MERGED
 
     @property
-    def value(self):
+    def value(self) -> None:
         return None
 
 
@@ -1566,16 +1591,14 @@ def _decode_date_format_field(field: str, value: datetime) -> str:
         s = DATETIME_FIELD_MAP[field]
         if callable(s):
             return s(value)
-        else:
-            return value.strftime(s)
-    else:
-        warn(f"Unsupported field code '{field}'", UnsupportedWarning, stacklevel=4)
-        return ""
+        return value.strftime(s)
+    warn(f"Unsupported field code '{field}'", UnsupportedWarning, stacklevel=4)
+    return ""
 
 
-def _decode_date_format(format, value):
+def _decode_date_format(date_format, value):
     """Parse a custom date format string and return a formatted datetime value."""
-    chars = [*format]
+    chars = [*date_format]
     index = 0
     in_string = False
     in_field = False
@@ -1587,7 +1610,7 @@ def _decode_date_format(format, value):
         if current_char == "'":
             if next_char is None:
                 break
-            elif chars[index + 1] == "'":
+            if chars[index + 1] == "'":
                 result += "'"
                 index += 2
             elif in_string:
@@ -1621,9 +1644,9 @@ def _decode_date_format(format, value):
     return result
 
 
-def _decode_text_format(format, value: str):
+def _decode_text_format(text_format, value: str):
     """Parse a custom date format string and return a formatted number value."""
-    custom_format_string = format.custom_format_string
+    custom_format_string = text_format.custom_format_string
     return custom_format_string.replace(CUSTOM_TEXT_PLACEHOLDER, value)
 
 
@@ -1638,7 +1661,7 @@ def _expand_quotes(value: str) -> str:
         if current_char == "'":
             if next_char is None:
                 break
-            elif chars[index + 1] == "'":
+            if chars[index + 1] == "'":
                 formatted_value += "'"
                 index += 2
             elif in_string:
@@ -1653,19 +1676,19 @@ def _expand_quotes(value: str) -> str:
     return formatted_value
 
 
-def _decode_number_format(format, value, name):  # noqa: PLR0912
+def _decode_number_format(number_format, value, name):  # noqa: PLR0912
     """Parse a custom date format string and return a formatted number value."""
-    custom_format_string = format.custom_format_string
-    value *= format.scale_factor
-    if "%" in custom_format_string and format.scale_factor == 1.0:
+    custom_format_string = number_format.custom_format_string
+    value *= number_format.scale_factor
+    if "%" in custom_format_string and number_format.scale_factor == 1.0:
         # Per cent scale has 100x but % does not
         value *= 100.0
 
-    if format.currency_code != "":
+    if number_format.currency_code != "":
         # Replace currency code with symbol and no-break space
         custom_format_string = custom_format_string.replace(
             "\u00a4",
-            format.currency_code + "\u00a0",
+            number_format.currency_code + "\u00a0",
         )
 
     if (match := re.search(r"([#0.,]+(E[+]\d+)?)", custom_format_string)) is None:
@@ -1695,7 +1718,7 @@ def _decode_number_format(format, value, name):  # noqa: PLR0912
     if num_decimals > 0:
         if dec_part[0] == "#":
             dec_pad = None
-        elif format.num_nonspace_decimal_digits > 0:
+        elif number_format.num_nonspace_decimal_digits > 0:
             dec_pad = CellPadding.ZERO
         else:
             dec_pad = CellPadding.SPACE
@@ -1712,15 +1735,15 @@ def _decode_number_format(format, value, name):  # noqa: PLR0912
         decimal = float(f"0.{decimal}")
 
     num_integers = len(int_part.replace(",", ""))
-    if not format.show_thousands_separator:
+    if not number_format.show_thousands_separator:
         int_part = int_part.replace(",", "")
     if num_integers > 0:
         if int_part[0] == "#":
             int_pad = None
             int_width = len(int_part)
-        elif format.num_nonspace_integer_digits > 0:
+        elif number_format.num_nonspace_integer_digits > 0:
             int_pad = CellPadding.ZERO
-            if format.show_thousands_separator:
+            if number_format.show_thousands_separator:
                 num_commas = int(math.floor(math.log10(integer)) / 3) if integer != 0 else 0
                 num_commas = max([num_commas, int((num_integers - 1) / 3)])
                 int_width = num_integers + num_commas
@@ -1734,7 +1757,7 @@ def _decode_number_format(format, value, name):  # noqa: PLR0912
         int_width = num_integers
 
     # value_1 = str(value).split(".")[0]
-    # value_2 = sigfig.round(str(value).split(".")[1], sigfig=MAX_SIGNIFICANT_DIGITS, warn=False)
+    # value_2 = sigfig(str(value).split(".")[1], sigfig=MAX_SIGNIFICANT_DIGITS, warn=False)
     # int_pad_space_as_zero = (
     #     num_integers > 0
     #     and num_decimals > 0
@@ -1756,26 +1779,29 @@ def _decode_number_format(format, value, name):  # noqa: PLR0912
         formatted_value = "".rjust(int_width)
     elif integer == 0 and int_pad is None and dec_pad == CellPadding.SPACE:
         formatted_value = ""
-    elif integer == 0 and int_pad == CellPadding.SPACE and dec_pad is not None:
-        formatted_value = "".rjust(int_width)
     elif (
         integer == 0
         and int_pad == CellPadding.SPACE
-        and dec_pad is None
-        and len(str(decimal)) > num_decimals
+        and dec_pad is not None
+        or (
+            integer == 0
+            and int_pad == CellPadding.SPACE
+            and dec_pad is None
+            and len(str(decimal)) > num_decimals
+        )
     ):
         formatted_value = "".rjust(int_width)
     elif int_pad_space_as_zero or int_pad == CellPadding.ZERO:
-        if format.show_thousands_separator:
+        if number_format.show_thousands_separator:
             formatted_value = f"{integer:0{int_width},}"
         else:
             formatted_value = f"{integer:0{int_width}}"
     elif int_pad == CellPadding.SPACE:
-        if format.show_thousands_separator:
+        if number_format.show_thousands_separator:
             formatted_value = f"{integer:,}".rjust(int_width)
         else:
             formatted_value = str(integer).rjust(int_width)
-    elif format.show_thousands_separator:
+    elif number_format.show_thousands_separator:
         formatted_value = f"{integer:,}"
     else:
         formatted_value = str(integer)
@@ -1795,33 +1821,33 @@ def _decode_number_format(format, value, name):  # noqa: PLR0912
     return _expand_quotes(formatted_value)
 
 
-def _format_decimal(value: float, format, percent: bool = False) -> str:
+def _format_decimal(value: float, number_format, percent: bool = False) -> str:
     if value is None:
         return ""
-    if value < 0 and format.negative_style == 1:
+    if value < 0 and number_format.negative_style == 1:
         accounting_style = False
         value = -value
-    elif value < 0 and format.negative_style >= 2:
+    elif value < 0 and number_format.negative_style >= 2:
         accounting_style = True
         value = -value
     else:
         accounting_style = False
-    thousands = "," if format.show_thousands_separator else ""
+    thousands = "," if number_format.show_thousands_separator else ""
 
-    if value.is_integer() and format.decimal_places >= DECIMAL_PLACES_AUTO:
+    if value.is_integer() and number_format.decimal_places >= DECIMAL_PLACES_AUTO:
         formatted_value = f"{int(value):{thousands}}"
     else:
-        if format.decimal_places >= DECIMAL_PLACES_AUTO:
-            formatted_value = str(sigfig.round(value, MAX_SIGNIFICANT_DIGITS, warn=False))
+        if number_format.decimal_places >= DECIMAL_PLACES_AUTO:
+            formatted_value = str(sigfig(value, MAX_SIGNIFICANT_DIGITS, warn=False))
         else:
-            formatted_value = sigfig.round(value, MAX_SIGNIFICANT_DIGITS, type=str, warn=False)
-            formatted_value = sigfig.round(
+            formatted_value = sigfig(value, MAX_SIGNIFICANT_DIGITS, type=str, warn=False)
+            formatted_value = sigfig(
                 formatted_value,
-                decimals=format.decimal_places,
+                decimals=number_format.decimal_places,
                 type=str,
             )
-        if format.show_thousands_separator:
-            formatted_value = sigfig.round(formatted_value, spacer=",", spacing=3, type=str)
+        if number_format.show_thousands_separator:
+            formatted_value = sigfig(formatted_value, spacer=",", spacing=3, type=str)
             try:
                 (integer, decimal) = formatted_value.split(".")
                 formatted_value = integer + "." + decimal.replace(",", "")
@@ -1833,22 +1859,20 @@ def _format_decimal(value: float, format, percent: bool = False) -> str:
 
     if accounting_style:
         return f"({formatted_value})"
-    else:
-        return formatted_value
+    return formatted_value
 
 
-def _format_currency(value: float, format) -> str:
-    formatted_value = _format_decimal(value, format)
-    if format.currency_code in CURRENCY_SYMBOLS:
-        symbol = CURRENCY_SYMBOLS[format.currency_code]
+def _format_currency(value: float, number_format) -> str:
+    formatted_value = _format_decimal(value, number_format)
+    if number_format.currency_code in CURRENCY_SYMBOLS:
+        symbol = CURRENCY_SYMBOLS[number_format.currency_code]
     else:
-        symbol = format.currency_code + " "
-    if format.use_accounting_style and value < 0:
+        symbol = number_format.currency_code + " "
+    if number_format.use_accounting_style and value < 0:
         return f"{symbol}\t({formatted_value[1:]})"
-    elif format.use_accounting_style:
+    if number_format.use_accounting_style:
         return f"{symbol}\t{formatted_value}"
-    else:
-        return symbol + formatted_value
+    return symbol + formatted_value
 
 
 INT_TO_BASE_CHAR = [str(x) for x in range(10)] + [chr(x) for x in range(ord("A"), ord("Z") + 1)]
@@ -1868,49 +1892,45 @@ def _twos_complement(value: int, base: int) -> str:
 
     if base == 2:
         return bin(twos_complement_dec)[2:].rjust(num_bits, "1")
-    elif base == 8:
+    if base == 8:
         return oct(twos_complement_dec)[2:]
-    else:
-        return hex(twos_complement_dec)[2:].upper()
+    return hex(twos_complement_dec)[2:].upper()
 
 
-def _format_base(value: float, format) -> str:
+def _format_base(value: float, number_format) -> str:
     if value == 0:
-        return "0".zfill(format.base_places)
+        return "0".zfill(number_format.base_places)
 
     value = round(value)
 
     is_negative = False
-    if not format.base_use_minus_sign and format.base in [2, 8, 16]:
+    if not number_format.base_use_minus_sign and number_format.base in [2, 8, 16]:
         if value < 0:
-            return _twos_complement(value, format.base)
-        else:
-            value = abs(value)
+            return _twos_complement(value, number_format.base)
+        value = abs(value)
     elif value < 0:
         is_negative = True
         value = abs(value)
 
     formatted_value = []
     while value:
-        formatted_value.append(int(value % format.base))
-        value //= format.base
+        formatted_value.append(int(value % number_format.base))
+        value //= number_format.base
     formatted_value = "".join([INT_TO_BASE_CHAR[x] for x in formatted_value[::-1]])
 
     if is_negative:
-        return "-" + formatted_value.zfill(format.base_places)
-    else:
-        return formatted_value.zfill(format.base_places)
+        return "-" + formatted_value.zfill(number_format.base_places)
+    return formatted_value.zfill(number_format.base_places)
 
 
 def _format_fraction_parts_to(whole: int, numerator: int, denominator: int):
     if whole > 0:
         if numerator == 0:
             return str(whole)
-        else:
-            return f"{whole} {numerator}/{denominator}"
-    elif numerator == 0:
+        return f"{whole} {numerator}/{denominator}"
+    if numerator == 0:
         return "0"
-    elif numerator == denominator:
+    if numerator == denominator:
         return "1"
     return f"{numerator}/{denominator}"
 
@@ -1923,7 +1943,8 @@ def _float_to_fraction(value: float, denominator: int) -> str:
 
 
 def _float_to_n_digit_fraction(value: float, max_digits: int) -> str:
-    """Convert a float to a fraction of a maxinum number of digits
+    """
+    Convert a float to a fraction of a maxinum number of digits
     and return as a string.
     """
     max_denominator = 10**max_digits - 1
@@ -1935,35 +1956,33 @@ def _float_to_n_digit_fraction(value: float, max_digits: int) -> str:
     return _format_fraction_parts_to(whole, numerator, denominator)
 
 
-def _format_fraction(value: float, format) -> str:
-    accuracy = format.fraction_accuracy
+def _format_fraction(value: float, number_format) -> str:
+    accuracy = number_format.fraction_accuracy
     if accuracy & 0xFF000000:
         num_digits = 0x100000000 - accuracy
         return _float_to_n_digit_fraction(value, num_digits)
-    else:
-        return _float_to_fraction(value, accuracy)
+    return _float_to_fraction(value, accuracy)
 
 
-def _format_scientific(value: float, format) -> str:
-    formatted_value = sigfig.round(value, sigfigs=MAX_SIGNIFICANT_DIGITS, warn=False)
-    return f"{formatted_value:.{format.decimal_places}E}"
+def _format_scientific(value: float, number_format) -> str:
+    formatted_value = sigfig(value, sigfigs=MAX_SIGNIFICANT_DIGITS, warn=False)
+    return f"{formatted_value:.{number_format.decimal_places}E}"
 
 
-def _unit_format(unit: str, value: int, style: int, abbrev: Optional[str] = None):
+def _unit_format(unit: str, value: int, style: int, abbrev: str | None = None):
     plural = "" if value == 1 else "s"
     if abbrev is None:
         abbrev = unit[0]
     if style == DurationStyle.COMPACT:
         return ""
-    elif style == DurationStyle.SHORT:
+    if style == DurationStyle.SHORT:
         return f"{abbrev}"
-    else:
-        return f" {unit}" + plural
+    return f" {unit}" + plural
 
 
-def _auto_units(cell_value, format):
-    unit_largest = format.duration_unit_largest
-    unit_smallest = format.duration_unit_smallest
+def _auto_units(cell_value, number_format):
+    unit_largest = number_format.duration_unit_largest
+    unit_smallest = number_format.duration_unit_smallest
 
     if cell_value == 0:
         unit_largest = DurationUnits.DAY
@@ -1992,8 +2011,7 @@ def _auto_units(cell_value, format):
             unit_smallest = DurationUnits.HOUR
         elif cell_value % SECONDS_IN_WEEK:
             unit_smallest = DurationUnits.DAY
-        if unit_smallest < unit_largest:
-            unit_smallest = unit_largest
+        unit_smallest = max(unit_smallest, unit_largest)
 
     return unit_smallest, unit_largest
 
@@ -2004,7 +2022,8 @@ range_parts = re.compile(r"(\$?)([A-Z]{1,3})(\$?)(\d+)")
 
 
 def xl_cell_to_rowcol(cell_str: str) -> tuple:
-    """Convert a cell reference in A1 notation to a zero indexed row and column.
+    """
+    Convert a cell reference in A1 notation to a zero indexed row and column.
 
     Parameters
     ----------
@@ -2015,6 +2034,7 @@ def xl_cell_to_rowcol(cell_str: str) -> tuple:
     -------
     row, col: int, int
         Cell row and column numbers (zero indexed).
+
     """
     if not cell_str:
         return 0, 0
@@ -2028,11 +2048,9 @@ def xl_cell_to_rowcol(cell_str: str) -> tuple:
     row_str = match.group(4)
 
     # Convert base26 column string to number.
-    expn = 0
     col = 0
-    for char in reversed(col_str):
+    for expn, char in enumerate(reversed(col_str)):
         col += (ord(char) - ord("A") + 1) * (26**expn)
-        expn += 1
 
     # Convert 1-index to zero-index
     row = int(row_str) - 1
@@ -2042,7 +2060,8 @@ def xl_cell_to_rowcol(cell_str: str) -> tuple:
 
 
 def xl_range(first_row, first_col, last_row, last_col):
-    """Convert zero indexed row and col cell references to a A1:B1 range string.
+    """
+    Convert zero indexed row and col cell references to a A1:B1 range string.
 
     Parameters
     ----------
@@ -2059,18 +2078,19 @@ def xl_range(first_row, first_col, last_row, last_col):
     -------
     str:
         A1:B1 style range string.
+
     """
     range1 = xl_rowcol_to_cell(first_row, first_col)
     range2 = xl_rowcol_to_cell(last_row, last_col)
 
     if range1 == range2:
         return range1
-    else:
-        return range1 + ":" + range2
+    return range1 + ":" + range2
 
 
 def xl_rowcol_to_cell(row, col, row_abs=False, col_abs=False):
-    """Convert a zero indexed row and column cell reference to a A1 style string.
+    """
+    Convert a zero indexed row and column cell reference to a A1 style string.
 
     Parameters
     ----------
@@ -2087,6 +2107,7 @@ def xl_rowcol_to_cell(row, col, row_abs=False, col_abs=False):
     -------
     str:
         A1 style string.
+
     """
     if row < 0:
         msg = f"row reference {row} below zero"
@@ -2105,7 +2126,8 @@ def xl_rowcol_to_cell(row, col, row_abs=False, col_abs=False):
 
 
 def xl_col_to_name(col, col_abs=False):
-    """Convert a zero indexed column cell reference to a string.
+    """
+    Convert a zero indexed column cell reference to a string.
 
     Parameters
     ----------
@@ -2118,6 +2140,7 @@ def xl_col_to_name(col, col_abs=False):
     -------
         str:
             Column in A1 notation.
+
     """
     if col < 0:
         msg = f"column reference {col} below zero"
@@ -2160,7 +2183,7 @@ class Formatting:
     increment: float = 1.0
     maximum: float = 100.0
     minimum: float = 1.0
-    popup_values: List[str] = field(default_factory=lambda: ["Item 1"])
+    popup_values: list[str] = field(default_factory=lambda: ["Item 1"])
     negative_style: NegativeNumberStyle = NegativeNumberStyle.MINUS
     show_thousands_separator: bool = False
     type: FormattingType = FormattingType.NUMBER
@@ -2188,7 +2211,8 @@ class Formatting:
                     raise TypeError(msg)
 
         if self.type == FormattingType.CURRENCY and self.currency_code not in CURRENCIES:
-            raise TypeError(f"Unsupported currency code '{self.currency_code}'")
+            msg = f"Unsupported currency code '{self.currency_code}'"
+            raise TypeError(msg)
 
         if self.decimal_places is None:
             if self.type == FormattingType.CURRENCY:
@@ -2227,7 +2251,8 @@ class CustomFormatting:
             raise TypeError(msg)
 
         if self.type == CustomFormattingType.TEXT and self.format.count("%s") > 1:
-            raise TypeError("Custom formats only allow one text substitution")
+            msg = "Custom formats only allow one text substitution"
+            raise TypeError(msg)
 
     @classmethod
     def from_archive(cls, archive: object):