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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: excel-mcp-server
-Version: 2.2.1
+Version: 2.2.2
 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
@@ -23,7 +23,7 @@ Classifier: Typing :: Typed
 Requires-Dist: mcp>=2.2,<3
 Requires-Dist: olefile>=0.47,<1
 Requires-Dist: openpyxl>=3.1.5,<4
-Requires-Dist: pillow>=12,<13
+Requires-Dist: pillow>=13,<14
 Requires-Dist: pydantic>=2.12,<3
 Requires-Dist: starlette>=1,<2
 Requires-Dist: uvicorn>=0.31,<1
@@ -234,6 +234,7 @@ docker run -p 8017:8017 -v "$PWD/workbooks:/data" -e EXCEL_MCP_AUTH_TOKEN=change
 | `--max-file-mb N` | `EXCEL_MCP_MAX_FILE_MB` | `100` | Largest workbook the server opens. Also sets the unpacked-size limit (10 times this) that every opened or uploaded workbook must stay under; parts compressed over 500:1 are refused |
 | `--max-cells N` | `EXCEL_MCP_MAX_CELLS` | `100000` | Most cells one call may read, write or format; reads are still returned in pages |
 | `--max-pivot-cells N` | `EXCEL_MCP_MAX_PIVOT_CELLS` | `3000000` | Largest PivotTable source in cells (a 230,000-row, 13-column sheet); creating one from the biggest sources takes a minute and about 2 GB of memory |
+| `--max-loaded-cells N` | `EXCEL_MCP_MAX_LOADED_CELLS` | `3000000` | Most cells and rows of a workbook that may be loaded into memory at once, about 0.5 KB each (a 3,000,000 limit is about 1.5 GB). A workbook with more is refused by the tools that must load whole sheets; `read_range` and the other streaming reads, and edits of large sheets that parse only some rows, are not limited by the size of the sheet |
 | `--log-level LEVEL` | | `WARNING` | Logging on stderr |
 | `--host HOST` | `EXCEL_MCP_HOST` | `127.0.0.1` | HTTP listen address |
 | `--port PORT` | `EXCEL_MCP_PORT` | `8017` | HTTP port |

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

@@ -198,6 +198,7 @@ docker run -p 8017:8017 -v "$PWD/workbooks:/data" -e EXCEL_MCP_AUTH_TOKEN=change
 | `--max-file-mb N` | `EXCEL_MCP_MAX_FILE_MB` | `100` | Largest workbook the server opens. Also sets the unpacked-size limit (10 times this) that every opened or uploaded workbook must stay under; parts compressed over 500:1 are refused |
 | `--max-cells N` | `EXCEL_MCP_MAX_CELLS` | `100000` | Most cells one call may read, write or format; reads are still returned in pages |
 | `--max-pivot-cells N` | `EXCEL_MCP_MAX_PIVOT_CELLS` | `3000000` | Largest PivotTable source in cells (a 230,000-row, 13-column sheet); creating one from the biggest sources takes a minute and about 2 GB of memory |
+| `--max-loaded-cells N` | `EXCEL_MCP_MAX_LOADED_CELLS` | `3000000` | Most cells and rows of a workbook that may be loaded into memory at once, about 0.5 KB each (a 3,000,000 limit is about 1.5 GB). A workbook with more is refused by the tools that must load whole sheets; `read_range` and the other streaming reads, and edits of large sheets that parse only some rows, are not limited by the size of the sheet |
 | `--log-level LEVEL` | | `WARNING` | Logging on stderr |
 | `--host HOST` | `EXCEL_MCP_HOST` | `127.0.0.1` | HTTP listen address |
 | `--port PORT` | `EXCEL_MCP_PORT` | `8017` | HTTP port |

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

@@ -1,6 +1,6 @@
 [project]
 name = "excel-mcp-server"
-version = "2.2.1"
+version = "2.2.2"
 description = "MCP server for creating, reading and editing Excel workbooks without Microsoft Excel"
 readme = "README.md"
 license = "MIT"
