numbers-parser 4.17.0.post1__py3-none-any.whl → 4.18.1__py3-none-any.whl

numbers_parser/model.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import re
 from array import array
 from collections import defaultdict
+from datetime import timedelta
 from hashlib import sha1
 from itertools import chain
 from math import floor
@@ -32,6 +33,7 @@ from numbers_parser.cell import (
     PaddingType,
     Style,
     VerticalJustification,
+    _decode_date_format,
 )
 from numbers_parser.constants import (
     ALLOWED_FORMATTING_PARAMETERS,
@@ -47,6 +49,7 @@ from numbers_parser.constants import (
     DEFAULT_TEXT_WRAP,
     DEFAULT_TILE_SIZE,
     DOCUMENT_ID,
+    EPOCH,
     FORMAT_TYPE_MAP,
     MAX_TILE_SIZE,
     PACKAGE_ID,
@@ -233,6 +236,8 @@ class _NumbersModel(Cacheable):
         self._control_specs = DataLists(self, "control_cell_spec_table", "cell_spec")
         self._formulas = DataLists(self, "formula_table", "formula")
         self._table_data = {}
+        self._table_categories_data = {}
+        self._table_categories_row_mapper = {}
         self._styles = None
         self._images = {}
         self._custom_formats = None
@@ -807,38 +812,6 @@ class _NumbersModel(Cacheable):
         # Table can be empty if the document does not use FormulaOwnerDependenciesArchive
         return self._table_id_to_base_id.get(table_id)
 
-    def get_formula_owner(self, table_id: int) -> object:
-        table_uuid = self.table_base_id(table_id)
-        return self.objects[self._table_base_id_to_formula_owner_id[table_uuid]]
-
-    def add_formula_dependency(self, row: int, col: int, table_id: int) -> None:
-        calc_engine = self.calc_engine()
-        calc_engine.dependency_tracker.number_of_formulas += 1
-        internal_formula_id = calc_engine.dependency_tracker.number_of_formulas
-
-        formula_owner = self.get_formula_owner(table_id)
-        formula_owner.cell_dependencies.cell_record.append(
-            TSCEArchives.CellRecordExpandedArchive(column=col, row=row),
-        )
-        if len(formula_owner.tiled_cell_dependencies.cell_record_tiles) == 0:
-            cell_record_id, cell_record = self.objects.create_object_from_dict(
-                "CalculationEngine",
-                {
-                    "internal_owner_id": internal_formula_id,
-                    "tile_column_begin": 0,
-                    "tile_row_begin": 0,
-                },
-                TSCEArchives.CellRecordTileArchive,
-            )
-            formula_owner.tiled_cell_dependencies.cell_record_tiles.append(
-                TSPMessages.Reference(identifier=cell_record_id),
-            )
-        else:
-            cell_record_id = formula_owner.tiled_cell_dependencies.cell_record_tiles[0].identifier
-            cell_record = self.objects[cell_record_id]
-
-        cell_record.cell_records.append(formula_owner.cell_dependencies.cell_record[-1])
-
     @cache(num_args=0)
     def calc_engine_id(self):
         """Return the CalculationEngine ID for the current document."""
@@ -867,7 +840,7 @@ class _NumbersModel(Cacheable):
         self._merge_cells[table_id].add_anchor(row_start, col_start, size)
 
     @cache()
-    def calculate_new_merge_cell_ranges(self, table_id) -> None:
+    def calculate_merges_using_formula_stores(self, table_id) -> None:
         table_model = self.objects[table_id]
         formulas = table_model.merge_owner.formula_store.formulas
         if len(formulas) == 0:
@@ -887,7 +860,7 @@ class _NumbersModel(Cacheable):
             )
 
     @cache()
-    def calculate_merge_cell_ranges(self, table_id) -> None:
+    def calculate_merges_using_dependency_archives(self, table_id) -> None:
         """Extract all the merge cell ranges for the Table."""
         # See details in Numbers.md#merge-ranges.
         owner_id_map = self.owner_id_map()
@@ -910,6 +883,8 @@ class _NumbersModel(Cacheable):
                         record_range.bottom_right_column,
                     )
 
