numbers-parser 4.18.0__tar.gz → 4.18.1__tar.gz

{numbers_parser-4.18.0/src/numbers_parser.egg-info → numbers_parser-4.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numbers-parser
-Version: 4.18.0
+Version: 4.18.1
 Summary: Read and write Apple Numbers spreadsheets
 Author-email: Jon Connell <python@figsandfudge.com>
 License-Expression: MIT

{numbers_parser-4.18.0 → numbers_parser-4.18.1}/pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
 description = "Read and write Apple Numbers spreadsheets"
 name = "numbers-parser"
 readme = "README.md"
-version = "4.18.0"
+version = "4.18.1"
 
 [project.urls]
 repository = "https://github.com/masaccio/numbers-parser"
@@ -197,5 +197,5 @@ ban-relative-imports = "all"
 "src/build/**" = ["PLR2004", "INP001", "PTH"]
 "src/build/protodump.py" = ["PLR2004", "INP001", "PTH", "S110", "N806"]
 "src/debug/**" = ["INP001"]
-"tests/**" = ["PLR2004", "S101", "D103", "ANN201", "ANN001"]
+"tests/**" = ["PLR2004", "S101", "D103", "ANN201", "ANN001", "DTZ001"]
 

{numbers_parser-4.18.0 → numbers_parser-4.18.1}/src/numbers_parser/constants.py

@@ -121,6 +121,7 @@ def _week_of_month(value: datetime) -> int:
 
 DATETIME_FIELD_MAP = OrderedDict(
     [
+        # Cell formats
         ("a", lambda x: x.strftime("%p").lower()),
         ("EEEE", "%A"),
         ("EEE", "%a"),
@@ -157,6 +158,10 @@ DATETIME_FIELD_MAP = OrderedDict(
         ("SSS", lambda x: str(x.microsecond).zfill(6)[0:3]),
         ("SSSS", lambda x: str(x.microsecond).zfill(6)[0:4]),
         ("SSSSS", lambda x: str(x.microsecond).zfill(6)[0:5]),
+        # Table category formats
+        ("QQQ", lambda x: "Q" + str(int(x.month / 3) + 1)),
+        ("LLLL", "%B"),
+        ("w", "%-W"),
     ],
 )
 

{numbers_parser-4.18.0 → numbers_parser-4.18.1}/src/numbers_parser/document.py

@@ -756,7 +756,9 @@ class Table(Cacheable):
             msg = f"column {col} out of range"
             raise IndexError(msg)
 
-        if (row_mapper := self._model.table_category_row_map(self._table_id)) is not None:
+        self._model.calculate_table_categories(self._table_id)
+        row_mapper = self._model._table_categories_row_mapper[self._table_id]
+        if row_mapper is not None:
             return self._data[row_mapper[row]][col]
         return self._data[row][col]
 
@@ -824,7 +826,9 @@ class Table(Cacheable):
             raise IndexError(msg)
 
         rows = self.rows()
-        if (row_mapper := self._model.table_category_row_map(self._table_id)) is not None:
+        self._model.calculate_table_categories(self._table_id)
+        row_mapper = self._model._table_categories_row_mapper[self._table_id]
+        if row_mapper is not None:
             rows = [rows[row_mapper[row]] for row in range(min_row, max_row + 1)]
         else:
             rows = rows[min_row : max_row + 1]
@@ -899,7 +903,9 @@ class Table(Cacheable):
             raise IndexError(msg)
 
         rows = self.rows()
-        if (row_mapper := self._model.table_category_row_map(self._table_id)) is not None:
+        self._model.calculate_table_categories(self._table_id)
+        row_mapper = self._model._table_categories_row_mapper[self._table_id]
+        if row_mapper is not None:
             rows = [rows[row_mapper[row_num]] for row_num in range(min_row, max_row + 1)]
         else:
             rows = rows[min_row : max_row + 1]
@@ -1011,33 +1017,60 @@ class Table(Cacheable):
             msg = "style must be a Style object or style name"
             raise TypeError(msg)
 
-    def categorized_data(self) -> dict | None:
+    def categorized_data(self, values_only: bool = False) -> dict | None:
         """
         Return the table's data organized into categories, if enabled or ``None``
         if the table has not had categories enabled.
 
-        The data is a dictionary with the category names as keys and a list
-        dictionaries for each row in that category of the table. The table heading
-        row is used as the keys for the row dictionary.
+        The data is a set of nested dictionaries and lists. Dictionary keys are
+        Category keys and values are either another dictionary in the case of
+        nested categories or a list of rows. Each row is itself a list such that
+        the data is the same as returned by :py:meth:`numbers_parser.Table.rows`.
+
+        Parameters
+        ----------
+        values_only:
+            If ``True``, return cell values instead of :class:`Cell` objects
+
+        Returns
+        -------
+        Dict[str, Dict | List]:
+            Nested dictionary of lists of rows or dictionaries of the next group
+            of categories down. Row data is returned as :py:class:`Cell` classes
+            unless ``values_only`` is ``True``.
 
         Example
         -------
         .. code:: python
 
             "Transport": [
-                {"Description": "Airplane", "Category": "Transport" },
-                {"Description": "Bicycle", "Category": "Transport" },
-                {"Description": "Bus", "Category": "Transport"},
+                {"Airplane", "Air": 5 },
+                {"Helicopter": "Air", 2 },
+                {"Bus": "Road", 10 },
             ],
             "Fruit": [
-                {"Description": "Apple", "Category": "Fruit" },
-                {"Description": "Banana", "Category": "Fruit" },
+                {"Apple", "Green": 7 },
+                {"Banana", "Yellow", 6 },
             ],
 
         For tables with multiple categories, the top-level dictionary is nested.
 
         """
-        return self._model.table_category_data(self._table_id)
+
+        def data_to_values(item):
+            if isinstance(item, dict):
+                return {k: data_to_values(v) for k, v in item.items()}
+
+            if isinstance(item, list):
+                return [data_to_values(v) for v in item]
+
+            return item.value
+
+        self._model.calculate_table_categories(self._table_id)
+        data = self._model._table_categories_data[self._table_id]
+        if values_only:
+            return data_to_values(data)
+        return data
 
     def add_row(
         self,

{numbers_parser-4.18.0 → numbers_parser-4.18.1}/src/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
@@ -2561,8 +2566,18 @@ class _NumbersModel(Cacheable):
             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
+        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):
@@ -2574,14 +2589,19 @@ class _NumbersModel(Cacheable):
         }
 
     @cache()
-    def table_category_row_map(self, table_id: int) -> dict[int, int] | None:
+    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:
-            return None
+            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]
@@ -2594,101 +2614,99 @@ class _NumbersModel(Cacheable):
         row_uid_for_index = [
             NumbersUUID(row_uid_map.sorted_row_uids[i]) for i in row_uid_map.row_uid_for_index
         ]
-        return {
-            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 table_category_data(self, table_id: int) -> dict | None:
-        category_owner_id = self.objects[table_id].category_owner.identifier
-        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
-
-        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_index_for_uid
-        ]
 
-        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
-
-        group_node_to_key = {
-            NumbersUUID(self.objects[_id].group_uid).hex: _NumbersModel.cell_value_to_key(
-                self.objects[_id].group_cell_value,
-            )
-            for _id in self.find_refs("GroupNodeArchive")
-        }
-        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]
-
-        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 = _NumbersModel.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
-                        ],
-                    }
-                else:
-                    categories[group_uuid] = {
-                        "key": group_node_to_key[group_uuid],
-                        "parent": parent,
-                        "rows": None,
+                    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": [],
                     }
-                    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-4.18.0 → numbers_parser-4.18.1/src/numbers_parser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numbers-parser
-Version: 4.18.0
+Version: 4.18.1
 Summary: Read and write Apple Numbers spreadsheets
 Author-email: Jon Connell <python@figsandfudge.com>
 License-Expression: MIT