@@ -43,7 +43,7 @@ dependencies = [
     "mcp>=2.2,<3",
     "olefile>=0.47,<1",
     "openpyxl>=3.1.5,<4",
-    "pillow>=12,<13",
+    "pillow>=13,<14",
     "pydantic>=2.12,<3",
     "starlette>=1,<2",
     "uvicorn>=0.31,<1",
@@ -71,7 +71,7 @@ dev = [
 ]
 
 [build-system]
-requires = ["uv_build>=0.12.19,<0.13"]
+requires = ["uv_build>=0.13.1,<0.14"]
 build-backend = "uv_build"
 
 [tool.ruff]

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

@@ -1,6 +1,6 @@
 [project]
 name = "excel-mcp-server"
-version = "2.2.1"
+version = "2.2.2"
 description = "MCP server for creating, reading and editing Excel workbooks without Microsoft Excel"
 readme = "README.md"
 license = "MIT"
@@ -44,7 +44,7 @@ dependencies = [
     "mcp>=2.2,<3",
     "olefile>=0.47,<1",
     "openpyxl>=3.1.5,<4",
-    "pillow>=12,<13",
+    "pillow>=13,<14",
     "pydantic>=2.12,<3",
     "starlette>=1,<2",
     "uvicorn>=0.31,<1",
@@ -68,7 +68,7 @@ dev = [
 ]
 
 [build-system]
-requires = ["uv_build>=0.12.19,<0.13"]
+requires = ["uv_build>=0.13.1,<0.14"]
 build-backend = "uv_build"
 
 [tool.ruff]

excel_mcp_server-2.2.2/src/excel_mcp/cell_budget.py

@@ -0,0 +1,73 @@
+"""A limit on the cells that a workbook's sheets make openpyxl create.
+
+Memory use is set by the number of cells created, not by the size of the file: a sheet of
+millions of empty cells is a few hundred kilobytes. So every sheet is counted before it is
+parsed, and what is created cannot pass the limit. Rows count as cells (openpyxl keeps their
+attributes), and so does every cell of a merged range or hyperlink range, which it creates
+from the one element that names the range.
+"""
+
+from pathlib import Path
+from typing import IO
+from xml.parsers import expat
+
+from openpyxl.reader.excel import ExcelReader
+from openpyxl.xml.constants import SHEET_MAIN_NS, WORKSHEET_TYPE
+
+from excel_mcp.errors import LimitExceededError
+from excel_mcp.refs import parse_range
+
+_CHUNK = 1 << 20
+_NAMESPACE = f"{SHEET_MAIN_NS} "
+_COUNTED = {f"{_NAMESPACE}c", f"{_NAMESPACE}row"}
+_MERGED = f"{_NAMESPACE}mergeCell"
+_LINKED = f"{_NAMESPACE}hyperlink"
+# A cell that holds a link takes about three times the memory of one that does not.
+_LINK_COST = 3
+
+
+class CellBudget:
+    """The cells that may still be created for one workbook, shared by all its sheets."""
+
+    def __init__(self, limit: int) -> None:
+        self.limit = limit
+        self.used = 0
+
+    def spend(self, count: int) -> None:
+        self.used += count
+        if self.used > self.limit:
+            raise LimitExceededError(
+                f"The workbook has more than {self.limit:,} cells and rows to load, which "
+                "would use too much memory. Read it with read_range, split it into smaller "
+                "workbooks, or raise --max-loaded-cells."
+            )
+
+
+def spend_sheet(source: IO[bytes], budget: CellBudget) -> None:
+    """Spend the cells and rows of one worksheet's XML, stopping at the first one over the limit."""
+    parser = expat.ParserCreate(namespace_separator=" ")
+
+    def start(name: str, attributes: dict[str, str]) -> None:
+        if name in _COUNTED:
+            budget.spend(1)
+        elif name == _MERGED:
+            budget.spend(parse_range(attributes["ref"]).size)
+        elif name == _LINKED:
+            budget.spend(_LINK_COST * parse_range(attributes["ref"]).size)
+
+    parser.StartElementHandler = start
+    while chunk := source.read(_CHUNK):
+        parser.Parse(chunk, False)
+    parser.Parse(b"", True)
+
+
+def check_workbook(path: Path, budget: CellBudget) -> None:
+    """Spend the cells and rows that loading all of a workbook's worksheets would create."""
+    reader = ExcelReader(path)
+    try:
+        reader.read_manifest()
+        for part in reader.package.findall(WORKSHEET_TYPE):
+            with reader.archive.open(part.PartName.lstrip("/")) as source:
+                spend_sheet(source, budget)
+    finally:
+        reader.archive.close()

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/cli.py

@@ -78,6 +78,7 @@ def _settings(args: argparse.Namespace) -> Settings:
             max_file_bytes=args.max_file_mb * MB,
             max_cells=args.max_cells,
             max_pivot_source_cells=args.max_pivot_cells,
+            max_loaded_cells=args.max_loaded_cells,
         ),
         log_level=args.log_level,
     )