+    @cache()
+    def calculate_merges_using_region_map(self, table_id) -> None:
         base_data_store = self.objects[table_id].base_data_store
         if base_data_store.merge_region_map.identifier == 0:
             return
@@ -926,18 +901,12 @@ class _NumbersModel(Cacheable):
             )
             row_end = row_start + num_rows - 1
             col_end = col_start + num_columns - 1
-            for row in range(row_start, row_end + 1):
-                for col in range(col_start, col_end + 1):
-                    self._merge_cells[table_id].add_reference(
-                        row,
-                        col,
-                        (row_start, col_start, row_end, col_end),
-                    )
-            self._merge_cells[table_id].add_anchor(row_start, col_start, (num_rows, num_columns))
+            self.add_merge_range(table_id, row_start, row_end, col_start, col_end)
 
     def merge_cells(self, table_id):
-        self.calculate_new_merge_cell_ranges(table_id)
-        self.calculate_merge_cell_ranges(table_id)
+        self.calculate_merges_using_formula_stores(table_id)
+        self.calculate_merges_using_dependency_archives(table_id)
+        self.calculate_merges_using_region_map(table_id)
         return self._merge_cells[table_id]
 
     def table_id_to_sheet_id(self, table_id: int) -> int:
@@ -946,25 +915,14 @@ class _NumbersModel(Cacheable):
                 return sheet_id
         return None
 
-    def table_name_to_uuid(self, sheet_name: str, table_name: str) -> str:
-        table_ids = [tid for tid in self.table_ids() if table_name == self.table_name(tid)]
-        if len(table_ids) == 1:
-            return self.table_base_id(table_ids[0])
-
-        sheet_name_to_id = {self.sheet_name(x): x for x in self.sheet_ids()}
-        sheet_id = sheet_name_to_id[sheet_name]
-        table_name_to_id = {self.table_name(x): x for x in self.table_ids(sheet_id)}
-        table_id = table_name_to_id[table_name]
-        return self.table_base_id(table_id)
-
     @cache()
     def table_uuids_to_id(self, table_uuid) -> int | None:
-        for sheet_id in self.sheet_ids():  # pragma: no branch
+        for sheet_id in self.sheet_ids():  # pragma: no branch  # noqa: RET503
             for table_id in self.table_ids(sheet_id):
                 if table_uuid == self.table_base_id(table_id):
                     return table_id
 
-    def node_to_ref(self, table_id: int, row: int, col: int, node, merge_mode: bool = False):
+    def node_to_ref(self, table_id: int, row: int, col: int, node):
         def resolve_range(is_absolute, absolute_list, relative_list, offset, max_val):
             if is_absolute:
                 return absolute_list[0].range_begin
@@ -1030,7 +988,6 @@ class _NumbersModel(Cacheable):
                 col_end_is_abs=node.AST_sticky_bits.end_column_is_absolute,
                 from_table_id=table_id,
                 to_table_id=to_table_id,
-                _do_init=not merge_mode,
             )
 
         row = node.AST_row.row if node.AST_row.absolute else row + node.AST_row.row
@@ -1510,7 +1467,7 @@ class _NumbersModel(Cacheable):
             },
             TSTArchives.TableModelArchive,
         )
-        # Supresses Numbers assertions for tables sharing the same data
+        # Suppress Numbers assertions for tables sharing the same data
         table_model.category_owner.identifier = 0
 
         column_headers_id, column_headers = self.objects.create_object_from_dict(
@@ -1719,7 +1676,7 @@ class _NumbersModel(Cacheable):
             "bottom_right_column": 0x7FFF,
             "bottom_right_row": 0x7FFFFFFF,
         }
