excel-mcp-server 2.2.0__tar.gz → 2.2.1__tar.gz

{excel_mcp_server-2.2.0 → excel_mcp_server-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: excel-mcp-server
-Version: 2.2.0
+Version: 2.2.1
 Summary: MCP server for creating, reading and editing Excel workbooks without Microsoft Excel
 Keywords: mcp,mcp-server,model-context-protocol,excel,xlsx,xlsm,spreadsheet,openpyxl,charts,pivot-table,formulas,vba,llm,ai,claude,cursor
 Author: Haris Musa
@@ -98,6 +98,9 @@ Excel**, and runs on Windows, macOS and Linux.
 **Large files**
 - Reads stream the workbook and return pages, so memory stays flat on sheets with hundreds of
   thousands of rows; every call is bounded by size and cell limits
+- Edits of a sheet of 1 MB of XML or more parse only the rows they touch, so inserting or
+  deleting rows and columns, sorting, replacing, copying a sheet and creating a PivotTable
+  take seconds on a 200,000-row sheet instead of minutes
 
 **Macros (opt-in)**
 - Read the VBA code in `.xlsm` files. Writing VBA is off unless you start the server with

{excel_mcp_server-2.2.0 → excel_mcp_server-2.2.1}/README.md

@@ -62,6 +62,9 @@ Excel**, and runs on Windows, macOS and Linux.
 **Large files**
 - Reads stream the workbook and return pages, so memory stays flat on sheets with hundreds of
   thousands of rows; every call is bounded by size and cell limits
+- Edits of a sheet of 1 MB of XML or more parse only the rows they touch, so inserting or
+  deleting rows and columns, sorting, replacing, copying a sheet and creating a PivotTable
+  take seconds on a 200,000-row sheet instead of minutes
 
 **Macros (opt-in)**
 - Read the VBA code in `.xlsm` files. Writing VBA is off unless you start the server with

{excel_mcp_server-2.2.0 → excel_mcp_server-2.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "excel-mcp-server"
-version = "2.2.0"
+version = "2.2.1"
 description = "MCP server for creating, reading and editing Excel workbooks without Microsoft Excel"
 readme = "README.md"
 license = "MIT"

{excel_mcp_server-2.2.0 → excel_mcp_server-2.2.1}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "excel-mcp-server"
-version = "2.2.0"
+version = "2.2.1"
 description = "MCP server for creating, reading and editing Excel workbooks without Microsoft Excel"
 readme = "README.md"
 license = "MIT"

{excel_mcp_server-2.2.0 → excel_mcp_server-2.2.1}/src/excel_mcp/formulas.py

@@ -16,10 +16,12 @@ else before a "!" (a file, a path, a URL, "[1]") points at another workbook.
 
 import re
 from collections.abc import Iterable, Iterator
+from functools import lru_cache
 
 from openpyxl.formula import Tokenizer
 from openpyxl.formula.tokenizer import Token, TokenizerError
 
+from excel_mcp import plain_refs
 from excel_mcp.errors import InvalidFormulaError, UnsafeFormulaError
 from excel_mcp.formula_syntax import check_syntax, invalid_formula
 from excel_mcp.spill import store_spills
@@ -118,10 +120,28 @@ def storable_formula(formula: str, sheet_names: Iterable[str]) -> str:
 
     Every formula that is written anywhere in a workbook goes through here.
     """
+    pattern = plain_refs.shape(formula)
+    if pattern is not None and _is_plain_and_allowed(pattern):
+        return formula
     check_formula(formula, sheet_names)
     return add_prefixes(store_spills(formula))
 
 
+@lru_cache(maxsize=4096)
+def _is_plain_and_allowed(pattern: str) -> bool:
+    """Whether formulas of this shape pass the check and need no prefixes.
+
+    Which cells a plain formula refers to cannot change the outcome, so a sheet with hundreds
+    of thousands of formulas filled down from a few is checked a few times, not that often.
+    A formula that does not pass is checked again as itself, to raise its own error.
+    """
+    try:
+        check_formula(pattern, ())
+    except (InvalidFormulaError, UnsafeFormulaError):
+        return False
+    return add_prefixes(pattern) == pattern
+
+
 def storable_operand(operand: str, sheet_names: Iterable[str]) -> str:
     """`storable_formula` for rule operands and names, which are stored without the "="."""
     return storable_formula(f"={operand.removeprefix('=')}", sheet_names).removeprefix("=")

{excel_mcp_server-2.2.0 → excel_mcp_server-2.2.1}/src/excel_mcp/lazy_edit.py

@@ -32,16 +32,9 @@ from openpyxl.worksheet.dimensions import DimensionHolder
 from openpyxl.worksheet.worksheet import Worksheet
 from openpyxl.xml.constants import SHARED_STRINGS
 
-from excel_mcp import lazy_shared
-from excel_mcp.lazy_workbook import (
-    BLOCK_ROWS,
-    LazyCells,
-    Parts,
-    SheetSource,
-    lazy_sheets,
-    open_lazily,
-    split_sheet,
-)
+from excel_mcp import lazy_rows, lazy_shared
+from excel_mcp.lazy_source import SheetSource, split_sheet
+from excel_mcp.lazy_workbook import BLOCK_ROWS, LazyCells, Parts, lazy_sheets, open_lazily
 from excel_mcp.package.opc import REL_BASE, Package, Rel, free_id
 from excel_mcp.package.restore import MAIN, sheet_parts
 from excel_mcp.package.scan import declare_in_root, root_scope
@@ -55,6 +48,7 @@ _ROW = re.compile(rb"<row\b[^>]*?/>|<row\b[^>]*>.*?</row>", re.S)
 _ROW_NUMBER = re.compile(rb'\br="(\d+)"')
 _DIMENSION = re.compile(rb'<dimension\s+ref="[^"]*"\s*/>')
 _CELL_COLUMN = re.compile(rb'<c\b[^>]*?\br="([A-Z]+)\d')
+_UNADDRESSED_CELL = re.compile(rb"<c\b(?![^>]*\br=)")
 # A row with attributes of its own (a height, a style, hidden), not just its number.
 _ATTRIBUTED_ROW = re.compile(rb"<row\b[^>]*\s(?!r=|spans=|[\w.-]+:)[\w.-]+=[^>]*>")
 # What a formula stored as its result when Excel last calculated it, which an edit makes stale.
@@ -73,6 +67,8 @@ def _split(data: bytes) -> tuple[bytes, SheetSource] | None:
     cross_cell = (b't="array"', b't="dataTable"', b' cm="', b' vm="')
     if len(data) < LAZY_SHEET_BYTES or any(marker in data for marker in cross_cell):
         return None
+    if _UNADDRESSED_CELL.search(data):  # Its column is not known until the row is read.
+        return None
     split = split_sheet(data)
     return split if split and split[1].row_numbers else None
 
@@ -148,27 +144,31 @@ class LazyEdit:
 
     path: Path
     strings_part: str | None
-    sheets: list[Worksheet] = field(default_factory=list)
-    frozen: dict[Worksheet, LazyCells] = field(default_factory=dict)
+    frozen: dict[Worksheet, tuple[LazyCells, dict[int, bytes]]] = field(default_factory=dict)
 
-    def freeze(self) -> None:
-        """Leave each sheet with the cells and row dimensions that were parsed, for saving.
+    def freeze(self, workbook: Workbook) -> None:
+        """Prepare each sheet for saving, with the rows that were parsed written as text.
 
-        openpyxl writes what a sheet holds, and the rows of blocks that were not parsed are
-        put in from the file by `merge`.
+        openpyxl writes what a sheet holds, which is only the rows that need it (those with a
+        link, a note or a value it writes in a form of its own). The other rows of blocks that
+        were parsed are written by `lazy_rows`, and the rows of blocks that were not parsed are
+        put in from the file; `merge` puts them all together.
         """
-        for sheet in self.sheets:
+        for sheet in workbook.worksheets:
             cells = sheet._cells
-            if isinstance(cells, LazyCells):
-                lazy_shared.settle(cells)
+            if not isinstance(cells, LazyCells):
+                continue
+            lazy_shared.settle(cells)
             dimensions = DimensionHolder(worksheet=sheet, default_factory=sheet._add_row)
             for row, dimension in dict.items(sheet.row_dimensions):
-                if not isinstance(cells, LazyCells) or cells.is_loaded(row):
+                if cells.is_loaded(row):
                     dimensions[row] = dimension
-            sheet.row_dimensions = dimensions
-            if isinstance(cells, LazyCells):
-                sheet._cells = cells.held()
-                self.frozen[sheet] = cells
+            rendered, sheet._cells = lazy_rows.render(cells.held(), dimensions)
+            kept = {row for row, _ in sheet._cells}
+            sheet.row_dimensions = DimensionHolder(worksheet=sheet, default_factory=sheet._add_row)
+            for row in kept & dimensions.keys():
+                sheet.row_dimensions[row] = dimensions[row]
+            self.frozen[sheet] = (cells, rendered)
 
     def merge(self, workbook: Workbook, content: bytes) -> bytes:
         """The saved workbook with the rows that were not parsed put back, as the file has them."""
@@ -179,8 +179,9 @@ class LazyEdit:
             return content
         package = Package(content)
         parts = sheet_parts(package)
-        for sheet, cells in spliced.items():
-            package.write(parts[sheet.title], _splice(package.read(parts[sheet.title]), cells))
+        for sheet, (cells, rendered) in spliced.items():
+            xml = _splice(package.read(parts[sheet.title]), cells, rendered)
+            package.write(parts[sheet.title], xml)
         if self.strings_part:
             self._restore_strings(package)
         return package.to_bytes()
@@ -206,10 +207,10 @@ def load(path: Path) -> tuple[Workbook, LazyEdit | None]:
     reader.read()
     strings = reader.package.find(SHARED_STRINGS)
     edit = LazyEdit(path, strings.PartName.lstrip("/") if strings is not None else None)
-    for sheet, source in lazy_sheets(reader, parts):
+    lazy = list(lazy_sheets(reader, parts))
+    for sheet, source in lazy:
         _install(sheet, source, reader.shared_strings)
-        edit.sheets.append(sheet)
-    return reader.wb, edit if edit.sheets else None
+    return reader.wb, edit if lazy else None
 
 
 def _install(sheet: Worksheet, source: SheetSource, strings: list[str]) -> None:
@@ -250,13 +251,14 @@ def _self_closed(tag: bytes) -> bytes:
     return tag if tag.endswith(b"/>") else tag[:-1] + b"/>"
 
 
-def _splice(xml: bytes, cells: LazyCells) -> bytes:
+def _splice(xml: bytes, cells: LazyCells, rendered: dict[int, bytes]) -> bytes:
     """The sheet openpyxl wrote, holding the rows of the parsed blocks, with the others added."""
     source = cells.source
     data = _SHEET_DATA.search(xml)
     if data is None:
         raise ValueError("A saved worksheet has no sheetData.")
     produced = {_row_number(row[0]): row[0] for row in _ROW.finditer(data[0])}
+    produced.update(rendered)
     lazy_shared.restore(cells, produced)
     pieces = _rows(cells, produced)
     head, tail = xml[: data.start()], xml[data.end() :]

excel_mcp_server-2.2.1/src/excel_mcp/lazy_find.py

@@ -0,0 +1,83 @@
+"""Finding which rows of a sheet that is not parsed can hold a text, without parsing them.
+
+Replacing text looks at every cell, but most of a large sheet holds none of it. Only the blocks
+of rows that might hold a match are parsed; the others are as in the file. "Might" is decided
+from the XML and errs on the side of parsing: a block that holds nothing is parsed at worst.
+A cell is searched as `replace` searches it: text, numbers as their text, formulas as they are
+written (without the storage prefixes), so a formula that is only a master of the shared
+formulas below it matches for the cells that follow it too.
+"""
+
+import re
+from bisect import bisect_right
+from collections.abc import Callable
+from html import unescape
+
+from excel_mcp.lazy_workbook import LazyCells
+
+_STRING = re.compile(rb'<c\b[^>]*\bt="s"[^>]*><v>(\d+)</v>')
+_INLINE = re.compile(rb"<is>(.*?)</is>", re.S)
+_TAGS = re.compile(rb"<[^>]*>")
+_FORMULA = re.compile(rb"<f\b([^>]*)>([^<]*)</f>")
+_NUMBER = re.compile(rb'<c\b(?![^>]*\bt="(?!n")\w+")[^>]*><v>')
+_GROUP = re.compile(rb'\bsi="(\d+)"')
+_TEXT_OF_NUMBERS = frozenset("0123456789.-+e")
+# What a stored formula has and its text as shown does not, or the reverse.
+_STORAGE_MARKS = ("_xl", "anchorarray")
+
+
+def load_matches(
+    cells: LazyCells, matches: Callable[[str], bool], query: str, *, in_formulas: bool
+) -> None:
+    """Parse the blocks that may hold a cell for which ``matches(text)`` is true.
+
+    ``query`` is what ``matches`` looks for, which tells what kinds of cell it can match.
+    """
+    source = cells.source
+    starts = [start for start, _ in source.spans]
+    rows: set[int] = set()
+
+    def mark(position: int) -> None:
+        rows.add(source.row_numbers[bisect_right(starts, position) - 1])
+
+    hits = {index for index, text in enumerate(cells.strings) if matches(text)}
+    if hits:
+        for found in _STRING.finditer(source.data):
+            if int(found[1]) in hits:
+                mark(found.start())
+    for found in _INLINE.finditer(source.data):
+        if matches(unescape(_TAGS.sub(b"", found[1]).decode())):
+            mark(found.start())
+    if set(query.lower()) <= _TEXT_OF_NUMBERS:
+        rows.update(_rows_with_numbers(cells))
+    if in_formulas:
+        _mark_formulas(cells, matches, query, mark)
+    for number in rows:
+        cells.load(number)
+
+
+def _rows_with_numbers(cells: LazyCells) -> list[int]:
+    source = cells.source
+    return [
+        number
+        for number, (start, stop) in zip(source.row_numbers, source.spans, strict=True)
+        if _NUMBER.search(source.data, start, stop)
+    ]
+
+
+def _mark_formulas(
+    cells: LazyCells, matches: Callable[[str], bool], query: str, mark: Callable[[int], None]
+) -> None:
+    source = cells.source
+    digits = any(character.isdigit() for character in query)
+    for found in _FORMULA.finditer(source.data):
+        shown = "=" + unescape(found[2].decode())
+        hit = matches(shown) or any(part in shown.lower() for part in _STORAGE_MARKS)
+        if hit:
+            mark(found.start())
+        group = _GROUP.search(found[1])
+        master = source.masters.get(group[1].decode()) if group else None
+        # A cell that follows its master differs from it in digits, and in letters when the
+        # group spans columns.
+        if master is not None and (hit or digits or master.wide):
+            cells.load_between(*master.rows)

excel_mcp_server-2.2.1/src/excel_mcp/lazy_lines.py

@@ -0,0 +1,259 @@
+"""Rows inserted or deleted, and references moved, in a sheet whose rows are not parsed.
+
+A large sheet is held as the XML of its rows (`lazy_workbook`). Inserting rows above most of
+them renumbers the rows and rewrites the references in their formulas, which needs no cells:
+both are done on the XML, row by row, and only the rows around the edit are parsed.
+
+Formulas filled down are stored as one master and the cells that follow it (`lazy_shared`).
+They stay that way when every cell of the group moves alike: rewriting the master then
+rewrites them all. A group whose cells or references fall on both sides of the edit (such a
+cell now refers to another one than its master does) is parsed first and becomes ordinary
+formulas, as Excel splits it.
+"""
+
+import re
+from collections.abc import Callable
+from dataclasses import replace
+from functools import lru_cache
+from html import unescape
+from typing import Any
+from xml.sax.saxutils import escape
+
+from openpyxl.formula.translate import Translator
+from openpyxl.utils import column_index_from_string, get_column_letter
+from openpyxl.worksheet.worksheet import Worksheet
+
+from excel_mcp.formulas import storable_formula
+from excel_mcp.lazy_shared import SharedMaster
+from excel_mcp.lazy_source import SheetSource
+from excel_mcp.lazy_workbook import CellKey, LazyCells
+from excel_mcp.package.lines import LineEdit
+from excel_mcp.refs import parse_range
+from excel_mcp.rewrite import ReferenceRewriter
+
+_FORMULA = re.compile(rb"<f\b([^>]*)>([^<]*)</f>")
+_ROW_NUMBERS = re.compile(rb'(<row\b[^>]*?\br="|<c\b[^>]*?\br="[A-Z]+)(\d+)(")')
+_REF = re.compile(rb' ref="([^"]*)"')
+_CELLS = re.compile(rb"<c\b[^>]*?(?:/>|>.*?</c>)", re.S)
+_CELL_REF = re.compile(rb'<c\b[^>]*?\br="([A-Z]+)(\d+)"')
+_STYLE = re.compile(rb' s="(\d+)"')
+_SPANS = re.compile(rb' spans="[^"]*"')
+
+Row = tuple[int, bytes]
+
+
+def unshare(cells: LazyCells, host: str, rewriter: ReferenceRewriter, edit: LineEdit) -> None:
+    """Parse the groups of shared formulas that ``edit`` would not leave alike."""
+    for master in cells.source.masters.values():
+        if not _moves_alike(master, host, rewriter, edit):
+            cells.load_between(*master.rows)
+
+
+def _moves_alike(
+    master: SharedMaster, host: str, rewriter: ReferenceRewriter, edit: LineEdit
+) -> bool:
+    """Whether every cell of the group ends up with the formula its master gives it.
+
+    The group moves alike if the master's rewritten formula, copied to the farthest cell of the
+    group, is what rewriting the formula of that cell gives. The shift of a reference is the
+    same for the cells in between, because it changes only once, at the edit.
+    """
+    area = parse_range(master.ref)
+    if host.casefold() == edit.sheet.casefold():
+        first, last = (
+            (area.min_row, area.max_row) if edit.axis == "rows" else (area.min_col, area.max_col)
+        )
+        if edit.cuts(first, last):
+            return False
+    far = f"{get_column_letter(area.max_col)}{area.max_row}"
+    formula = "=" + master.text
+    copied = Translator(formula, master.coordinate).translate_formula(far)
+    moved = Translator(rewriter.formula(formula, host), master.coordinate).translate_formula(far)
+    return moved == rewriter.formula(copied, host)
+
+
+def rewrite_formulas(
+    cells: LazyCells,
+    host: str,
+    rewriter: ReferenceRewriter,
+    names: list[str],
+    *,
+    check_all: bool = False,
+) -> None:
+    """Rewrite the references of the formulas in the rows that are not parsed.
+
+    A formula that changes is checked as every written formula is; ``check_all`` also checks
+    those that stay as they are (a copy of a sheet writes them all).
+    """
+    source = cells.source
+    cache: dict[str, str] = {}
+
+    def rewrite(text: str) -> str:
+        if text not in cache:
+            formula = "=" + text
+            moved = rewriter.formula(formula, host)
+            unchanged = moved == formula and not check_all
+            cache[text] = text if unchanged else storable_formula(moved, names)[1:]
+        return cache[text]
+
+    def replace_formula(match: re.Match[bytes]) -> bytes:
+        text = unescape(match[2].decode())
+        moved = rewrite(text)
+        if moved == text:
+            return match[0]
+        return b"<f%b>%b</f>" % (match[1], escape(moved).encode())
+
+    rows: list[Row] = []
+    for number, (start, stop) in zip(source.row_numbers, source.spans, strict=True):
+        row = source.data[start:stop]
+        if b"<f" in row and not cells.is_loaded(number):
+            row = _FORMULA.sub(replace_formula, row)
+        rows.append((number, row))
+    masters = {group: replace(m, text=rewrite(m.text)) for group, m in source.masters.items()}
+    cells.source = _assembled(source, rows, masters, source.hidden_rows)
+
+
+def move_lines(
+    cells: LazyCells,
+    edit: LineEdit,
+    moved: dict[CellKey, Any],
+    inherit: Callable[[int, int | None], int] | None,
+) -> None:
+    """Insert or delete rows or columns: move the rows that are not parsed, in their XML, and
+    hold ``moved`` (the cells that are parsed, already moved) with them.
+
+    ``inherit`` gives the style of a cell that is inserted next to one: from the style of that
+    cell and of the one on its other side.
+    """
+    source = cells.source
+    rows: list[Row] = []
+    hidden = source.hidden_rows
+    parsed = cells.parsed_rows()
+    if edit.axis == "rows":
+        move_row = _row_mover(edit)
+        for number, (start, stop) in zip(source.row_numbers, source.spans, strict=True):
+            if (index := edit.index(number)) is not None and not cells.is_loaded(number):
+                rows.append((index, move_row(source.data[start:stop], index - number)))
+        hidden = [index for row in hidden if (index := edit.index(row)) is not None]
+        parsed = [span for first, last in parsed if (span := edit.span(first, last))]
+    else:
+        move_cells = _column_mover(edit, inherit)
+        for number, (start, stop) in zip(source.row_numbers, source.spans, strict=True):
+            if not cells.is_loaded(number):
+                rows.append((number, move_cells(source.data[start:stop])))
+    cells.replace(moved, _assembled(source, rows, _moved_masters(source, edit), hidden), parsed)
+
+
+def copied(cells: LazyCells, sheet: Worksheet) -> LazyCells:
+    """The cells of a copy of a sheet: the rows that are not parsed are shared with the original,
+    which keeps the cells that are parsed."""
+    source = cells.source
+    rows = [
+        (number, source.data[start:stop])
+        for number, (start, stop) in zip(source.row_numbers, source.spans, strict=True)
+        if not cells.is_loaded(number)
+    ]
+    masters = dict(source.masters)
+    return LazyCells(sheet, _assembled(source, rows, masters, source.hidden_rows), cells.strings)
+
+
+def _moved_masters(source: SheetSource, edit: LineEdit) -> dict[str, SharedMaster]:
+    masters = {}
+    rows = edit.axis == "rows"
+    for group, master in source.masters.items():
+        area = edit.range(parse_range(master.ref))
+        line = edit.index(master.row if rows else master.column)
+        if line is not None and area is not None:
+            position = {"row": line} if rows else {"column": line}
+            masters[group] = replace(master, ref=str(area), **position)
+    return masters
+
+
+def _ref_mover(edit: LineEdit) -> Callable[[re.Match[bytes]], bytes]:
+    """What a shared formula's ``ref`` becomes."""
+
+    def move(match: re.Match[bytes]) -> bytes:
+        area = edit.range(parse_range(match[1].decode()))
+        return b' ref="%b"' % str(area).encode()
+
+    return move
+
+
+def _row_mover(edit: LineEdit) -> Callable[[bytes, int], bytes]:
+    """A function that moves a row of XML down by some rows: its number, its cells, and the
+    range of a shared formula it holds."""
+    move_ref = _ref_mover(edit)
+
+    def move(row: bytes, delta: int) -> bytes:
+        if not delta:
+            return row
+        row = _ROW_NUMBERS.sub(lambda m: m[1] + b"%d" % (int(m[2]) + delta) + m[3], row)
+        return _REF.sub(move_ref, row) if b" ref=" in row else row
+
+    return move
+
+
+def _column_mover(
+    edit: LineEdit, inherit: Callable[[int, int | None], int] | None
+) -> Callable[[bytes], bytes]:
+    """A function that moves the cells of a row of XML sideways: it drops those in deleted
+    columns, renames the others and gives the cells inserted next to one its format."""
+    move_ref = _ref_mover(edit)
+
+    def move(row: bytes) -> bytes:
+        found = list(_CELLS.finditer(row))
+        if not found:
+            return row
+        cells = []
+        for match in found:
+            ref = _CELL_REF.match(match[0])
+            assert ref is not None  # `split_sheet` leaves out sheets with cells without an address.
+            cells.append((_column(ref[1]), ref, match[0]))
+        styles = {column: _style(cell) for column, _, cell in cells} if inherit else {}
+        kept = []
+        for column, ref, cell in cells:
+            line = edit.index(column)
+            if line is None:
+                continue
+            if line != column:
+                cell = cell[: ref.start(1)] + _letters(line) + cell[ref.end(1) :]
+                cell = _REF.sub(move_ref, cell) if b" ref=" in cell else cell
+            kept.append(cell)
+            if inherit and column == edit.at - 1:
+                style = inherit(styles[column], styles.get(edit.at))
+                kept.extend(
+                    b'<c r="%b%b" s="%d"/>' % (_letters(new), ref[2], style)
+                    for new in range(edit.at, edit.at + edit.count)
+                    if style
+                )
+        head = _SPANS.sub(b"", row[: found[0].start()])
+        return head + b"".join(kept) + row[found[-1].end() :]
+
+    return move
+
+
+@lru_cache(maxsize=1024)
+def _column(letters: bytes) -> int:
+    return column_index_from_string(letters.decode())
+
+
+@lru_cache(maxsize=1024)
+def _letters(column: int) -> bytes:
+    return get_column_letter(column).encode()
+
+
+def _style(cell: bytes) -> int:
+    found = _STYLE.search(cell, 0, cell.index(b">"))
+    return int(found[1]) if found else 0
+
+
+def _assembled(
+    source: SheetSource, rows: list[Row], masters: dict[str, SharedMaster], hidden: list[int]
+) -> SheetSource:
+    spans = []
+    offset = 0
+    for _, row in rows:
+        spans.append((offset, offset + len(row)))
+        offset += len(row)
+    data = b"".join(row for _, row in rows)
+    return SheetSource(data, source.root, [number for number, _ in rows], spans, hidden, masters)