@@ -159,6 +160,13 @@ def _parser() -> argparse.ArgumentParser:
         help="Largest PivotTable source, in cells (default %(default)s). "
         "Also EXCEL_MCP_MAX_PIVOT_CELLS.",
     )
+    common.add_argument(
+        "--max-loaded-cells",
+        type=_positive_int,
+        default=_env_default("EXCEL_MCP_MAX_LOADED_CELLS", DEFAULT_LIMITS.max_loaded_cells),
+        help="Most cells and rows of a workbook that may be loaded into memory at once, about "
+        "0.5 KB each (default %(default)s). Also EXCEL_MCP_MAX_LOADED_CELLS.",
+    )
     common.add_argument(
         "--log-level",
         default="WARNING",

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/config.py

@@ -14,6 +14,8 @@ class Limits:
     max_cells: int = 100_000
     max_pivot_source_cells: int = 3_000_000
     max_copy_cells: int = 1_000_000
+    # Cells and rows that all the sheets of a workbook may create in memory, about 0.5 KB each.
+    max_loaded_cells: int = 3_000_000
     # Zip bomb guards, applied to every workbook the server opens or receives. Real workbooks
     # compress 10 to 30 times and sparse sheets far more, so these leave room for them.
     max_unpack_factor: int = 10

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

@@ -33,6 +33,7 @@ from openpyxl.worksheet.worksheet import Worksheet
 from openpyxl.xml.constants import SHARED_STRINGS
 
 from excel_mcp import lazy_rows, lazy_shared
+from excel_mcp.cell_budget import CellBudget
 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
@@ -48,7 +49,6 @@ _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.
@@ -67,8 +67,6 @@ 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
 
@@ -200,22 +198,22 @@ class LazyEdit:
         rels.append(Rel(free_id(rels, ""), REL_BASE + "sharedStrings", name))
 
 
-def load(path: Path) -> tuple[Workbook, LazyEdit | None]:
+def load(path: Path, budget: CellBudget) -> tuple[Workbook, LazyEdit | None]:
     """Load a workbook for editing, its large sheets without their rows."""
     parts: Parts = {}
-    reader = open_lazily(path, parts, _split)
+    reader = open_lazily(path, parts, _split, budget)
     reader.read()
     strings = reader.package.find(SHARED_STRINGS)
     edit = LazyEdit(path, strings.PartName.lstrip("/") if strings is not None else None)
     lazy = list(lazy_sheets(reader, parts))
     for sheet, source in lazy:
-        _install(sheet, source, reader.shared_strings)
+        _install(sheet, source, reader.shared_strings, budget)
     return reader.wb, edit if lazy else None
 
 
-def _install(sheet: Worksheet, source: SheetSource, strings: list[str]) -> None:
+def _install(sheet: Worksheet, source: SheetSource, strings: list[str], budget: CellBudget) -> None:
     carried = sheet._cells
-    cells = LazyCells(sheet, source, strings)
+    cells = LazyCells(sheet, source, strings, budget)
     sheet._cells = cells
     _bind_row_dimensions(sheet, source, strings)
     for (row, column), carried_cell in carried.items():

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/lazy_lines.py

@@ -154,7 +154,9 @@ def copied(cells: LazyCells, sheet: Worksheet) -> LazyCells:
         if not cells.is_loaded(number)
     ]
     masters = dict(source.masters)