-        spanning_depdendencies = {
+        spanning_dependencies = {
             "total_range_for_table": null_range_ref,
             "body_range_for_table": null_range_ref,
         }
@@ -1732,8 +1689,8 @@ class _NumbersModel(Cacheable):
                 "cell_dependencies": {},
                 "range_dependencies": {},
                 "volatile_dependencies": volatile_dependencies,
-                "spanning_column_dependencies": spanning_depdendencies,
-                "spanning_row_dependencies": spanning_depdendencies,
+                "spanning_column_dependencies": spanning_dependencies,
+                "spanning_row_dependencies": spanning_dependencies,
                 "whole_owner_dependencies": {"dependent_cells": {}},
                 "cell_errors": {},
                 "base_owner_uid": base_owner_uuid.dict2,
@@ -1809,7 +1766,7 @@ class _NumbersModel(Cacheable):
             for k, v in presets_map.items()
         }
         for style in styles.values():
-            # Override __setattr__ behaviour for builtin styles
+            # Override __setattr__ behavior for builtin styles
             style.__dict__["_update_text_style"] = False
             style.__dict__["_update_cell_style"] = False
         return styles
@@ -2142,7 +2099,7 @@ class _NumbersModel(Cacheable):
         # a string with a new bullet character
         bds = self.objects[table_id].base_data_store
         rich_text_table = self.objects[bds.rich_text_table.identifier]
-        for entry in rich_text_table.entries:  # pragma: no branch
+        for entry in rich_text_table.entries:  # pragma: no branch  # noqa: RET503
             if string_key == entry.key:
                 payload = self.objects[entry.rich_text_payload.identifier]
                 payload_storage = self.objects[payload.storage.identifier]
@@ -2596,107 +2553,160 @@ class _NumbersModel(Cacheable):
         # datas never appears to be an empty list (default themes include images)
         return max(image_ids) + 1
 
-    def table_category_data(self, table_id: int) -> dict | None:
+    @classmethod
+    def cell_value_to_key(
+        cls,
+        cell_value: TSCEArchives.CellValueArchive,
+    ) -> str | int | bool | datetime:
+        """Convert a CellValueArchive to a key."""
+        cell_value_type = cell_value.cell_value_type
+        if cell_value_type == CellValueType.STRING_TYPE:
+            return cell_value.string_value.value
+        if cell_value_type == CellValueType.NUMBER_TYPE:
+            return cell_value.number_value.value
+        if cell_value_type == CellValueType.BOOLEAN_TYPE:
+            return cell_value.boolean_value.value
+        if cell_value_type == CellValueType.DATE_TYPE:
+            # "yyyy"
+            # "yyyy-QQQ"
+            # "LLLL yyyy"
+            # "yyyy'-W'w"
+            # "d/M/yyyy"
+            # "EEEE"
+            return _decode_date_format(
+                cell_value.date_value.format.date_time_format,
+                EPOCH + timedelta(seconds=cell_value.date_value.value),
+            )
+        return None
+
+    @cache(num_args=0)
+    def group_uuid_values(self):
+        return {
+            NumbersUUID(self.objects[_id].group_uid): _NumbersModel.cell_value_to_key(
+                self.objects[_id].group_cell_value,
+            )
+            for _id in self.find_refs("GroupNodeArchive")
+        }
+
+    @cache()
+    def calculate_table_categories(self, table_id: int) -> tuple[dict[int, int], dict] | None:
         category_owner_id = self.objects[table_id].category_owner.identifier
+        if not category_owner_id:
+            self._table_categories_data[table_id] = None
+            self._table_categories_row_mapper[table_id] = None
+            return
+
         category_archive_id = self.objects[category_owner_id].group_by[0].identifier
         category_archive = self.objects[category_archive_id]
         if not category_archive.is_enabled:
