numbers-parser 4.4.6__py3-none-any.whl → 4.4.8__py3-none-any.whl

numbers_parser/__init__.py

@@ -23,9 +23,9 @@ import os
 import plistlib
 import warnings
 
-from numbers_parser.document import Document  # NOQA
-from numbers_parser.cell import *  # NOQA
-from numbers_parser.exceptions import *  # NOQA
+from numbers_parser.cell import *
+from numbers_parser.document import Document
+from numbers_parser.exceptions import *
 
 __version__ = importlib.metadata.version("numbers-parser")
 
@@ -53,12 +53,14 @@ def _get_version():
 def _check_installed_numbers_version():
     try:
         fp = open(os.path.join(_DEFAULT_NUMBERS_INSTALL_PATH, _VERSION_PLIST_PATH), "rb")
-    except IOError:
+    except OSError:
         return None
     version_dict = plistlib.load(fp)
     installed_version = version_dict["CFBundleShortVersionString"]
     if installed_version not in _SUPPORTED_NUMBERS_VERSIONS:
-        warnings.warn(f"Numbers version {installed_version} not tested with this version")
+        warnings.warn(
+            f"Numbers version {installed_version} not tested with this version", stacklevel=2
+        )
     fp.close()
     return installed_version
 

numbers_parser/_cat_numbers.py

@@ -5,9 +5,8 @@ import sys
 
 import sigfig
 
-from numbers_parser import Document, ErrorCell, FileFormatError, NumberCell, FileError
+from numbers_parser import Document, ErrorCell, FileError, FileFormatError, NumberCell, _get_version
 from numbers_parser import __name__ as numbers_parser_name
-from numbers_parser import _get_version
 from numbers_parser.constants import MAX_SIGNIFICANT_DIGITS
 from numbers_parser.experimental import _enable_experimental_features
 

numbers_parser/_unpack_numbers.py

@@ -1,33 +1,31 @@
-import os
+import contextlib
 import json
 import logging
-import regex
+import os
 import sys
-
-from array import array
 from argparse import ArgumentParser
+from array import array
 from base64 import b64decode
 from binascii import hexlify
+
+import regex
 from compact_json import Formatter
 
-from numbers_parser.file import read_numbers_file
-from numbers_parser import _get_version
 from numbers_parser import __name__ as numbers_parser_name
+from numbers_parser import _get_version
+from numbers_parser.exceptions import FileError, FileFormatError, UnsupportedError
+from numbers_parser.file import read_numbers_file
 from numbers_parser.iwafile import IWAFile
-from numbers_parser.exceptions import FileFormatError, UnsupportedError, FileError
 from numbers_parser.numbers_uuid import NumbersUUID
 
-
 logger = logging.getLogger(numbers_parser_name)
 
 
 def ensure_directory_exists(prefix, path):
     """Ensure that a path's directory exists."""
     parts = os.path.split(path)
-    try:
+    with contextlib.suppress(OSError):
         os.makedirs(os.path.join(*([prefix] + list(parts[:-1]))))
-    except OSError:
-        pass
 
 
 def prettify_uuids(obj):
@@ -54,18 +52,18 @@ def prettify_uuids(obj):
 def prettify_cell_storage(obj):
     if isinstance(obj, dict):
         for k, v in obj.items():
-            if isinstance(v, dict) or isinstance(v, list):
+            if isinstance(v, (dict, list)):
                 prettify_cell_storage(v)
-            elif k == "cell_storage_buffer" or k == "cell_storage_buffer_pre_bnc":
+            elif k in ["cell_storage_buffer", "cell_storage_buffer_pre_bnc"]:
                 obj[k] = str(hexlify(b64decode(obj[k]), sep=":"))
                 obj[k] = obj[k].replace("b'", "").replace("'", "")
-            elif k == "cell_offsets" or k == "cell_offsets_pre_bnc":
+            elif k in ["cell_offsets", k == "cell_offsets_pre_bnc"]:
                 offsets = array("h", b64decode(obj[k])).tolist()
                 obj[k] = ",".join([str(x) for x in offsets])
                 obj[k] = regex.sub(r"(?:,-1)+$", ",[...]", obj[k])
     else:  # list
         for v in obj:
-            if isinstance(v, dict) or isinstance(v, list):
+            if isinstance(v, (dict, list)):
                 prettify_cell_storage(v)
 
 
@@ -137,7 +135,7 @@ def main():
             try:
                 read_numbers_file(
                     document,
-                    file_handler=lambda filename, blob: process_file(
+                    file_handler=lambda filename, blob, output_dir=output_dir: process_file(
                         filename, blob, output_dir, args
                     ),
                 )

numbers_parser/bullets.py

@@ -1,6 +1,6 @@
 from roman import toRoman
-from numbers_parser.generated.TSWPArchives_pb2 import ListStyleArchive
 
+from numbers_parser.generated.TSWPArchives_pb2 import ListStyleArchive
 
 BULLET_PREFIXES = {
     ListStyleArchive.kNumericDecimal: "",

numbers_parser/cell.py

@@ -29,7 +29,7 @@ from numbers_parser.generated import TSTArchives_pb2 as TSTArchives
 from numbers_parser.generated.TSWPArchives_pb2 import (
     ParagraphStylePropertiesArchive as ParagraphStyle,
 )
-from numbers_parser.numbers_cache import cache, Cacheable
+from numbers_parser.numbers_cache import Cacheable, cache
 
 __all__ = [
     "Alignment",
@@ -122,8 +122,7 @@ class Alignment(_Alignment):
                 raise TypeError("invalid vertical alignment")
             vertical = VERTICAL_MAP[vertical]
 
-        self = super(_Alignment, cls).__new__(cls, (horizontal, vertical))
-        return self
+        return super(_Alignment, cls).__new__(cls, (horizontal, vertical))
 
 
 DEFAULT_ALIGNMENT_CLASS = Alignment(*DEFAULT_ALIGNMENT)
@@ -186,13 +185,11 @@ class Style:
 
     @classmethod
     def from_storage(cls, cell_storage: object, model: object):
-        style = Style()
-
         if cell_storage.image_data is not None:
             bg_image = BackgroundImage(*cell_storage.image_data)
         else:
             bg_image = None
-        style = Style(
+        return Style(
             alignment=model.cell_alignment(cell_storage),
             bg_image=bg_image,
             bg_color=model.cell_bg_color(cell_storage),
@@ -212,7 +209,6 @@ class Style:
             _text_style_obj_id=model.text_style_object_id(cell_storage),
             _cell_style_obj_id=model.cell_style_object_id(cell_storage),
         )
-        return style
 
     def __post_init__(self):
         self.bg_color = rgb_color(self.bg_color)
@@ -229,7 +225,8 @@ class Style:
 
     def __setattr__(self, name: str, value: Any) -> None:
         """Detect changes to cell styles and flag the style for
-        possible updates when saving the document"""
+        possible updates when saving the document.
+        """
         if name in ["bg_color", "font_color"]:
             value = rgb_color(value)
         if name == "alignment":
@@ -244,13 +241,13 @@ class Style:
 
 
 def rgb_color(color) -> RGB:
-    """Raise a TypeError if a color is not a valid RGB value"""
+    """Raise a TypeError if a color is not a valid RGB value."""
     if color is None:
         return None
     if isinstance(color, RGB):
         return color
     if isinstance(color, tuple):
-        if not (len(color) == 3 and all([isinstance(x, int) for x in color])):
+        if not (len(color) == 3 and all(isinstance(x, int) for x in color)):
             raise TypeError("RGB color must be an RGB or a tuple of 3 integers")
         return RGB(*color)
     elif isinstance(color, list):
@@ -259,13 +256,13 @@ def rgb_color(color) -> RGB:
 
 
 def alignment(value) -> Alignment:
-    """Raise a TypeError if a alignment is not a valid"""
+    """Raise a TypeError if a alignment is not a valid."""
     if value is None:
         return Alignment()
     if isinstance(value, Alignment):
         return value
     if isinstance(value, tuple):
-        if not (len(value) == 2 and all([isinstance(x, (int, str)) for x in value])):
+        if not (len(value) == 2 and all(isinstance(x, (int, str)) for x in value)):
             raise TypeError("Alignment must be an Alignment or a tuple of 2 integers/strings")
         return Alignment(*value)
     raise TypeError("Alignment must be an Alignment or a tuple of 2 integers/strings")
@@ -285,16 +282,20 @@ class Border:
     def __init__(
         self,
         width: float = DEFAULT_BORDER_WIDTH,
-        color: RGB = RGB(*DEFAULT_BORDER_COLOR),
-        style: BorderType = BorderType(BORDER_STYLE_MAP[DEFAULT_BORDER_STYLE]),
+        color: RGB = None,
+        style: BorderType = None,
         _order: int = 0,
     ):
         if not isinstance(width, float):
             raise TypeError("width must be a float number of points")
         self.width = width
 
+        if color is None:
+            color = RGB(*DEFAULT_BORDER_COLOR)
         self.color = rgb_color(color)
 
+        if style is None:
+            style = BorderType(BORDER_STYLE_MAP[DEFAULT_BORDER_STYLE])
         if isinstance(style, str):
             style = style.lower()
             if style not in BORDER_STYLE_MAP:
@@ -394,14 +395,14 @@ class CellBorder:
 
 
 class MergeReference:
-    """Cell reference for cells eliminated by a merge"""
+    """Cell reference for cells eliminated by a merge."""
 
     def __init__(self, row_start: int, col_start: int, row_end: int, col_end: int):
         self.rect = (row_start, col_start, row_end, col_end)
 
 
 class MergeAnchor:
-    """Cell reference for the merged cell"""
+    """Cell reference for the merged cell."""
 
     def __init__(self, size: Tuple):
         self.size = size
@@ -475,11 +476,12 @@ class Cell(Cacheable):
                 warn(
                     f"'{value}' rounded to {MAX_SIGNIFICANT_DIGITS} significant digits",
                     RuntimeWarning,
+                    stacklevel=2,
                 )
             return NumberCell(row_num, col_num, rounded_value)
-        elif isinstance(value, builtin_datetime) or isinstance(value, DateTime):
+        elif isinstance(value, (DateTime, builtin_datetime)):
             return DateCell(row_num, col_num, pendulum_instance(value))
-        elif isinstance(value, builtin_timedelta) or isinstance(value, Duration):
+        elif isinstance(value, (Duration, builtin_timedelta)):
             return DurationCell(row_num, col_num, value)
         else:
             raise ValueError("Can't determine cell type from type " + type(value).__name__)
@@ -527,6 +529,7 @@ class Cell(Cacheable):
             "image_filename is deprecated and will be removed in the future. "
             + "Please use the style property",
             DeprecationWarning,
+            stacklevel=2,
         )
         if self.style is not None and self.style.bg_image is not None:
             return self.style.bg_image.filename
@@ -539,6 +542,7 @@ class Cell(Cacheable):
             "image_data is deprecated and will be removed in the future. "
             + "Please use the style property",
             DeprecationWarning,
+            stacklevel=2,
         )
         if self.style is not None and self.style.bg_image is not None:
             return self.style.bg_image.data
@@ -555,8 +559,7 @@ class Cell(Cacheable):
     def formula(self):
         if self._formula_key is not None:
             table_formulas = self._model.table_formulas(self._table_id)
-            formula = table_formulas.formula(self._formula_key, self.row, self.col)
-            return formula
+            return table_formulas.formula(self._formula_key, self.row, self.col)
         else:
             return None
 
@@ -580,7 +583,11 @@ class Cell(Cacheable):
 
     @style.setter
     def style(self, _):
-        warn("cell style cannot be set; use Table.set_cell_style() instead", UnsupportedWarning)
+        warn(
+            "cell style cannot be set; use Table.set_cell_style() instead",
+            UnsupportedWarning,
+            stacklevel=2,
+        )
 
     @property
     def border(self):
@@ -592,6 +599,7 @@ class Cell(Cacheable):
         warn(
             "cell border values cannot be set; use Table.set_cell_border() instead",
             UnsupportedWarning,
+            stacklevel=2,
         )
 
 
@@ -718,8 +726,7 @@ 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.
     Args:
         cell_str:  A1 style string.
     Returns:
@@ -750,8 +757,7 @@ 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.
     Args:
        first_row: The first cell row.    Int.
        first_col: The first cell column. Int.
@@ -770,8 +776,7 @@ def xl_range(first_row, first_col, last_row, last_col):
 
 
 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.
     Args:
        row:     The cell row.    Int.
        col:     The cell column. Int.
@@ -795,8 +800,7 @@ 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.
     Args:
        col:     The cell column. Int.
        col_abs: Optional flag to make the column absolute. Bool.

numbers_parser/cell_storage.py

@@ -27,7 +27,7 @@ from numbers_parser.constants import (
 )
 from numbers_parser.exceptions import UnsupportedError, UnsupportedWarning
 from numbers_parser.generated import TSTArchives_pb2 as TSTArchives
-from numbers_parser.numbers_cache import cache, Cacheable
+from numbers_parser.numbers_cache import Cacheable, cache
 from numbers_parser.numbers_uuid import NumbersUUID
 
 logger = logging.getLogger(numbers_parser_name)
@@ -111,7 +111,9 @@ class CellStorage(Cacheable):
     )
 
     # @profile
-    def __init__(self, model: object, table_id: int, buffer, row_num, col_num):  # noqa: C901
+    def __init__(  # noqa: PLR0912, PLR0913, PLR0915
+        self, model: object, table_id: int, buffer, row_num, col_num
+    ):
         self.buffer = buffer
         self.model = model
         self.table_id = table_id
@@ -277,7 +279,7 @@ class CellStorage(Cacheable):
     @property
     @cache(num_args=0)
     def image_data(self) -> Tuple[bytes, str]:
-        """Return the background image data for a cell or None if no image"""
+        """Return the background image data for a cell or None if no image."""
         if self.cell_style_id is None:
             return None
         style = self.model.table_style(self.table_id, self.cell_style_id)
@@ -286,10 +288,18 @@ class CellStorage(Cacheable):
 
         image_id = style.cell_properties.cell_fill.image.imagedata.identifier
         datas = self.model.objects[PACKAGE_ID].datas
-        image_filename = [x.file_name for x in datas if x.identifier == image_id][0]
+        stored_filename = [x.file_name for x in datas if x.identifier == image_id][0]
+        preferred_filename = [x.preferred_file_name for x in datas if x.identifier == image_id][0]
         all_paths = self.model.objects.file_store.keys()
-        image_pathname = [x for x in all_paths if x == f"Data/{image_filename}"][0]
-        return (self.model.objects.file_store[image_pathname], image_filename)
+        image_pathnames = [x for x in all_paths if x == f"Data/{stored_filename}"]
+        if len(image_pathnames) == 0:
+            warn(
+                f"Cannot find file '{preferred_filename}' in Numbers archive",
+                RuntimeWarning,
+                stacklevel=3,
+            )
+        else:
+            return (self.model.objects.file_store[image_pathnames[0]], preferred_filename)
 
     def custom_format(self) -> str:
         if self.text_format_id is not None and self.type == CellType.TEXT:
@@ -341,14 +351,16 @@ class CellStorage(Cacheable):
                 formatted_value = decode_date_format(custom_format_string, self.datetime)
             else:
                 warn(
-                    f"Unexpected custom format type {custom_format.format_type}", UnsupportedWarning
+                    f"Unexpected custom format type {custom_format.format_type}",
+                    UnsupportedWarning,
+                    stacklevel=3,
                 )
                 return ""
         else:
             formatted_value = decode_date_format(format.date_time_format, self.datetime)
         return formatted_value
 
-    def duration_format(self) -> str:  # noqa: C901
+    def duration_format(self) -> str:
         format = self.model.table_format(self.table_id, self.duration_format_id)
 
         duration_style = format.duration_style
@@ -433,7 +445,7 @@ def unpack_decimal128(buffer: bytearray) -> float:
 
 
 def days_occurred_in_month(value: datetime) -> str:
-    """Return how many times the day of the datetime value has fallen in the month"""
+    """Return how many times the day of the datetime value has fallen in the month."""
     n_days = int((value - value.replace(day=1)).days / 7) + 1
     return str(n_days)
 
@@ -446,12 +458,12 @@ def decode_date_format_field(field: str, value: datetime) -> str:
         else:
             return value.strftime(s)
     else:
-        warn(f"Unsupported field code '{field}'", UnsupportedWarning)
+        warn(f"Unsupported field code '{field}'", UnsupportedWarning, stacklevel=4)
         return ""
 
 
 def decode_date_format(format, value):
-    """Parse a custom date format string and return a formatted datetime value"""
+    """Parse a custom date format string and return a formatted datetime value."""
     chars = [*format]
     index = 0
     in_string = False
@@ -498,8 +510,8 @@ def decode_date_format(format, value):
     return result
 
 
-def decode_text_format(format, value: str):  # noqa: C901
-    """Parse a custom date format string and return a formatted number value"""
+def decode_text_format(format, value: str):
+    """Parse a custom date format string and return a formatted number value."""
     custom_format_string = format.custom_format_string
     return custom_format_string.replace("\ue421", value)
 
@@ -530,8 +542,8 @@ def expand_quotes(value: str) -> str:
     return formatted_value
 
 
-def decode_number_format(format, value, name):  # noqa: C901
-    """Parse a custom date format string and return a formatted number value"""
+def decode_number_format(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:
@@ -548,6 +560,7 @@ def decode_number_format(format, value, name):  # noqa: C901
         warn(
             f"Can't parse format string '{custom_format_string}'; skipping",
             UnsupportedWarning,
+            stacklevel=1,
         )
         return custom_format_string
     format_spec = match.group(1)
@@ -596,10 +609,7 @@ def decode_number_format(format, value, name):  # noqa: C901
         elif format.num_nonspace_integer_digits > 0:
             int_pad = CellPadding.ZERO
             if format.show_thousands_separator:
-                if integer != 0:
-                    num_commas = int(math.floor(math.log10(integer)) / 3)
-                else:
-                    num_commas = 0
+                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
             else:
@@ -653,11 +663,10 @@ def decode_number_format(format, value, name):  # noqa: C901
             formatted_value = f"{integer:,}".rjust(int_width)
         else:
             formatted_value = str(integer).rjust(int_width)
+    elif format.show_thousands_separator:
+        formatted_value = f"{integer:,}"
     else:
-        if format.show_thousands_separator:
-            formatted_value = f"{integer:,}"
-        else:
-            formatted_value = str(integer)
+        formatted_value = str(integer)
 
     if num_decimals:
         if dec_pad == CellPadding.ZERO or (dec_pad == CellPadding.SPACE and num_integers == 0):
@@ -683,10 +692,7 @@ def format_decimal(value: float, format) -> str:
         value = -value
     else:
         accounting_style = False
-    if format.show_thousands_separator:
-        thousands = ","
-    else:
-        thousands = ""
+    thousands = "," if format.show_thousands_separator else ""
 
     if value.is_integer() and format.decimal_places >= DECIMAL_PLACES_AUTO:
         formatted_value = f"{int(value):{thousands}}"
@@ -710,7 +716,7 @@ def format_decimal(value: float, format) -> str:
 
 
 def float_to_fraction(value: float, denominator: int) -> str:
-    """Convert a float to the nearest fraction and return as a string"""
+    """Convert a float to the nearest fraction and return as a string."""
     whole = int(value)
     numerator = round(denominator * (value - whole))
     if numerator == 0:
@@ -724,7 +730,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
-    and return as a string"""
+    and return as a string.
+    """
     max_denominator = 10**max_digits - 1
     (numerator, denominator) = (
         Fraction.from_float(value).limit_denominator(max_denominator).as_integer_ratio()

numbers_parser/constants.py

@@ -1,6 +1,6 @@
 import os
-
 from enum import IntEnum
+
 from pendulum import datetime
 from pkg_resources import resource_filename
 
@@ -8,7 +8,7 @@ from pkg_resources import resource_filename
 DEFAULT_DOCUMENT = resource_filename(__name__, os.path.join("data", "empty.numbers"))
 DEFAULT_COLUMN_COUNT = 8
 DEFAULT_COLUMN_WIDTH = 98.0
-DEFAULT_PRE_BNC_BYTES = "🤠".encode("utf-8")  # Yes, really!
+DEFAULT_PRE_BNC_BYTES = "🤠".encode()  # Yes, really!
 DEFAULT_ROW_COUNT = 12
 DEFAULT_ROW_HEIGHT = 20.0
 DEFAULT_NUM_HEADERS = 1

numbers_parser/containers.py

@@ -1,8 +1,8 @@
 import math
 
-from numbers_parser.file import read_numbers_file
 from numbers_parser.constants import PACKAGE_ID
-from numbers_parser.iwafile import create_iwa_segment, copy_object_to_iwa_file, IWAFile
+from numbers_parser.file import read_numbers_file
+from numbers_parser.iwafile import IWAFile, copy_object_to_iwa_file, create_iwa_segment
 
 
 class ItemsList:
@@ -11,13 +11,13 @@ class ItemsList:
         self._items = [item_class(model, _) for _ in refs]
 
     def __getitem__(self, key: int):
-        if type(key) == int:
+        if isinstance(key, int):
             if key < 0:
                 key += len(self._items)
             if key >= len(self._items):
                 raise IndexError(f"index {key} out of range")
             return self._items[key]
-        elif type(key) == str:
+        elif isinstance(key, str):
             for item in self._items:
                 if item.name == key:
                     return item
@@ -54,7 +54,7 @@ class ObjectStore:
         self._max_id = math.ceil(self._max_id / 1000000) * 1000000
 
     def new_message_id(self):
-        """Return the next available message ID for object creation"""
+        """Return the next available message ID for object creation."""
         self._max_id += 1
         self._objects[PACKAGE_ID].last_object_identifier = self._max_id
         return self._max_id
@@ -62,12 +62,10 @@ class ObjectStore:
     def create_object_from_dict(self, iwa_file: str, object_dict: dict, cls: object):
         """Create a new object and store the associated IWA segment. Return the
         message ID for the object and the newly created object. If the IWA
-        file cannot be found, it will be created."""
+        file cannot be found, it will be created.
+        """
         paths = [k for k, v in self._file_store.items() if iwa_file in k]
-        if len(paths) == 0:
-            iwa_pathname = None
-        else:
-            iwa_pathname = paths[0]
+        iwa_pathname = None if len(paths) == 0 else paths[0]
 
         new_id = self.new_message_id()
         iwa_segment = create_iwa_segment(new_id, cls, object_dict)
@@ -85,8 +83,9 @@ class ObjectStore:
 
     def update_object_file_store(self):
         """Copy the protobuf messages from any updated object to the cached
-        version in the file store so this can be saved to a new document"""
-        for obj_id in self._objects.keys():
+        version in the file store so this can be saved to a new document.
+        """
+        for obj_id in self._objects:
             copy_object_to_iwa_file(
                 self._file_store[self._object_to_filename_map[obj_id]],
                 self._objects[obj_id],
@@ -112,5 +111,4 @@ class ObjectStore:
 
     # Don't cache: new tables and sheets can be added at runtime
     def find_refs(self, ref_name) -> list:
-        refs = [k for k, v in self._objects.items() if type(v).__name__ == ref_name]
-        return refs
+        return [k for k, v in self._objects.items() if type(v).__name__ == ref_name]