-    return LazyCells(sheet, _assembled(source, rows, masters, source.hidden_rows), cells.strings)
+    return LazyCells(
+        sheet, _assembled(source, rows, masters, source.hidden_rows), cells.strings, cells.budget
+    )
 
 
 def _moved_masters(source: SheetSource, edit: LineEdit) -> dict[str, SharedMaster]:

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/lazy_source.py

@@ -4,8 +4,9 @@ import re
 from bisect import bisect_left, bisect_right
 from dataclasses import dataclass, field
 from functools import cached_property
+from itertools import pairwise
 
-from openpyxl.utils import column_index_from_string
+from openpyxl.utils import column_index_from_string, get_column_letter
 from openpyxl.xml.constants import SHEET_MAIN_NS
 
 from excel_mcp import lazy_shared
@@ -17,6 +18,9 @@ _ROW_NUMBER = re.compile(rb'\br="(\d+)"')
 _HIDDEN = re.compile(rb'\bhidden="(?:1|true)"')
 _CELL = re.compile(rb"<c[ >/]")
 _CELL_COLUMN = re.compile(rb'<c\b[^>]*?\br="([A-Z]+)\d')
+_UNADDRESSED = re.compile(rb"<row\b(?![^>]*\br=)|<c\b(?![^>]*\br=)")
+_TAG = re.compile(rb"<(row|c)\b([^>]*)>")
+_CELL_LETTERS = re.compile(rb'\br="([A-Z]+)\d')
 _ROOT = re.compile(rb'<worksheet\b[^>]*?\bxmlns="([^"]+)"[^>]*>')
 
 
@@ -73,24 +77,24 @@ class SheetSource:
 def split_sheet(data: bytes) -> tuple[bytes, SheetSource] | None:
     """The sheet without its rows, and the rows; None for a layout this does not handle.
 
-    Rows without a number are left out because they are numbered by their position. The
-    masters of shared formulas are indexed, as a row's formula can depend on the row that
-    declares it.
+    Rows and cells without a number or address are given one first, as their position
+    says. The masters of shared formulas are indexed, as a row's formula can depend on the
+    row that declares it.
     """
     root = _ROOT.search(data)
     start = data.find(_SHEET_DATA)
     end = data.find(_SHEET_DATA_END)
     if root is None or root[1] != SHEET_MAIN_NS.encode() or start < 0 or end < start:
         return None
+    if not _all_addressed(data, start, end) and _UNADDRESSED.search(data, start, end):
+        data = data[:start] + _address(data[start:end]) + data[end:]
+        end = data.find(_SHEET_DATA_END)
     numbers: list[int] = []
     spans: list[tuple[int, int]] = []
     hidden: list[int] = []
     starts = list(_ROW.finditer(data, start, end))
     for position, tag in enumerate(starts):
-        number = _ROW_NUMBER.search(tag.group())
-        if number is None:
-            return None
-        numbers.append(int(number.group(1)))
+        numbers.append(int(_ROW_NUMBER.search(tag.group())[1]))  # pyright: ignore[reportOptionalSubscript]
         following = starts[position + 1].start() if position + 1 < len(starts) else end
         spans.append((tag.start(), following))
         if _HIDDEN.search(tag.group()):
@@ -100,3 +104,38 @@ def split_sheet(data: bytes) -> tuple[bytes, SheetSource] | None:
     without_rows = data[:start] + _SHEET_DATA + b"/>" + data[end + len(_SHEET_DATA_END) :]
     masters = lazy_shared.index(data, start, end) if b't="shared"' in data else {}
     return without_rows, SheetSource(data, root.group(), numbers, spans, hidden, masters)