-            return None
+            self._table_categories_data[table_id] = None
+            self._table_categories_row_mapper[table_id] = None
+            return
 
         table_info = self.objects[self.table_info_id(table_id)]
         category_order = self.objects[table_info.category_order.identifier]
         row_uid_map = self.objects[category_order.uid_map.identifier]
-        sorted_row_uuids = [
-            NumbersUUID(row_uid_map.sorted_row_uids[i]).hex for i in row_uid_map.row_uid_for_index
-        ]
 
-        data = self._table_data[table_id]
-        header = [cell.value for cell in data[0]]
-
-        def index_set_to_offsets(index_set: TSCEArchives.IndexSetArchive) -> list[int]:
-            """Convert an IndexSetArchive to a list of offsets."""
-            offsets = []
-            for entry in index_set.entries:
-                if entry.HasField("range_end"):
-                    offsets += list(range(entry.range_begin, entry.range_end + 1))
-                else:
-                    offsets += list(range(entry.range_begin, entry.range_begin + 1))
-            return offsets
-
-        def cell_value_to_key(
-            cell_value: TSCEArchives.CellValueArchive,
-        ) -> str | int | bool | datetime:
-            """Convert a CellValueArchive to a key."""
-            cell_value_type = cell_value.cell_value_type
-            if cell_value_type == CellValueType.STRING_TYPE:
-                return cell_value.string_value.value
-            if cell_value_type == CellValueType.NUMBER_TYPE:
-                return cell_value.number_value.value
-            if cell_value_type == CellValueType.BOOLEAN_TYPE:
-                return cell_value.boolean_value.value
-            # Must be DATE_TYPE
-            return cell_value.date_value.value
-
-        group_node_to_key = {
-            NumbersUUID(self.objects[_id].group_uid).hex: cell_value_to_key(
-                self.objects[_id].group_cell_value,
-            )
-            for _id in self.find_refs("GroupNodeArchive")
+        group_uuids = self.group_uuid_values()
+        row_uuid_to_offset = {
+            NumbersUUID(uuid): row for row, uuid in enumerate(category_archive.row_uid_lookup.uuids)
         }
-        group_uuids = [NumbersUUID(x.group_uid).hex for x in category_archive.group_node_root.child]
-        group_uuids = [uuid for uuid in sorted_row_uuids if uuid in group_uuids]
+        row_uid_for_index = [
+            NumbersUUID(row_uid_map.sorted_row_uids[i]) for i in row_uid_map.row_uid_for_index
+        ]
 
-        def group_hierarchy(parent: str, children: list):
-            nodes = {}
+        def parent_relationships(parent: NumbersUUID, children: list, group_parents: dict):
             for child in children:
-                group_uuid = NumbersUUID(child.group_uid).hex
+                child_uuid = NumbersUUID(child.group_uid)
+                group_parents[child_uuid] = parent
                 if len(child.child) > 0:
-                    nodes[group_uuid] = group_hierarchy(group_uuid, child.child)
-                else:
-                    nodes[group_uuid] = None
-            return nodes
-
-        def assign_rows_to_categories(parent: str, children: list, categories: dict):
-            for child in children:
-                group_uuid = NumbersUUID(child.group_uid).hex
-                if len(child.child) == 0:
-                    key = cell_value_to_key(child.group_cell_value)
-
-                    row_offsets = index_set_to_offsets(child.row_lookup_uids)
-                    categories[group_uuid] = {
-                        "key": key,
-                        "parent": parent,
-                        "rows": [
-                            {header[col]: cell.value for col, cell in enumerate(data[row])}
-                            for row in row_offsets
-                        ],
+                    parent_relationships(child_uuid, child.child, group_parents)
+
+        group_parents = {}
+        parent_relationships(None, category_archive.group_node_root.child, group_parents)
+
+        row = 0
+        row_mapper = {}
+        header = []
+        in_header = True
+
+        nodes: dict[NumbersUUID, dict] = {}
+        root_children: dict = {}
+        stack: list[NumbersUUID | None] = []
+        # rows that are not in any group (rare) kept here
+        root_rows: list = []
+
+        for uuid in row_uid_for_index:
+            if uuid in group_uuids:
+                # this UUID is a group heading
+                in_header = False
+                parent = group_parents.get(uuid)
+
+                # ensure node exists
+                if uuid not in nodes:
+                    nodes[uuid] = {
+                        "key": group_uuids[uuid],
+                        "children": {},
+                        "rows": [],
                     }
-                else:
-                    categories[group_uuid] = {
-                        "key": group_node_to_key[group_uuid],
-                        "parent": parent,
-                        "rows": None,
-                    }
-                    assign_rows_to_categories(group_uuid, child.child, categories)
-
-        category_tree = group_hierarchy(
-            NumbersUUID(category_archive.group_node_root.group_uid).hex,
-            category_archive.group_node_root.child,
-        )
 
-        categories = {}
-        assign_rows_to_categories(None, category_archive.group_node_root.child, categories)
-
-        def merge_trees(a: dict, b: dict):
-            new_tree = {}
-            for k, v in a.items():
-                if v is not None:
-                    new_tree[b[k]["key"]] = merge_trees(v, b)
+                # attach node to its parent (or root)
+                if parent is None:
+                    if nodes[uuid]["key"] not in root_children:
+                        root_children[nodes[uuid]["key"]] = nodes[uuid]
                 else:
-                    new_tree[b[k]["key"]] = b[k]["rows"]
-            return new_tree
-
-        return merge_trees(category_tree, categories)
+                    if parent not in nodes:
+                        nodes[parent] = {
+                            "key": group_uuids[parent],
+                            "children": {},
+                            "rows": [],
+                        }
+                    parent_node = nodes[parent]
+                    if nodes[uuid]["key"] not in parent_node["children"]:
+                        parent_node["children"][nodes[uuid]["key"]] = nodes[uuid]
+
+                # update stack to current nesting (pop until parent is on top)
+                while stack and stack[-1] != parent:
+                    stack.pop()
+                stack.append(uuid)
+            else:
+                mapped_row = row_uuid_to_offset[uuid]
+                if in_header:
+                    header.append(self._table_data[table_id][mapped_row])
+                # assign this row to the deepest open group, or root
+                elif stack:
+                    nodes[stack[-1]]["rows"].append(self._table_data[table_id][mapped_row])
+                else:
+                    root_rows.append(self._table_data[table_id][mapped_row])
+
+                row_mapper[row] = mapped_row
+                row += 1
+
+        # helper to convert node dicts to nested mapping (keys -> children or rows)
+        def node_to_structure(node: dict):
+            if not node["children"]:
+                return node["rows"]
+            out = {}
+            for child_key, child_node in node["children"].items():
+                out[child_key] = node_to_structure(child_node)
+            # if this node also has rows in addition to children, include them under a special key
+            if node["rows"]:
+                out["_rows"] = node["rows"]
+            return out
+
+        maximally_nested = {}
+        for key, node in root_children.items():
+            maximally_nested[key] = node_to_structure(node)
+        if root_rows:
+            maximally_nested["_rows"] = root_rows
+
+        self._table_categories_data[table_id] = maximally_nested
+        self._table_categories_row_mapper[table_id] = {
+            row: row_uuid_to_offset[uuid]
+            for row, uuid in enumerate(
+                uuid for uuid in row_uid_for_index if uuid not in group_uuids
+            )
+        }
 
 
 def rgb(obj) -> RGB:

numbers_parser/xrefs.py

@@ -67,8 +67,6 @@ class CellRange:
     _table_names: list[str] = field(init=False, default=None, repr=False)
 
     def __post_init__(self):
-        if not self._do_init:
-            return
         if self._table_names is None:
             self._initialize_table_data()
         self.model.name_ref_cache.refresh()