numbers-parser 4.8.1__py3-none-any.whl → 4.9.0__py3-none-any.whl

numbers_parser/cell.py

@@ -1,9 +1,10 @@
 import re
 from collections import namedtuple
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime as builtin_datetime
 from datetime import timedelta as builtin_timedelta
 from enum import IntEnum
+from os.path import basename
 from typing import Any, List, Tuple, Union
 from warnings import warn
 
@@ -27,6 +28,7 @@ from numbers_parser.constants import (
     EMPTY_STORAGE_BUFFER,
     MAX_BASE,
     MAX_SIGNIFICANT_DIGITS,
+    ControlFormattingType,
     CustomFormattingType,
     FormattingType,
     FormatType,
@@ -75,18 +77,43 @@ __all__ = [
 
 
 class BackgroundImage:
-    def __init__(self, image_data: bytes = None, filename: str = None):
-        self._data = image_data
-        self._filename = filename
+    """
+    A named document style that can be applied to cells.
+
+    .. code-block:: python
+
+        fh = open("cats.png", mode="rb")
+        image_data = fh.read()
+        cats_bg = doc.add_style(
+            name="Cats",
+            bg_image=BackgroundImage(image_data, "cats.png")
+        )
+        table.write(0, 0, "❤️ cats", style=cats_bg)
+
+    Currently only standard image files and not 'advanced' image fills are
+    supported. Tiling and scaling is not reported back and cannot be changed
+    when saving new cells.
+
+    Parameters
+    ----------
+    data: bytes
+        Raw image data for a cell background image.
+    filename: str
+        Path to the image file.
+    """
+
+    def __init__(self, data: bytes = None, filename: str = None):
+        self._data = data
+        self._filename = basename(filename)
 
     @property
     def data(self) -> bytes:
-        """The background image as byts for a cell, or None if no image."""
+        """bytes: The background image as bytes for a cell, or None if no image."""
         return self._data
 
     @property
     def filename(self) -> str:
-        """The image filename for a cell, or None if no image."""
+        """str: The image filename for a cell, or None if no image."""
         return self._filename
 
 
@@ -184,6 +211,8 @@ class Style:
     ------
     TypeError:
         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
@@ -230,6 +259,7 @@ class Style:
         return [
             "alignment",
             "bg_color",
+            "bg_image",
             "first_indent",
             "left_indent",
             "right_indent",
@@ -273,9 +303,9 @@ class Style:
         if not isinstance(self.font_name, str):
             raise TypeError("font name must be a string")
 
-        for field in ["bold", "italic", "underline", "strikethrough"]:
-            if not isinstance(getattr(self, field), bool):
-                raise TypeError(f"{field} argument must be boolean")
+        for attr in ["bold", "italic", "underline", "strikethrough"]:
+            if not isinstance(getattr(self, attr), bool):
+                raise TypeError(f"{attr} argument must be boolean")
 
     def __setattr__(self, name: str, value: Any) -> None:
         """Detect changes to cell styles and flag the style for
@@ -575,8 +605,14 @@ class Cell(Cacheable):
         else:
             raise ValueError("Can't determine cell type from type " + type(value).__name__)
 
-    def _set_formatting(self, format_id: int, format_type: FormattingType) -> None:
-        self._storage._set_formatting(format_id, format_type)
+    def _set_formatting(
+        self,
+        format_id: int,
+        format_type: FormattingType,
+        control_id: int = None,
+        is_currency: bool = False,
+    ) -> None:
+        self._storage.set_formatting(format_id, format_type, control_id, is_currency)
 
     def __init__(self, row: int, col: int, value):
         self._value = value
@@ -705,7 +741,32 @@ class Cell(Cacheable):
 
     @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
+        visual representation. Currently supported mappings are:
+
+        * Checkboxes are U+2610 (Ballow Box) or U+2611 (Ballot Box with Check)
+        * Ratings are their star value represented using (U+2605) (Black Star)
+
+        .. code-block:: python
+
+            >>> table = doc.sheets[0].tables[0]
+            >>> table.cell(0,0).value
+            False
+            >>> table.cell(0,0).formatted_value
+            '☐'
+            >>> table.cell(0,1).value
+            True
+            >>> table.cell(0,1).formatted_value
+            '☑'
+            >>> table.cell(1,1).value
+            3.0
+            >>> table.cell(1,1).formatted_value
+            '★★★'
+        """
         if self._storage is None:
             return ""
         else:
@@ -1079,16 +1140,22 @@ def xl_col_to_name(col, col_abs=False):
 
 @dataclass()
 class Formatting:
-    type: FormattingType = FormattingType.NUMBER
+    allow_none: bool = False
     base_places: int = 0
     base_use_minus_sign: bool = True
     base: int = 10
+    control_format: ControlFormattingType = ControlFormattingType.NUMBER
     currency_code: str = "GBP"
     date_time_format: str = DEFAULT_DATETIME_FORMAT
     decimal_places: int = None
     fraction_accuracy: FractionAccuracy = FractionAccuracy.THREE
+    increment: float = 1.0
+    maximum: float = 100.0
+    minimum: float = 1.0
+    popup_values: List[str] = field(default_factory=lambda: ["Item 1"])
     negative_style: NegativeNumberStyle = NegativeNumberStyle.MINUS
     show_thousands_separator: bool = False
+    type: FormattingType = FormattingType.NUMBER
     use_accounting_style: bool = False
     _format_id = None
 

numbers_parser/cell_storage.py

@@ -11,6 +11,8 @@ from pendulum import datetime, duration
 
 from numbers_parser import __name__ as numbers_parser_name
 from numbers_parser.constants import (
+    CHECKBOX_FALSE_VALUE,
+    CHECKBOX_TRUE_VALUE,
     CURRENCY_CELL_TYPE,
     CUSTOM_TEXT_PLACEHOLDER,
     DATETIME_FIELD_MAP,
@@ -21,6 +23,7 @@ from numbers_parser.constants import (
     SECONDS_IN_DAY,
     SECONDS_IN_HOUR,
     SECONDS_IN_WEEK,
+    STAR_RATING_VALUE,
     CellPadding,
     CellType,
     CustomFormattingType,
@@ -60,7 +63,7 @@ class CellStorage(Cacheable):
         # "cond_style_id",
         # "cond_rule_style_id",
         "formula_id",
-        # "control_id",
+        "control_id",
         "formula_error_id",
         "suggest_id",
         "num_format_id",
@@ -95,7 +98,7 @@ class CellStorage(Cacheable):
         # self.cond_style_id = None
         # self.cond_rule_style_id = None
         self.formula_id = None
-        # self.control_id = None
+        self.control_id = None
         self.formula_error_id = None
         self.suggest_id = None
         self.num_format_id = None
@@ -148,9 +151,9 @@ class CellStorage(Cacheable):
         if flags & 0x200:
             self.formula_id = unpack("<i", buffer[offset : offset + 4])[0]
             offset += 4
-        # if flags & 0x400:
-        #     self.control_id = unpack("<i", buffer[offset : offset + 4])[0]
-        #     offset += 4
+        if flags & 0x400:
+            self.control_id = unpack("<i", buffer[offset : offset + 4])[0]
+            offset += 4
         # if flags & 0x800:
         #     self.formula_error_id = unpack("<i", buffer[offset : offset + 4])[0]
         #     offset += 4
@@ -158,7 +161,7 @@ class CellStorage(Cacheable):
             self.suggest_id = unpack("<i", buffer[offset : offset + 4])[0]
             offset += 4
         # Skip unused flags
-        offset += 4 * bin(flags & 0xD00).count("1")
+        offset += 4 * bin(flags & 0x900).count("1")
         #
         if flags & 0x2000:
             self.num_format_id = unpack("<i", buffer[offset : offset + 4])[0]
@@ -300,13 +303,15 @@ class CellStorage(Cacheable):
             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)
+        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)
         elif self.num_format_id is not None:
             format = self.model.table_format(self.table_id, self.num_format_id)
-        elif self.bool_format_id is not None:
-            format = self.model.table_format(self.table_id, self.bool_format_id)
         else:
             return str(self.value)
 
+        debug("custom_format: @[%d,%d]: format_type=%s, ", self.row, self.col, format.format_type)
+
         if format.HasField("custom_uid"):
             format_uuid = NumbersUUID(format.custom_uid).hex
             format_map = self.model.custom_format_map()
@@ -336,6 +341,10 @@ class CellStorage(Cacheable):
             return format_fraction(self.d128, format)
         elif format.format_type == FormatType.SCIENTIFIC:
             return format_scientific(self.d128, format)
+        elif format.format_type == FormatType.CHECKBOX:
+            return CHECKBOX_TRUE_VALUE if self.value else CHECKBOX_FALSE_VALUE
+        elif format.format_type == FormatType.RATING:
+            return STAR_RATING_VALUE * int(self.d128)
         else:
             formatted_value = str(self.value)
         return formatted_value
@@ -362,6 +371,14 @@ class CellStorage(Cacheable):
 
     def duration_format(self) -> str:
         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_style = format.duration_style
         unit_largest = format.duration_unit_largest
@@ -431,15 +448,34 @@ class CellStorage(Cacheable):
 
         return duration_str
 
-    def _set_formatting(
-        self, format_id: int, format_type: Union[FormattingType, CustomFormattingType]
+    def set_formatting(
+        self,
+        format_id: int,
+        format_type: Union[FormattingType, CustomFormattingType],
+        control_id: int = None,
+        is_currency: bool = False,
     ) -> None:
+        self.is_currency = is_currency
         if format_type == FormattingType.CURRENCY:
             self.currency_format_id = format_id
-            self.is_currency = True
+        elif format_type == FormattingType.TICKBOX:
+            self.bool_format_id = format_id
+            self.control_id = control_id
+        elif format_type == FormattingType.RATING:
+            self.num_format_id = format_id
+            self.control_id = control_id
+        elif format_type in [FormattingType.SLIDER, FormattingType.STEPPER]:
+            if is_currency:
+                self.currency_format_id = format_id
+            else:
+                self.num_format_id = format_id
+            self.control_id = control_id
+        elif format_type == FormattingType.POPUP:
+            self.text_format_id = format_id
+            self.control_id = control_id
         elif format_type in [FormattingType.DATETIME, CustomFormattingType.DATETIME]:
             self.date_format_id = format_id
-        elif format_type == CustomFormattingType.TEXT:
+        elif format_type in [FormattingType.TEXT, CustomFormattingType.TEXT]:
             self.text_format_id = format_id
         else:
             self.num_format_id = format_id

numbers_parser/constants.py

@@ -20,6 +20,7 @@ __all__ = [
     "FormattingType",
     "NegativeNumberStyle",
     "FractionAccuracy",
+    "ControlFormattingType",
 ]
 
 DEFAULT_DOCUMENT = files("numbers_parser") / "data" / "empty.numbers"
@@ -44,8 +45,11 @@ DEFAULT_TEXT_INSET = 4.0
 DEFAULT_TEXT_WRAP = True
 EMPTY_STORAGE_BUFFER = b"\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 
-# Formatting defaults
+# Formatting values and defaults
 DEFAULT_DATETIME_FORMAT = "dd MMM YYY HH:MM"
+CHECKBOX_FALSE_VALUE = "☐"
+CHECKBOX_TRUE_VALUE = "☑"
+STAR_RATING_VALUE = "★"
 
 # Numbers limits
 MAX_TILE_SIZE = 256
@@ -179,6 +183,39 @@ class FormattingType(IntEnum):
     NUMBER = 5
     PERCENTAGE = 6
     SCIENTIFIC = 7
+    TICKBOX = 8
+    RATING = 9
+    SLIDER = 10
+    STEPPER = 11
+    POPUP = 12
+    TEXT = 13
+
+
+class ControlFormattingType(IntEnum):
+    BASE = 1
+    CURRENCY = 2
+    FRACTION = 4
+    NUMBER = 5
+    PERCENTAGE = 6
+    SCIENTIFIC = 7
+
+
+FORMATTING_ALLOWED_CELLS = {
+    "base": ["NumberCell"],
+    "currency": ["NumberCell"],
+    "datetime": ["DateCell"],
+    "fraction": ["NumberCell"],
+    "number": ["NumberCell"],
+    "percentage": ["NumberCell"],
+    "popup": ["NumberCell", "TextCell"],
+    "rating": ["NumberCell"],
+    "scientific": ["NumberCell"],
+    "slider": ["NumberCell"],
+    "stepper": ["NumberCell"],
+    "tickbox": ["BoolCell"],
+}
+
+FORMATTING_ACTION_CELLS = ["tickbox", "rating", "popup", "slider", "stepper"]
 
 
 class CustomFormattingType(IntEnum):
@@ -187,6 +224,13 @@ class CustomFormattingType(IntEnum):
     TEXT = 103
 
 
+CUSTOM_FORMATTING_ALLOWED_CELLS = {
+    "number": ["NumberCell"],
+    "datetime": ["DateCell"],
+    "text": ["TextCell"],
+}
+
+
 @enum_tools.documentation.document_enum
 class NegativeNumberStyle(IntEnum):
     """
@@ -236,19 +280,47 @@ class FractionAccuracy(IntEnum):
 
 
 ALLOWED_FORMATTING_PARAMETERS = {
-    FormattingType.BASE: ["base", "base_places", "base_use_minus_sign"],
+    FormattingType.BASE: [
+        "base",
+        "base_places",
+        "base_use_minus_sign",
+    ],
     FormattingType.CURRENCY: [
+        "currency_code",
         "decimal_places",
-        "show_thousands_separator",
         "negative_style",
+        "show_thousands_separator",
         "use_accounting_style",
-        "currency_code",
     ],
     FormattingType.DATETIME: ["date_time_format"],
     FormattingType.FRACTION: ["fraction_accuracy"],
-    FormattingType.NUMBER: ["decimal_places", "show_thousands_separator", "negative_style"],
-    FormattingType.PERCENTAGE: ["decimal_places", "show_thousands_separator", "negative_style"],
+    FormattingType.NUMBER: [
+        "decimal_places",
+        "show_thousands_separator",
+        "negative_style",
+    ],
+    FormattingType.PERCENTAGE: [
+        "decimal_places",
+        "show_thousands_separator",
+        "negative_style",
+    ],
     FormattingType.SCIENTIFIC: ["decimal_places"],
+    FormattingType.POPUP: ["popup_values", "allow_none"],
+    FormattingType.RATING: [],
+    FormattingType.SLIDER: [
+        "control_format",
+        "increment",
+        "maximum",
+        "minimum",
+    ],
+    FormattingType.STEPPER: [
+        "control_format",
+        "increment",
+        "maximum",
+        "minimum",
+    ],
+    FormattingType.TICKBOX: [],
+    FormattingType.TEXT: [],
 }
 
 FORMAT_TYPE_MAP = {
@@ -258,7 +330,13 @@ FORMAT_TYPE_MAP = {
     FormattingType.FRACTION: FormatType.FRACTION,
     FormattingType.NUMBER: FormatType.DECIMAL,
     FormattingType.PERCENTAGE: FormatType.PERCENT,
+    FormattingType.POPUP: FormatType.TEXT,
+    FormattingType.RATING: FormatType.RATING,
     FormattingType.SCIENTIFIC: FormatType.SCIENTIFIC,
+    FormattingType.SLIDER: FormatType.DECIMAL,
+    FormattingType.STEPPER: FormatType.DECIMAL,
+    FormattingType.TICKBOX: FormatType.CHECKBOX,
+    FormattingType.TEXT: FormatType.TEXT,
 }
 
 CUSTOM_FORMAT_TYPE_MAP = {
@@ -268,6 +346,25 @@ CUSTOM_FORMAT_TYPE_MAP = {
 }
 
 
+class CellInteractionType(IntEnum):
+    VALUE_EDITING = 0
+    FORMULA_EDITING = 1
+    STOCK = 2
+    CATEGORY_SUMMARY = 3
+    STEPPER = 4
+    SLIDER = 5
+    RATING = 6
+    POPUP = 7
+    TOGGLE = 8
+
+
+CONTROL_CELL_TYPE_MAP = {
+    FormattingType.POPUP: CellInteractionType.POPUP,
+    FormattingType.SLIDER: CellInteractionType.SLIDER,
+    FormattingType.STEPPER: CellInteractionType.STEPPER,
+}
+
+
 @enum_tools.documentation.document_enum
 class PaddingType(IntEnum):
     """How integers and decimals are padded in custom number formats"""

numbers_parser/containers.py

@@ -59,7 +59,7 @@ class ObjectStore:
         self._objects[PACKAGE_ID].last_object_identifier = self._max_id
         return self._max_id
 
-    def create_object_from_dict(self, iwa_file: str, object_dict: dict, cls: object):
+    def create_object_from_dict(self, iwa_file: str, object_dict: dict, cls: object, append=False):
         """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.
@@ -70,7 +70,7 @@ class ObjectStore:
         new_id = self.new_message_id()
         iwa_segment = create_iwa_segment(new_id, cls, object_dict)
 
-        if iwa_pathname is None:
+        if iwa_pathname is None and not append:
             iwa_pathname = iwa_file.format(new_id) + ".iwa"
             chunks = {"chunks": [{"archives": [iwa_segment.to_dict()]}]}
             self._file_store[iwa_pathname] = IWAFile.from_dict(chunks)

numbers_parser/document.py

@@ -4,15 +4,15 @@ from warnings import warn
 from pendulum import DateTime, Duration
 
 from numbers_parser.cell import (
+    BackgroundImage,
     Border,
     Cell,
+    ControlFormattingType,
     CustomFormatting,
     CustomFormattingType,
-    DateCell,
     Formatting,
     FormattingType,
     MergedCell,
-    NumberCell,
     Style,
     TextCell,
     UnsupportedWarning,
@@ -21,8 +21,11 @@ from numbers_parser.cell import (
 )
 from numbers_parser.cell_storage import CellStorage
 from numbers_parser.constants import (
+    CUSTOM_FORMATTING_ALLOWED_CELLS,
     DEFAULT_COLUMN_COUNT,
     DEFAULT_ROW_COUNT,
+    FORMATTING_ACTION_CELLS,
+    FORMATTING_ALLOWED_CELLS,
     MAX_COL_COUNT,
     MAX_HEADER_COUNT,
     MAX_ROW_COUNT,
@@ -221,10 +224,17 @@ class Document:
         ------
         TypeError:
             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.
         """  # noqa: E501
         if "name" in kwargs and kwargs["name"] is not None and kwargs["name"] in self._model.styles:
             raise IndexError(f"style '{kwargs['name']}' already exists")
+
+        if "bg_image" in kwargs and kwargs["bg_image"] is not None:
+            if not isinstance(kwargs["bg_image"], BackgroundImage):
+                raise TypeError("bg_image must be a BackgroundImage object")
+            self._model.store_image((kwargs["bg_image"].data), kwargs["bg_image"].filename)
+
         style = Style(**kwargs)
         if style.name is None:
             style.name = self._model.custom_style_name()
@@ -814,20 +824,28 @@ class Table(Cacheable):  # noqa: F811
         The ``write()`` method supports two forms of notation to designate the position
         of cells: **Row-column** notation and **A1** notation:
 
-        .. code-block:: python
+        .. code:: python
 
-            (0, 0)      # Row-column notation.
-            ("A1")      # The same cell in A1 notation.
+            doc = Document("write.numbers")
+            sheets = doc.sheets
+            tables = sheets[0].tables
+            table = tables[0]
+            table.write(1, 1, "This is new text")
+            table.write("B7", datetime(2020, 12, 25))
+            doc.save("new-sheet.numbers")
 
         Parameters
         ----------
 
-        param1: int
+        row: int
             The row number (zero indexed)
-        param2: int
+        col: int
             The column number (zero indexed)
-        param3: str | int | float | bool | DateTime | Duration
-            The value to write to the cell. The generated cell type
+        value: str | int | float | bool | DateTime | Duration
+            The value to write to the cell. The generated cell type is automatically
+            created based on the type of ``value``.
+        style: Style | str | None
+            The name of a document custom style or a :py:class:`~numbers_parser.cell.Style` object.
 
         Warns
         -----
@@ -843,19 +861,6 @@ class Table(Cacheable):  # noqa: F811
             If the style parameter is an invalid type.
         ValueError:
             If the cell type cannot be determined from the type of `param3`.
-
-        Example
-        -------
-
-        .. code:: python
-
-            doc = Document("write.numbers")
-            sheets = doc.sheets
-            tables = sheets[0].tables
-            table = tables[0]
-            table.write(1, 1, "This is new text")
-            table.write("B7", datetime(2020, 12, 25))
-            doc.save("new-sheet.numbers")
         """
         # TODO: write needs to retain/init the border
         (row, col, value) = self._validate_cell_coords(*args)
@@ -1103,6 +1108,48 @@ class Table(Cacheable):  # noqa: F811
                     cell._set_merge(merge_cells.get((row, col)))
 
     def set_cell_border(self, *args):
+        """
+        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)
+        of the side(s) must be one of ``"top"``, ``"right"``, ``"bottom"`` or ``"left"``.
+
+        Numbers supports different border styles for each cell within a merged cell range
+        for those cells that are on the outer part of the merge. ``numbers-parser`` will
+        ignore attempts to set these invisible cell edges and issue a ``RuntimeWarning``.
+
+        .. code-block:: python
+
+            # Dashed line for B7's right border
+            table.set_cell_border(6, 1, "right", Border(5.0, RGB(29, 177, 0), "dashes"))
+            # Solid line starting at B7's left border and running for 3 rows
+            table.set_cell_border("B7", "left", Border(8.0, RGB(29, 177, 0), "solid"), 3)
+
+        :Args (row-column):
+            * **param1** (*int*): The row number (zero indexed).
+            * **param2** (*int*): The column number (zero indexed).
+            * **param3** (*str | List[str]*): Which side(s) of the cell to apply the border to.
+            * **param4** (:py:class:`Border`): The border to add.
+            * **param5** (*int*, *optinal*, default: 1): The length of the stroke to add.
+
+        :Args (A1):
+            * **param1** (*str*): A cell reference using Excel/Numbers-style A1 notation.
+            * **param2** (*str | List[str]*): Which side(s) of the cell to apply the border to.
+            * **param3** (:py:class:`Border`): The border to add.
+            * **param4** (*int*, *optional*, default: 1): The length of the stroke to add.
+
+        Raises
+        ------
+        TypeError:
+            If an invalid number of arguments is passed or if the types of the arguments
+            are invalid.
+
+        Warns
+        -----
+        RuntimeWarning:
+            If any of the sides to which the border is applied have been merged.
+        """  # noqa: E501
         (row, col, *args) = self._validate_cell_coords(*args)
         if len(args) == 2:
             (side, border_value) = args
@@ -1165,32 +1212,52 @@ class Table(Cacheable):  # noqa: F811
 
         Cell references can be **row-column** offsers or Excel/Numbers-style **A1** notation.
 
+        .. code:: python
+
+            table.set_cell_formatting(
+                "C1",
+                "date",
+                date_time_format="EEEE, d MMMM yyyy"
+            )
+            table.set_cell_formatting(
+                0,
+                4,
+                "number",
+                decimal_places=3,
+                negative_style=NegativeNumberStyle.RED
+            )
+
         :Parameters:
             * **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):
-            * **param1** (``int``): The row number (zero indexed).
-            * **param2** (``int``): The column number (zero indexed).
-            * **param3** (``str``): Data format type for the cell (see "data formats" below).
+            * **param1** (*int*): The row number (zero indexed).
+            * **param2** (*int*): The column number (zero indexed).
+            * **param3** (*str*): Data format type for the cell (see "data formats" below).
 
         :Args (A1):
-            * **param1** (``str``): A cell reference using Excel/Numbers-style A1 notation.
-            * **param2** (``str``): Data format type for the cell (see "data formats" below).
+            * **param1** (*str*): A cell reference using Excel/Numbers-style A1 notation.
+            * **param2** (*str*): Data format type for the cell (see "data formats" below).
+
+        :Raises:
+            * **TypeError** -
+                If a tickbox is chosen for anything other than ``bool`` values.
 
         :Warns:
             * **RuntimeWarning** -
                 If ``use_accounting_style`` is used with
-                any ``negative_style`` other than ``NegativeNumberStyle.MINUS``.
+                any ``negative_style`` other than ``NegativeNumberStyle.MINUS``, or
+                if a rating is out of range 0 to 5 (rating is clamped to these values).
 
         All formatting styles share a name and a type, described in the **Common**
         parameters in the following table. Additional key-value pairs configure the format
         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.
@@ -1200,56 +1267,89 @@ class Table(Cacheable):  # noqa: F811
               * ``"percentage"``: A number formatted as a percentage
               * ``"number"``: A decimal number.
               * ``"scientific"``: A decimal number with scientific notation.
+              * ``"tickbox"``: A checkbox (bool values only).
+              * ``"rating"``: A star rating from 0 to 5.
+              * ``"slider"``: A range slider.
+              * ``"stepper"``: An up/down value stepper.
+              * ``"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.
 
         :``"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.
 
-        Example
+        :``"tickbox"``:
+            * No additional parameters defined.
+
+        :``"rating"``:
+            * No additional parameters defined.
+
+        :``"slider"``:
+            * **control_format** (*ControlFormattingType, optional, default: ControlFormattingType.NUMBER*) - the format
+                of the data in the slider. Valid options are ``"base"``, ``"currency"``,
+                ``"datetime"``, ``"fraction"``, ``"percentage"``, ``"number"``,
+                or ``"scientific". Each format allows additional parameters identical to those
+                available for the formats themselves. For example, a slider using fractions
+                is configured with ``fraction_accuracy``.
+            * **increment** (*float, optional, default: 1*) - the slider's minimum value
+            * **maximum** (*float, optional, default: 100*) - the slider's maximum value
+            * **minimum** (*float, optional, default: 1*) - increment value for the slider
+
+        :`"stepper"``:
+            * **control_format** (*ControlFormattingType, optional, default: ControlFormattingType.NUMBER*) - the format
+                of the data in the stepper. Valid options are ``"base"``, ``"currency"``,
+                ``"datetime"``, ``"fraction"``, ``"percentage"``, ``"number"``,
+                or ``"scientific"``. Each format allows additional parameters identical to those
+                available for the formats themselves. For example, a stepper using fractions
+                is configured with ``fraction_accuracy``.
+            * **increment** (*float, optional, default: 1*) - the stepper's minimum value
+            * **maximum** (*float, optional, default: 100*) - the stepper's maximum value
+            * **minimum** (*float, optional, default: 1*) - increment value for the stepper
+
+        :`"popup"``:
+            * **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
 
-        .. code:: python
-
-            >>> table.set_cell_formatting("C1", "date", date_time_format="EEEE, d MMMM yyyy")
-            >>> table.set_cell_formatting(0, 4, "number", decimal_places=3, negative_style=NegativeNumberStyle.RED)
 
         """  # noqa: E501
         (row, col, *args) = self._validate_cell_coords(*args)
@@ -1280,33 +1380,57 @@ class Table(Cacheable):  # noqa: F811
             raise TypeError("format must be a CustomFormatting object or format name")
 
         cell = self._data[row][col]
-        if custom_format.type == CustomFormattingType.DATETIME and not isinstance(cell, DateCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot use date/time formatting for cells of type {type_name}")
-        elif custom_format.type == CustomFormattingType.NUMBER and not isinstance(cell, NumberCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot use number formatting for cells of type {type_name}")
-        elif custom_format.type == CustomFormattingType.TEXT and not isinstance(cell, TextCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot use text formatting for cells of type {type_name}")
+        type_name = type(cell).__name__
+        format_type_name = custom_format.type.name.lower()
+        if type_name not in CUSTOM_FORMATTING_ALLOWED_CELLS[format_type_name]:
+            raise TypeError(
+                f"cannot use {format_type_name} formatting for cells of type {type_name}"
+            )
 
         format_id = self._model.custom_format_id(self._table_id, custom_format)
         cell._set_formatting(format_id, custom_format.type)
 
-    def _set_cell_data_format(self, row: int, col: int, format_type: str, **kwargs) -> None:
+    def _set_cell_data_format(self, row: int, col: int, format_type_name: str, **kwargs) -> None:
         try:
-            format_type = FormattingType[format_type.upper()]
+            format_type = FormattingType[format_type_name.upper()]
         except (KeyError, AttributeError):
-            raise TypeError(f"unsuported cell format type '{format_type}'") from None
+            raise TypeError(f"unsuported cell format type '{format_type_name}'") from None
 
         cell = self._data[row][col]
-        if format_type == FormattingType.DATETIME and not isinstance(cell, DateCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot use date/time formatting for cells of type {type_name}")
-        elif not isinstance(cell, NumberCell) and not isinstance(cell, DateCell):
-            type_name = type(cell).__name__
-            raise TypeError(f"cannot set formatting for cells of type {type_name}")
+        type_name = type(cell).__name__
+        if type_name not in FORMATTING_ALLOWED_CELLS[format_type_name]:
+            raise TypeError(
+                f"cannot use {format_type_name} formatting for cells of type {type_name}"
+            )
 
         format = Formatting(type=format_type, **kwargs)
-        format_id = self._model.format_archive(self._table_id, format_type, format)
-        cell._set_formatting(format_id, format_type)
+        if format_type_name in FORMATTING_ACTION_CELLS:
+            control_id = self._model.control_cell_archive(self._table_id, format_type, format)
+        else:
+            control_id = None
+
+        is_currency = True if format_type == FormattingType.CURRENCY else False
+        if format_type_name in ["slider", "stepper"]:
+            if "control_format" in kwargs:
+                try:
+                    control_format = kwargs["control_format"].name
+                    number_format_type = FormattingType[control_format]
+                    is_currency = (
+                        True
+                        if kwargs["control_format"] == ControlFormattingType.CURRENCY
+                        else False
+                    )
+                except (KeyError, AttributeError):
+                    raise TypeError(
+                        "unsupported number format '{control_format}' for format_type_name"
+                    ) from None
+            else:
+                number_format_type = FormattingType.NUMBER
+            format_id = self._model.format_archive(self._table_id, number_format_type, format)
+        elif format_type_name == "popup":
+            popup_format_type = FormattingType.TEXT if isinstance(cell, TextCell) else True
+            format_id = self._model.format_archive(self._table_id, popup_format_type, format)
+        else:
+            format_id = self._model.format_archive(self._table_id, format_type, format)
+
+        cell._set_formatting(format_id, format_type, control_id, is_currency=is_currency)

numbers_parser/file.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import re
 from io import BytesIO
 from sys import version_info
 from zipfile import BadZipFile, ZipFile
@@ -32,11 +33,15 @@ def read_numbers_file(path, file_handler, object_handler=None):
                     read_numbers_file(filepath, file_handler, object_handler)
                 else:
                     f = open(filepath, "rb")
-                    if filename.endswith(".iwa"):
-                        blob = f.read()
-                        extract_iwa_archives(blob, filepath, file_handler, object_handler)
                     blob = f.read()
-                    file_handler(os.path.join(path, filename), blob)
+                    if filename.endswith(".iwa"):
+                        package_filepath = re.sub(r".*\.numbers/*", "", filepath)
+                        extract_iwa_archives(blob, package_filepath, file_handler, object_handler)
+                    else:
+                        package_filepath = os.path.join(
+                            re.sub(r".*\.numbers/*", "", path), filename
+                        )
+                        file_handler(package_filepath, blob)
     else:
         try:
             zipf = open_zipfile(path)

numbers_parser/model.py

@@ -2,6 +2,7 @@ import math
 import re
 from array import array
 from collections import defaultdict
+from hashlib import sha1
 from struct import pack
 from typing import Dict, List, Tuple, Union
 from warnings import warn
@@ -55,6 +56,7 @@ from numbers_parser.constants import (
     FORMAT_TYPE_MAP,
     MAX_TILE_SIZE,
     PACKAGE_ID,
+    CellInteractionType,
     FormatType,
 )
 from numbers_parser.containers import ObjectStore
@@ -219,6 +221,7 @@ class _NumbersModel(Cacheable):
         self._table_formats = DataLists(self, "format_table", "format")
         self._table_styles = DataLists(self, "styleTable", "reference")
         self._table_strings = DataLists(self, "stringTable", "string")
+        self._control_specs = DataLists(self, "control_cell_spec_table", "cell_spec")
         self._table_data = {}
         self._styles = None
         self._custom_formats = None
@@ -362,6 +365,64 @@ class _NumbersModel(Cacheable):
         format = TSKArchives.FormatStructArchive(**attrs)
         return self._table_formats.lookup_key(table_id, format)
 
+    def cell_popup_model(self, parent_id: int, format: Formatting):
+        tsce_items = [{"cell_value_type": "NIL_TYPE"}]
+        for item in format.popup_values:
+            if isinstance(item, str):
+                tsce_items.append(
+                    {
+                        "cell_value_type": "STRING_TYPE",
+                        "string_value": {
+                            "value": item,
+                            "format": {"format_type": FormatType.TEXT},
+                        },
+                    }
+                )
+            else:
+                tsce_items.append(
+                    {
+                        "cell_value_type": "NUMBER_TYPE",
+                        "number_value": {
+                            "value": item,
+                            "format": {"format_type": FormatType.DECIMAL},
+                        },
+                    }
+                )
+        popup_menu_id, _ = self.objects.create_object_from_dict(
+            f"Index/Tables/DataList-{parent_id}",
+            {"tsce_item": tsce_items},
+            TSTArchives.PopUpMenuModel,
+            True,
+        )
+        return popup_menu_id
+
+    def control_cell_archive(self, table_id: int, format_type: FormattingType, format: Formatting):
+        """Create control cell archive from a Formatting spec and return the table format ID"""
+        if format_type == FormattingType.TICKBOX:
+            cell_spec = TSTArchives.CellSpecArchive(interaction_type=CellInteractionType.TOGGLE)
+        elif format_type == FormattingType.RATING:
+            cell_spec = TSTArchives.CellSpecArchive(
+                interaction_type=CellInteractionType.RATING,
+                range_control_min=0.0,
+                range_control_max=5.0,
+                range_control_inc=1.0,
+            )
+        elif format_type == FormattingType.SLIDER:
+            cell_spec = TSTArchives.CellSpecArchive(
+                interaction_type=CellInteractionType.SLIDER,
+                range_control_min=format.minimum,
+                range_control_max=format.maximum,
+                range_control_inc=format.increment,
+            )
+        else:  # POPUP
+            popup_id = self.cell_popup_model(self._control_specs.id(table_id), format)
+            cell_spec = TSTArchives.CellSpecArchive(
+                interaction_type=CellInteractionType.POPUP,
+                chooser_control_popup_model=TSPMessages.Reference(identifier=popup_id),
+                chooser_control_start_w_first=not (format.allow_none),
+            )
+        return self._control_specs.lookup_key(table_id, cell_spec)
+
     def add_custom_decimal_format_archive(self, format: CustomFormatting) -> None:
         """Create a custom format from the format spec"""
         integer_format = format.integer_format
@@ -1476,12 +1537,35 @@ class _NumbersModel(Cacheable):
                             + str(cell.style.bg_color.g)
                             + str(cell.style.bg_color.b)
                         )
+                    if cell._style.bg_image is not None:
+                        fingerprint += cell._style.bg_image.filename
                     if fingerprint not in cell_styles:
                         cell_styles[fingerprint] = self.add_cell_style(cell._style)
                     cell._style._cell_style_obj_id = cell_styles[fingerprint]
 
     def add_cell_style(self, style: Style) -> int:
-        if style.bg_color is not None:
+        if style.bg_image is not None:
+            datas = self.objects[PACKAGE_ID].datas
+            image_id = self.next_image_identifier()
+            datas.append(
+                TSPArchiveMessages.DataInfo(
+                    identifier=image_id,
+                    digest=sha1(style.bg_image.data).digest(),
+                    preferred_file_name=style.bg_image.filename,
+                    file_name=style.bg_image.filename,
+                    materialized_length=len(style.bg_image.data),
+                )
+            )
+            color_attrs = {
+                "cell_fill": {
+                    "image": {
+                        "technique": "ScaleToFill",
+                        "imagedata": {"identifier": image_id},
+                        "interpretsUntaggedImageDataAsGeneric": False,
+                    }
+                }
+            }
+        elif style.bg_color is not None:
             color_attrs = {
                 "cell_fill": {
                     "color": {
@@ -1530,6 +1614,7 @@ class _NumbersModel(Cacheable):
                 style=TSPMessages.Reference(identifier=cell_style_id),
             )
         )
+
         return cell_style_id
 
     def text_style_object_id(self, cell_storage) -> int:
@@ -1698,6 +1783,10 @@ class _NumbersModel(Cacheable):
             flags |= 0x200
             length += 4
             storage += pack("<i", cell._storage.formula_id)
+        if cell._storage.control_id is not None:
+            flags |= 0x400
+            length += 4
+            storage += pack("<i", cell._storage.control_id)
         if cell._storage.suggest_id is not None:
             flags |= 0x1000
             length += 4
@@ -2203,6 +2292,20 @@ class _NumbersModel(Cacheable):
             stroke_layer.stroke_runs.append(self.create_stroke(origin, length, border_value))
             layer_ids.append(TSPMessages.Reference(identifier=stroke_layer_id))
 
+    def store_image(self, data: bytes, filename: str) -> None:
+        """Store image data in the file store."""
+        stored_filename = f"Data/{filename}"
+        if stored_filename in self.objects.file_store:
+            raise IndexError(f"{filename}: image already exists in document")
+        self.objects.file_store[stored_filename] = data
+
+    def next_image_identifier(self):
+        """Return the next available ID in the list of images in the document."""
+        datas = self.objects[PACKAGE_ID].datas
+        image_ids = [x.identifier for x in datas]
+        # datas never appears to be an empty list (default themes include images)
+        return max(image_ids) + 1
+
 
 def rgb(obj) -> RGB:
     """Convert a TSPArchives.Color into an RGB tuple."""

{numbers_parser-4.8.1.dist-info → numbers_parser-4.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: numbers-parser
-Version: 4.8.1
+Version: 4.9.0
 Summary: Read and write Apple Numbers spreadsheets
 Home-page: https://github.com/masaccio/numbers-parser
 License: MIT
@@ -187,8 +187,8 @@ Whilst support for writing numbers files has been stable since version
 and instead save data to a new file.
 
 Cell values are written using
-[Table.write()](https://masaccio.github.io/numbers-parser/#numbers_parser.Table.write)
-and `numbers-parser` will automatically create empty rows and columns
+[Table.write()](https://masaccio.github.io/numbers-parser/api/table.html#numbers_parser.Table.write) and
+`numbers-parser` will automatically create empty rows and columns
 for any cell references that are out of range of the current table.
 
 ```python
@@ -201,12 +201,9 @@ table.write("B7", datetime(2020, 12, 25))
 doc.save("new-sheet.numbers")
 ```
 
-Additional tables and worksheets can be added to a `Document` before
-saving using
-[Document.add_sheet()](https://masaccio.github.io/numbers-parser/#numbers_parser.Document.add_sheet)
-and
-[Sheet.add_table()](https://masaccio.github.io/numbers-parser/#numbers_parser.Sheet.add_table)
-respectively:
+Additional tables and worksheets can be added to a `Document` before saving using
+[Document.add_sheet()](https://masaccio.github.io/numbers-parser/api/document.html#numbers_parser.Document.add_sheet) and
+[Sheet.add_table()](https://masaccio.github.io/numbers-parser/api/sheet.html#numbers_parser.Sheet.add_table) respectively:
 
 ```python
 doc = Document()
@@ -222,27 +219,28 @@ doc.save("sheet.numbers")
 ### Styles
 
 `numbers_parser` currently only supports paragraph styles and cell
-styles. The following paragraph styles are supported:
+styles. The following styles are supported:
 
 - font attributes: bold, italic, underline, strikethrough
 - font selection and size
 - text foreground color
 - horizontal and vertical alignment
 - cell background color
+- cell background images
 - cell indents (first line, left, right, and text inset)
 
 Numbers conflates style attributes that can be stored in paragraph
 styles (the style menu in the text panel) with the settings that are
 available on the Style tab of the Text panel. Some attributes in Numbers
-are not applied to new cells when a style is applied. To keep the API
-simple, `numbers-parser` packs all styling into a single
-[Style](https://masaccio.github.io/numbers-parser/api/style.html)
-object. When a document is saved, the attributes not stored in a
-paragraph style are applied to each cell that includes it.
+are not applied to new cells when a style is applied.
+
+To keep the API simple, `numbers-parser` packs all styling into a single
+[Style](https://masaccio.github.io/numbers-parser/api/style.html) object. When a document is saved, the attributes
+not stored in a paragraph style are applied to each cell that includes it.
 
 Styles are read from cells using the
-[Cell.style](https://masaccio.github.io/numbers-parser/api/cells.html#numbers_parser.Cell.style)
-property and you can add new styles with
+[Cell.style](https://masaccio.github.io/numbers-parser/api/cells.html#numbers_parser.Cell.style) property and you can
+add new styles with
 [Document.add_style](https://masaccio.github.io/numbers-parser/api/document.html#numbers_parser.Document.add_style).
 
 ```python
@@ -272,7 +270,7 @@ internally by the package. Changing a data format for cell has no impact
 on any other cells.
 
 Cell formats are changed using
-[Table.set_cell_formatting](https://masaccio.github.io/numbers-parser/#numbers_parser.Table.set_cell_formatting):
+[Table.set_cell_formatting()](https://masaccio.github.io/numbers-parser/api/table.html#numbers_parser.Table.set_cell_formatting):
 
 ```python
 table.set_cell_formatting(
@@ -293,9 +291,9 @@ Custom formats are shared across a Document and can be applied to
 multiple cells in multiple tables. Editing a custom format changes the
 appearance of data in all cells that share that format. You must first
 add a custom format to the document using
-[Document.add_custom_format](https://masaccio.github.io/numbers-parser/#numbers_parser.Document.add_custom_format)
+[Document.add_custom_format()](https://masaccio.github.io/numbers-parser/api/document.html#numbers_parser.Document.add_custom_format)
 before assigning it to cells using
-[Table.set_cell_formatting](https://masaccio.github.io/numbers-parser/#numbers_parser.Table.set_cell_formatting):
+[Table.set_cell_formatting()](https://masaccio.github.io/numbers-parser/api/table.html#numbers_parser.Table.set_cell_formatting):
 
 ```python
 long_date = doc.add_custom_format(
@@ -322,13 +320,11 @@ table to allow for drawing borders across multiple cells. Setting the
 border of merged cells is not possible unless the edge of the cells is
 at the end of the merged region.
 
-Borders are represented using the
-[Border](https://masaccio.github.io/numbers-parser/#numbers_parser.Border)
-class that can be initialized with line width, color and line style. The
+Borders are represented using the [Border](https://masaccio.github.io/numbers-parser/api/border.html) class
+that can be initialized with line width, color and line style. The
 current state of a cell border is read using the
-[Cell.border](https://masaccio.github.io/numbers-parser/#numbers_parser.Cell.border)
-property. The
-[Table.set_cell_border](https://masaccio.github.io/numbers-parser/#numbers_parser.Table.set_cell_border)
+[Cell.border](https://masaccio.github.io/numbers-parser/api/cells.html#numbers_parser.Cell.border) property
+and [Table.set_cell_border()](https://masaccio.github.io/numbers-parser/api/table.html#numbers_parser.Table.set_cell_border)
 sets the border for a cell edge or a range of cells.
 
 ## API
@@ -400,6 +396,5 @@ Current known limitations of `numbers-parser` are:
 
 ## License
 
-All code in this repository is licensed under the [MIT
-License](https://github.com/masaccio/numbers-parser/blob/master/LICENSE.rst)
+All code in this repository is licensed under the [MIT License](https://github.com/masaccio/numbers-parser/blob/master/LICENSE.rst).
 

{numbers_parser-4.8.1.dist-info → numbers_parser-4.9.0.dist-info}/RECORD

@@ -2,16 +2,16 @@ numbers_parser/__init__.py,sha256=hyoQ4x-1E8yDBMR128kZhSDLCfrnjNdz4_dEpKlekk4,19
 numbers_parser/_cat_numbers.py,sha256=-HboBJT11Vjcr8sjLZl7Z6qAapnPEc_kFYq6PTqON20,4619
 numbers_parser/_unpack_numbers.py,sha256=zfpBOfM92rMHSRQVR4tExf0fWI2Lbbb6WrwQPoq4gMo,5689
 numbers_parser/bullets.py,sha256=OnVVMPjhTDrC-ncw52Gb00UEXNmn2Rvd3xi7lfqW3hk,2616
-numbers_parser/cell.py,sha256=zXcxN1vtjZnE4jT2mc2bi5eqSrCsmbsx9G5wbr9rAuM,36384
-numbers_parser/cell_storage.py,sha256=_anyiHnG-pAZ9OTSdisT7lted9PGSzQcn_-xpsJVU0o,32873
-numbers_parser/constants.py,sha256=XFBGGFEHToU-DDrNxhtDsmqd4P0Yc6KiNdQAxzFCWqg,7477
-numbers_parser/containers.py,sha256=b9sOCBd60YjMxJ-s9u-erWusA3guHU-c1RAUqM8CyKs,4191
+numbers_parser/cell.py,sha256=YfHs1xxVSNY_oEodTN3IhqdO5tUhdgzZz5Z0m10dtpw,38457
+numbers_parser/cell_storage.py,sha256=jaGpleFg8xWPT3U-O4bczAMYFR54t3x920UBKcrUiOQ,34354
+numbers_parser/constants.py,sha256=BJGNz0ZZCs5xfAXlzLox4tvKOHIpDMXgJQ6i5yvdr4A,9606
+numbers_parser/containers.py,sha256=yR_T2yF5QiVj7Dg22nCMLvo___Xrec3j8kitbxiaWyU,4220
 numbers_parser/currencies.py,sha256=8k4a3WKmDoHeurkDICymHX13N7ManHSTaka_JNXCZYA,3767
 numbers_parser/data/empty.numbers,sha256=8JOp035V-p2ff9_Wao7mLcYvb6_if6O2cus_esjVA9k,90316
-numbers_parser/document.py,sha256=bjF0kjKh-Z2Z6H1Uwn1NVwx7b1URqNOXrjd60f4GjiI,49346
+numbers_parser/document.py,sha256=JmGyafm10FXnS5zmXkMTRVvYM-KnCKtcmbNCwMDyuSU,55333
 numbers_parser/exceptions.py,sha256=G8dASUQZI8ksHYRVfdGWJzgsJD5CBpcZvmDJUZTqT-c,670
 numbers_parser/experimental.py,sha256=WARjTa-2ePb8Ga8Q6oDP6EJCs12ofLRF2YpwzUu66ZI,374
-numbers_parser/file.py,sha256=ivcl5326TQXwj1GP9FCh-WiM_oXZumgQdByehAEw1f8,3966
+numbers_parser/file.py,sha256=buNbZRzQCIlr7H4JxwTh2_eh7oDA2fGH5ZiFpIEVHoo,4200
 numbers_parser/formula.py,sha256=JRsG0L21wS70oJ-FB46Amyoy-sKizWb-iUhSXUcVJ-U,10572
 numbers_parser/generated/TNArchives_pb2.py,sha256=txkTtPHvdXVvv7zO1dHCxxnixaFulK7hJVLQrH3cIJc,16007
 numbers_parser/generated/TNArchives_sos_pb2.py,sha256=AYI1X5t5Gb4l941jXlHEY0v97ToIze0bSYBR7KQmS0A,1215
@@ -50,11 +50,11 @@ numbers_parser/generated/fontmap.py,sha256=pqc1HwwTr3UbFMmhUaHJg1dX5-3pXbyhfS2bk
 numbers_parser/generated/functionmap.py,sha256=VdZo0ERMYONcrnJFwABcSCHb8pjA4wY2ogt8Janz57M,6082
 numbers_parser/iwafile.py,sha256=MuFIlB_hdXTTZflxoX_ZvA_68OaJkmRQ4eJ2UAiCKXQ,11833
 numbers_parser/mapping.py,sha256=in8W3S8DmTcPefFaxnATLw0FQ4YnFsnAE-cl5dljzJE,32215
-numbers_parser/model.py,sha256=ngC89eluYihQ-cRnqSKsZGn2LUNHyaEOneXploSG_po,98754
+numbers_parser/model.py,sha256=qvU0RRF4YgUcfhtRlDdRP09gl8rUY0GNgeHpOTJYvHk,103312
 numbers_parser/numbers_cache.py,sha256=1ghEBghQAYFpPiEeOtb74i016mXc039v1pOubbqvaLs,1141
 numbers_parser/numbers_uuid.py,sha256=-LeAj_ULC0va57pEmyegGY0xXqkNNjyuLukCaiQJhOk,2642
-numbers_parser-4.8.1.dist-info/LICENSE.rst,sha256=8vTa1-5KSdHrTpU9rlheO5005EWReEPMpjV7BjSaMc4,1050
-numbers_parser-4.8.1.dist-info/METADATA,sha256=k97XRQw49EhuCV3iHQG9tQ853HP8gnGISWgO93-F-Jk,16017
-numbers_parser-4.8.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-numbers_parser-4.8.1.dist-info/entry_points.txt,sha256=V91uB9vBPxf3eCY1h-0syv21imYCT0MJfMxf87DmwIk,115
-numbers_parser-4.8.1.dist-info/RECORD,,
+numbers_parser-4.9.0.dist-info/LICENSE.rst,sha256=8vTa1-5KSdHrTpU9rlheO5005EWReEPMpjV7BjSaMc4,1050
+numbers_parser-4.9.0.dist-info/METADATA,sha256=RWBbYXp1YHBV7Jj4Q6C_RwXIA_-JEi55l6o1A7G9r4w,16152
+numbers_parser-4.9.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+numbers_parser-4.9.0.dist-info/entry_points.txt,sha256=V91uB9vBPxf3eCY1h-0syv21imYCT0MJfMxf87DmwIk,115
+numbers_parser-4.9.0.dist-info/RECORD,,