+
+
+def _all_addressed(data: bytes, start: int, end: int) -> bool:
+    """Whether every row and cell opens with its address, as counting them (quickly) shows."""
+    return all(
+        data.count(tag, start, end) == data.count(tag + b' r="', start, end)
+        for tag in (b"<row", b"<c")
+    )
+
+
+def _address(rows: bytes) -> bytes:
+    """The rows with the number of each row and the address of each cell that has none.
+
+    Excel and openpyxl number them by position: a row after the one before it, a cell after
+    the one before it in its row. Writers leave the numbers out to make the file smaller.
+    """
+    row = column = 0
+
+    def addressed(tag: re.Match[bytes]) -> bytes:
+        nonlocal row, column
+        attributes = tag[2]
+        if tag[1] == b"row":
+            given = _ROW_NUMBER.search(attributes)
+            row = int(given[1]) if given else row + 1
+            column = 0
+            return tag[0] if given else b'<row r="%d"%b>' % (row, attributes)
+        given = _CELL_LETTERS.search(attributes)
+        column = column_index_from_string(given[1].decode()) if given else column + 1
+        if given:
+            return tag[0]
+        return b'<c r="%b%d"%b>' % (get_column_letter(column).encode(), row, attributes)
+
+    bounds = [0, *(tag.start() for tag in _ROW.finditer(rows)), len(rows)]
+    # One row at a time, so that no list of all the pieces of a sheet is held besides the sheet.
+    return b"".join(_TAG.sub(addressed, rows[a:b]) for a, b in pairwise(bounds))

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/lazy_workbook.py

@@ -22,6 +22,7 @@ from openpyxl.worksheet.worksheet import Worksheet
 from openpyxl.xml.constants import WORKSHEET_TYPE
 
 from excel_mcp import lazy_rows, lazy_shared
+from excel_mcp.cell_budget import CellBudget, spend_sheet
 from excel_mcp.lazy_source import SheetSource, split_sheet
 
 BLOCK_ROWS = 128
@@ -39,11 +40,14 @@ class LazyCells(dict[CellKey, Any]):
     parsed holds all of its rows: what is not in ``loaded`` is as the file has it.
     """
 
-    def __init__(self, sheet: Worksheet, source: SheetSource, strings: list[str]) -> None:
+    def __init__(
+        self, sheet: Worksheet, source: SheetSource, strings: list[str], budget: CellBudget
+    ) -> None:
         super().__init__()
         self.sheet = sheet
         self.source = source
         self.strings = strings
+        self.budget = budget
         self.loaded: set[int] = set()
         self.columns: dict[int, list[int]] = {}
         self.last_row = self.last_column = 0
@@ -246,6 +250,9 @@ class LazyCells(dict[CellKey, Any]):
 
     def _parse(self, spans: list[tuple[int, int]]) -> None:
         """Parse rows: those in the usual forms as text, the others with openpyxl's parser."""
+        data = self.source.data
+        # The rows and their cells, counted before they are parsed as `spend_sheet` counts a sheet.
+        self.budget.spend(len(spans) + sum(data.count(b"<c", start, end) for start, end in spans))
         book: Any = self.sheet.parent
         shared = lazy_shared.Translators(self.source.masters)
         reading = lazy_rows.Reading(
@@ -307,11 +314,14 @@ Splitter = Callable[[bytes], tuple[bytes, SheetSource] | None]
 class _SheetArchive(ZipFile):
     """An archive that serves each worksheet without its rows, which are kept in ``parts``."""
 
-    def __init__(self, path: Path, parts: Parts, sheet_parts: set[str], split: Splitter) -> None:
+    def __init__(
+        self, path: Path, parts: Parts, sheet_parts: set[str], split: Splitter, budget: CellBudget
+    ) -> None:
         super().__init__(path)
         self.parts = parts
         self.sheet_parts = sheet_parts
         self.split = split
+        self.budget = budget
         self.worksheets: list[str] = []
 
     def open(self, name: Any, mode: Any = "r", pwd: Any = None, **options: Any) -> IO[bytes]:
@@ -324,16 +334,24 @@ class _SheetArchive(ZipFile):
             split = self.split(data)
             self.parts[name] = split if split else (data, None)
         self.worksheets.append(name)
-        return BytesIO(self.parts[name][0])
+        parsed = self.parts[name][0]
+        spend_sheet(BytesIO(parsed), self.budget)
+        return BytesIO(parsed)
 
 
-def open_lazily(path: Path, parts: Parts, split: Splitter, **options: Any) -> ExcelReader:
-    """A reader that has not read the workbook yet, whose sheets are served by ``split``."""
+def open_lazily(
+    path: Path, parts: Parts, split: Splitter, budget: CellBudget, **options: Any
+) -> ExcelReader:
+    """A reader that has not read the workbook yet, whose sheets are served by ``split``.
+
+    The cells and rows of the sheets that are not split are spent from ``budget`` when they
+    are read, and those of the split sheets when their rows are parsed.
+    """
     reader = ExcelReader(path, **options)
     reader.read_manifest()
     sheet_parts = {part.PartName.lstrip("/") for part in reader.package.findall(WORKSHEET_TYPE)}
     reader.archive.close()
-    reader.archive = _SheetArchive(path, parts, sheet_parts, split)
+    reader.archive = _SheetArchive(path, parts, sheet_parts, split, budget)
     return reader
 
 
@@ -346,16 +364,16 @@ def lazy_sheets(reader: ExcelReader, parts: Parts) -> Iterator[tuple[Worksheet,
             yield sheet, source
 
 
-def load_lazy(path: Path, parts: Parts, *, data_only: bool) -> Workbook:
+def load_lazy(path: Path, parts: Parts, budget: CellBudget, *, data_only: bool) -> Workbook:
     """Load a workbook the way ``load_workbook`` does, leaving the cells to be read on demand.
 
     A sheet this cannot split into rows is loaded whole. ``parts`` is shared by the loads of
     one file, so that each sheet is read from the file once.
     """
-    reader = open_lazily(path, parts, split_sheet, data_only=data_only, keep_links=False)
+    reader = open_lazily(path, parts, split_sheet, budget, data_only=data_only, keep_links=False)
     reader.read()
     for sheet, source in lazy_sheets(reader, parts):
-        cells = LazyCells(sheet, source, reader.shared_strings)
+        cells = LazyCells(sheet, source, reader.shared_strings, budget)
         for cell in sheet._cells.values():
             if isinstance(cell, MergedCell):
                 cells.keep(cell)

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/operations/calculated.py

@@ -12,7 +12,7 @@ from openpyxl.worksheet.worksheet import Worksheet
 
 from excel_mcp.calc.engine import Engine
 from excel_mcp.calc.values import ExcelError, Scalar, UncalculableError
-from excel_mcp.errors import InvalidArgumentError
+from excel_mcp.errors import InvalidArgumentError, LimitExceededError
 from excel_mcp.operations import cells
 from excel_mcp.operations.cells import RangeData
 from excel_mcp.operations.comparison import FormulaResults
@@ -70,7 +70,14 @@ def formula_values(
     ]
     if not formula_cells:
         return {}
-    data = read_calculated(workspace, path, sheet.title, str(area), area.size)
+    try:
+        data = read_calculated(workspace, path, sheet.title, str(area), area.size)
+    except LimitExceededError as error:
+        raise LimitExceededError(
+            f"{error} Calculating the formulas of {area} needs the cells in memory because "
+            "the file stores no results for them. Open the workbook in Excel and save it, or "
+            "use a smaller range."
+        ) from None
     if data.uncalculated:
         cells_list = ", ".join(data.uncalculated)
         raise InvalidArgumentError(

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/operations/cells.py

@@ -57,6 +57,14 @@ def stored_cells(sheet: Worksheet) -> Iterator[Cell]:
             yield cell
 
 
+def described_used_range(sheet: Worksheet) -> CellRange:
+    """`used_range` of a sheet that is not being changed: a large sheet's is read from its XML."""
+    cells = sheet._cells
+    if isinstance(cells, LazyCells) and (found := used_range_in(cells.source.data)):
+        return found
+    return used_range(sheet)
+
+
 def stored_cells_in(sheet: Worksheet, area: CellRange) -> Iterator[Cell]:
     """The cells that hold a value inside ``area``; a large sheet parses only those rows."""
     cells = sheet._cells

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/operations/hyperlinks.py

@@ -12,6 +12,7 @@ from pydantic import BaseModel, Field
 from excel_mcp.errors import InvalidArgumentError
 from excel_mcp.formulas import split_top_level, unquote
 from excel_mcp.inputs import InputModel
+from excel_mcp.lazy_workbook import held_cells
 from excel_mcp.links import is_allowed_address
 from excel_mcp.refs import parse_range
 
@@ -58,7 +59,7 @@ def list_links(sheet: Worksheet) -> list[LinkInfo]:
             + ("#" + cell.hyperlink.location if cell.hyperlink.location else ""),
             tooltip=cell.hyperlink.tooltip,
         )
-        for _, cell in sorted(sheet._cells.items())
+        for _, cell in sorted(held_cells(sheet).items())
         if cell.hyperlink
     ]
 

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/operations/inspect.py

@@ -7,7 +7,7 @@ from openpyxl.workbook import Workbook
 from openpyxl.worksheet.worksheet import Worksheet
 from pydantic import BaseModel
 
-from excel_mcp.operations.cells import streamed_used_range, used_range
+from excel_mcp.operations.cells import described_used_range, streamed_used_range
 from excel_mcp.operations.chart_index import list_charts
 from excel_mcp.operations.chart_info import ChartInfo
 from excel_mcp.operations.conditional_x14 import extended_rules
@@ -139,7 +139,7 @@ def describe_workbook(
 
 def describe_sheet(sheet: Worksheet) -> SheetDetails:
     return SheetDetails(
-        used_range=str(used_range(sheet)),
+        used_range=str(described_used_range(sheet)),
         freeze_panes=sheet.freeze_panes,
         auto_filter=sheet.auto_filter.ref,
         merged_ranges=sorted(str(merged) for merged in sheet.merged_cells.ranges),

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/operations/layout.py

@@ -157,7 +157,7 @@ def set_visibility(sheet: Worksheet, visibility: Literal["visible", "hidden"]) -
 
 def hidden_lines(sheet: Worksheet, axis: Axis) -> list[str]:
     if axis == "rows":
-        indices = {index for index, row in sheet.row_dimensions.items() if row.hidden}
+        indices = {index for index, row in dict.items(sheet.row_dimensions) if row.hidden}
     else:
         indices = set()
         for column in sheet.column_dimensions.values():

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/operations/notes.py

@@ -5,6 +5,7 @@ from openpyxl.worksheet.worksheet import Worksheet
 from pydantic import BaseModel
 
 from excel_mcp.errors import InvalidArgumentError
+from excel_mcp.lazy_workbook import held_cells
 from excel_mcp.operations.cells import writable_cell
 from excel_mcp.refs import parse_cell
 
@@ -18,7 +19,7 @@ class NoteInfo(BaseModel):
 def list_notes(sheet: Worksheet) -> list[NoteInfo]:
     return [
         NoteInfo(cell=cell.coordinate, text=cell.comment.text, author=cell.comment.author or "")
-        for _, cell in sorted(sheet._cells.items())
+        for _, cell in sorted(held_cells(sheet).items())
         if cell.comment
     ]
 

{excel_mcp_server-2.2.1 → excel_mcp_server-2.2.2}/src/excel_mcp/server/sheet_tools.py

@@ -23,7 +23,7 @@ def register(tools: ToolRegistry, workspace: Workspace) -> None:
         """Describe a sheet: used range, panes, merges and everything on it (tables, charts,
         PivotTables, slicers, images, notes, hyperlinks, validation, conditional formats,
         sparklines...) with names and cells. Slow on very large files."""
-        with workspace.read(path, with_package=True) as workbook:
+        with workspace.read(path) as workbook:
             return inspect.describe_sheet(get_sheet(workbook, sheet))
 
     @tools.writer("Create sheet")