numbers-parser 4.11.2__tar.gz → 4.11.4__tar.gz

{numbers_parser-4.11.2 → numbers_parser-4.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: numbers-parser
-Version: 4.11.2
+Version: 4.11.4
 Summary: Read and write Apple Numbers spreadsheets
 Home-page: https://github.com/masaccio/numbers-parser
 License: MIT

{numbers_parser-4.11.2 → numbers_parser-4.11.4}/pyproject.toml

@@ -12,7 +12,7 @@ name = "numbers-parser"
 packages = [{include = "numbers_parser", from = "src"}]
 readme = "README.md"
 repository = "https://github.com/masaccio/numbers-parser"
-version = "4.11.2"
+version = "4.11.4"
 
 [tool.poetry.scripts]
 cat-numbers = "numbers_parser._cat_numbers:main"

{numbers_parser-4.11.2 → numbers_parser-4.11.4}/src/numbers_parser/_unpack_numbers.py

@@ -125,7 +125,9 @@ def main():
     parser.add_argument("--hex-uuids", action="store_true", help="print UUIDs as hex")
     parser.add_argument("--pretty-storage", action="store_true", help="pretty print cell storage")
     parser.add_argument(
-        "--compact-json", action="store_true", help="Format JSON compactly as possible",
+        "--compact-json",
+        action="store_true",
+        help="Format JSON compactly as possible",
     )
     parser.add_argument("--pretty", action="store_true", help="Enable all prettifying options")
     parser.add_argument("--output", "-o", help="directory name to unpack into")
@@ -150,7 +152,7 @@ def main():
         else:
             logger.setLevel("ERROR")
         for document in args.document:
-            args.output or document.replace(".numbers", "")
+            output_dir = args.output or document.replace(".numbers", "")
             try:
                 iwork = IWork(
                     handler=NumbersUnpacker(
@@ -158,7 +160,7 @@ def main():
                         pretty=args.pretty,
                         pretty_storage=args.pretty_storage,
                         compact_json=args.compact_json,
-                        output_dir=args.output,
+                        output_dir=output_dir,
                     ),
                 )
                 iwork.open(Path(document))

{numbers_parser-4.11.2 → numbers_parser-4.11.4}/src/numbers_parser/document.py

@@ -989,13 +989,21 @@ class Table(Cacheable):
         self.num_rows += num_rows
         self._model.number_of_rows(self._table_id, self.num_rows)
 
-        row = [
-            Cell._empty_cell(self._table_id, self.num_rows - 1, col, self._model)
-            for col in range(self.num_cols)
-        ]
-        rows = [row.copy() for _ in range(num_rows)]
+        rows = []
+        for row in range(start_row, start_row + num_rows):
+            rows.append(
+                [
+                    Cell._empty_cell(self._table_id, row, col, self._model)
+                    for col in range(self.num_cols)
+                ]
+            )
         self._data[start_row:start_row] = rows
 
+        for row in range(start_row, self.num_rows):
+            for col in range(self.num_cols):
+                self._data[row][col].row = row
+                self._data[row][col].col = col
+
         if default is not None:
             for row in range(start_row, start_row + num_rows):
                 for col in range(self.num_cols):
@@ -1045,10 +1053,14 @@ class Table(Cacheable):
 
         for row in range(self.num_rows):
             cols = [
-                Cell._empty_cell(self._table_id, row, col, self._model) for col in range(num_cols)
+                Cell._empty_cell(self._table_id, row, start_col + col, self._model)
+                for col in range(num_cols)
             ]
             self._data[row][start_col:start_col] = cols
 
+            for col in range(len(self._data[row])):
+                self._data[row][col].col = col
+
             if default is not None:
                 for col in range(start_col, start_col + num_cols):
                     self.write(row, col, default)
@@ -1091,6 +1103,12 @@ class Table(Cacheable):
         self.num_rows -= num_rows
         self._model.number_of_rows(self._table_id, self.num_rows)
 
+        if start_row is not None:
+            for row in range(start_row, self.num_rows):
+                for col in range(self.num_cols):
+                    self._data[row][col].row = row
+                    self._data[row][col].col = col
+
     def delete_column(
         self,
         num_cols: Optional[int] = 1,
@@ -1120,6 +1138,8 @@ class Table(Cacheable):
                 del self._data[row][start_col : start_col + num_cols]
             else:
                 del self._data[row][-num_cols:]
+            for col in range(len(self._data[row])):
+                self._data[row][col].col = col
 
         self.num_cols -= num_cols
         self._model.number_of_columns(self._table_id, self.num_cols)

{numbers_parser-4.11.2 → numbers_parser-4.11.4}/src/numbers_parser/model.py

@@ -2,6 +2,7 @@ import re
 from array import array
 from collections import defaultdict
 from hashlib import sha1
+from math import floor
 from pathlib import Path
 from struct import pack
 from typing import Dict, List, Optional, Tuple, Union
@@ -853,10 +854,7 @@ class _NumbersModel(Cacheable):
 
         for col, cells in enumerate(col_data):
             num_rows = len(cells) - sum([isinstance(x, MergedCell) for x in cells])
-            if table_id in self._col_widths and col in self._col_widths[table_id]:
-                width = self._col_widths[table_id][col]
-            else:
-                width = current_column_widths[col]
+            width = current_column_widths[col]
             header = TSTArchives.HeaderStorageBucket.Header(
                 index=col,
                 numberOfCells=num_rows,
@@ -1040,7 +1038,7 @@ class _NumbersModel(Cacheable):
         height = 0.0
         for row in range(self.number_of_rows(table_id)):
             height += self.row_height(table_id, row)
-        return round(height)
+        return floor(height)
 
     def row_height(self, table_id: int, row: int, height: Optional[int] = None) -> int:
         if height is not None:
@@ -1058,9 +1056,34 @@ class _NumbersModel(Cacheable):
         buckets = self.objects[bucket_id].headers
         bucket_map = {x.index: x for x in buckets}
         if row in bucket_map and bucket_map[row].size != 0.0:
-            return round(bucket_map[row].size)
+            height = round(bucket_map[row].size)
         else:
-            return round(table_model.default_row_height)
+            height = round(table_model.default_row_height)
+
+        data = self._table_data[table_id]
+        max_top_border = max(
+            [0.0]
+            + [
+                data[row][col].border.top.width
+                for col in range(len(data[row]))
+                if data[row][col].border.top is not None
+            ]
+        )
+        max_bottom_border = max(
+            [0.0]
+            + [
+                data[row][col].border.bottom.width
+                for col in range(len(data[row]))
+                if data[row][col].border.bottom is not None
+            ]
+        )
+        height += max_top_border / 2
+        height += max_bottom_border / 2
+
+        if table_id not in self._row_heights:
+            self._row_heights[table_id] = {}
+        self._row_heights[table_id][row] = floor(height)
+        return self._row_heights[table_id][row]
 
     def table_width(self, table_id: int) -> int:
         """Return the width of a table in points."""
@@ -1085,9 +1108,34 @@ class _NumbersModel(Cacheable):
         buckets = self.objects[bucket_id].headers
         bucket_map = {x.index: x for x in buckets}
         if col in bucket_map and bucket_map[col].size != 0.0:
-            return round(bucket_map[col].size)
+            width = round(bucket_map[col].size)
         else:
-            return round(table_model.default_column_width)
+            width = round(table_model.default_column_width)
+
+        data = self._table_data[table_id]
+        max_left_border = max(
+            [0.0]
+            + [
+                data[row][col].border.left.width
+                for row in range(len(data))
+                if data[row][col].border.left is not None
+            ]
+        )
+        max_right_border = max(
+            [0.0]
+            + [
+                data[row][col].border.right.width
+                for row in range(len(data))
+                if data[row][col].border.right is not None
+            ]
+        )
+        width += max_left_border / 2
+        width += max_right_border / 2
+
+        if table_id not in self._col_widths:
+            self._col_widths[table_id] = {}
+        self._col_widths[table_id][col] = floor(width)
+        return self._col_widths[table_id][col]
 
     def num_header_rows(self, table_id: int, num_headers: Optional[int] = None) -> int:
         """Return/set the number of header rows."""
@@ -1190,6 +1238,44 @@ class _NumbersModel(Cacheable):
             "Tables/HeaderStorageBucket-{}",
         )
 
+        # caption_storage_id, caption_storage = self.objects.create_object_from_dict(
+        #     "CalculationEngine",
+        #     {"text": ["TEST Caption"]},
+        #     TSWPArchives.StorageArchive,
+        # )
+        # caption_info_id, caption_info = self.objects.create_object_from_dict(
+        #     "CalculationEngine",
+        #     {},
+        #     TSAArchives.CaptionInfoArchive,
+        # )
+        # # caption_info.super.MergeFrom(TSWPArchives.ShapeInfoArchive())
+        # # caption_info.super.super.MergeFrom(TSDArchives.ShapeArchive())
+        # # caption_info.super.super.super.MergeFrom(TSDArchives.DrawableArchive())
+        # from_table_info = self.objects[self.table_info_id(from_table_id)]
+        # from_caption_info = self.objects[from_table_info.super.caption.identifier]
+        # caption_info.super.CopyFrom(from_caption_info.super)
+        # caption_info.super.super.CopyFrom(from_caption_info.super.super)
+        # caption_info.super.super.super.CopyFrom(from_caption_info.super.super.super)
+        # caption_info.super.deprecated_storage.MergeFrom(
+        #     TSPMessages.Reference(identifier=caption_storage_id)
+        # )
+        # caption_info.super.owned_storage.MergeFrom(
+        #     TSPMessages.Reference(identifier=caption_storage_id)
+        # )
+
+        # TST.TableModelArchive.stroke_sidecar -> TST.StrokeSidecarArchive
+        # TST.StrokeSidecarArchive
+        #    top_row_stroke_layers -> [TST.StrokeLayerArchive]
+        #    left_row_stroke_layers -> [TST.StrokeLayerArchive]
+        #    right_row_stroke_layers -> [TST.StrokeLayerArchive]
+        #    bottom_row_stroke_layers -> [TST.StrokeLayerArchive]
+        sidecar_id, _ = self.objects.create_object_from_dict(
+            "CalculationEngine",
+            {"max_order": 1, "column_count": 0, "row_count": 0},
+            TSTArchives.StrokeSidecarArchive,
+        )
+        table_model.stroke_sidecar.MergeFrom(TSPMessages.Reference(identifier=sidecar_id))
+
         style_table_id, _ = self.objects.create_object_from_dict(
             "Index/Tables/DataList-{}",
             {"listType": TSTArchives.TableDataList.ListType.STYLE, "nextListID": 1},
@@ -1255,11 +1341,11 @@ class _NumbersModel(Cacheable):
             TSPMessages.Reference(identifier=row_headers_id),
         )
 
-        data = [
+        self._table_data[table_model_id] = [
             [Cell._empty_cell(table_model_id, row, col, self) for col in range(num_cols)]
             for row in range(num_rows)
         ]
-        self.recalculate_table_data(table_model_id, data)
+        self.recalculate_table_data(table_model_id, self._table_data[table_model_id])
 
         table_info_id, table_info = self.objects.create_object_from_dict(
             "CalculationEngine",
@@ -1268,6 +1354,10 @@ class _NumbersModel(Cacheable):
         )
         table_info.tableModel.MergeFrom(TSPMessages.Reference(identifier=table_model_id))
         table_info.super.MergeFrom(self.create_drawable(sheet_id, x, y))
+        # caption_info.super.super.super.parent.MergeFrom(
+        #     TSPMessages.Reference(identifier=table_info_id)
+        # )
+        # table_info.super.caption.MergeFrom(TSPMessages.Reference(identifier=caption_info_id))
         self.add_component_reference(table_info_id, "Document", self.calc_engine_id())
 
         self.add_formula_owner(
@@ -1982,21 +2072,33 @@ class _NumbersModel(Cacheable):
                 cell._border.top = border_value
             if (cell := self.cell_for_stroke(table_id, "bottom", row - 1, col)) is not None:
                 cell._border.bottom = border_value
+            if table_id in self._row_heights:
+                self._row_heights[table_id].pop(row, None)
+                self._row_heights[table_id].pop(row - 1, None)
         elif side == "right":
             if (cell := self.cell_for_stroke(table_id, "right", row, col)) is not None:
                 cell._border.right = border_value
             if (cell := self.cell_for_stroke(table_id, "left", row, col + 1)) is not None:
                 cell._border.left = border_value
+            if table_id in self._col_widths:
+                self._col_widths[table_id].pop(col, None)
+                self._col_widths[table_id].pop(col + 1, None)
         elif side == "bottom":
             if (cell := self.cell_for_stroke(table_id, "bottom", row, col)) is not None:
                 cell._border.bottom = border_value
             if (cell := self.cell_for_stroke(table_id, "top", row + 1, col)) is not None:
                 cell._border.top = border_value
+            if table_id in self._row_heights:
+                self._row_heights[table_id].pop(row, None)
+                self._row_heights[table_id].pop(row + 1, None)
         else:  # left border
             if (cell := self.cell_for_stroke(table_id, "left", row, col)) is not None:
                 cell._border.left = border_value
             if (cell := self.cell_for_stroke(table_id, "right", row, col - 1)) is not None:
                 cell._border.right = border_value
+            if table_id in self._col_widths:
+                self._col_widths[table_id].pop(col, None)
+                self._col_widths[table_id].pop(col - 1, None)
 
     def extract_strokes_in_layers(self, table_id: int, layer_ids: List, side: str):
         for layer_id in layer_ids: