excel-mcp-server 2.2.6__tar.gz → 2.2.7__tar.gz

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: excel-mcp-server
-Version: 2.2.6
+Version: 2.2.7
 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
@@ -233,7 +233,7 @@ docker run -p 8017:8017 -v "$PWD/workbooks:/data" -e EXCEL_MCP_AUTH_TOKEN=change
 | `--allow-vba-write` | `EXCEL_MCP_ALLOW_VBA_WRITE=1` | off | Add tools that write VBA macros (see warning below); ignored with `--read-only` |
 | `--tools AREAS` | `EXCEL_MCP_TOOLS` | all | Only offer the core tools and these comma-separated areas, to save context (see [Choosing tools](#choosing-tools)) |
 | `--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-cells N` | `EXCEL_MCP_MAX_CELLS` | `100000` | Most cells one call may read, write or format; reads are still returned in pages; also bounds text to 256 characters per cell on average |
 | `--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 |
@@ -343,7 +343,7 @@ refused, since any change would invalidate the signature.
   `http(s)://`, `mailto:` or `#Sheet!A1` link only.
 - Paths are resolved, including symlinks, before they are checked against the allowed
   folders. Network (UNC) and Windows device paths are always rejected.
-- A single call processes at most 100,000 cells (`--max-cells`), and large reads are returned in pages.
+- A single call processes at most 100,000 cells (`--max-cells`) and, on average, 256 characters of text per cell (25.6 million characters at the default), and large reads are returned in pages. Text a workbook stores once but many cells hold is counted in every cell, and a workbook that saving would expand past the unpacked-size limit is refused.
 - Cell contents are data from files. The server tells the model not to follow instructions
   found in them, but review what an assistant does with workbooks from untrusted sources.
 

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/README.md

@@ -197,7 +197,7 @@ docker run -p 8017:8017 -v "$PWD/workbooks:/data" -e EXCEL_MCP_AUTH_TOKEN=change
 | `--allow-vba-write` | `EXCEL_MCP_ALLOW_VBA_WRITE=1` | off | Add tools that write VBA macros (see warning below); ignored with `--read-only` |
 | `--tools AREAS` | `EXCEL_MCP_TOOLS` | all | Only offer the core tools and these comma-separated areas, to save context (see [Choosing tools](#choosing-tools)) |
 | `--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-cells N` | `EXCEL_MCP_MAX_CELLS` | `100000` | Most cells one call may read, write or format; reads are still returned in pages; also bounds text to 256 characters per cell on average |
 | `--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 |
@@ -307,7 +307,7 @@ refused, since any change would invalidate the signature.
   `http(s)://`, `mailto:` or `#Sheet!A1` link only.
 - Paths are resolved, including symlinks, before they are checked against the allowed
   folders. Network (UNC) and Windows device paths are always rejected.
-- A single call processes at most 100,000 cells (`--max-cells`), and large reads are returned in pages.
+- A single call processes at most 100,000 cells (`--max-cells`) and, on average, 256 characters of text per cell (25.6 million characters at the default), and large reads are returned in pages. Text a workbook stores once but many cells hold is counted in every cell, and a workbook that saving would expand past the unpacked-size limit is refused.
 - Cell contents are data from files. The server tells the model not to follow instructions
   found in them, but review what an assistant does with workbooks from untrusted sources.
 

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/pyproject.toml

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

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/pyproject.toml.orig

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

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/calc/engine.py

@@ -121,7 +121,7 @@ class Engine:
         if cell is None:
             return None
         if cell.data_type != "f":
-            return constant(cell)
+            return self.sized(constant(cell))
         key = (sheet.title, row, col)
         if key in self.memo:
             remembered = self.memo[key]

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/cells.py

@@ -1,12 +1,14 @@
 """Reading, writing, clearing, copying and searching cell contents."""
 
 from collections.abc import Iterator
+from contextlib import closing
 
 from openpyxl.cell.cell import Cell, MergedCell
 from openpyxl.worksheet._read_only import ReadOnlyWorksheet
 from openpyxl.worksheet.worksheet import Worksheet
 from pydantic import BaseModel
 
+from excel_mcp.config import Limits
 from excel_mcp.errors import InvalidArgumentError, LimitExceededError
 from excel_mcp.lazy_workbook import LazyCells, held_cells
 from excel_mcp.operations.date_width import FITTED_WIDTHS, widen_for_dates
@@ -22,6 +24,7 @@ from excel_mcp.refs import (
     parse_clamped_range,
     parse_range,
 )
+from excel_mcp.text_budget import CHARS_PER_CELL, TextBudget
 from excel_mcp.values import CellValue, date_number_format, to_cell, to_json, typed_value
 from excel_mcp.workspace import sheet_names
 from excel_mcp.xlfn import display_formula
@@ -192,7 +195,24 @@ def read_range(sheet: ReadOnlyWorksheet, ref: str | None, max_cells: int) -> Ran
         max_col=target.max_col,
         values_only=True,
     )
-    values = [[_displayed(to_json(value)) for value in row] for row in rows]
+    values = []
+    characters, limit, cut = 0, max_cells * CHARS_PER_CELL, False
+    with closing(rows):
+        for row in rows:
+            line = [_displayed(to_json(value)) for value in row]
+            size = sum(len(value) for value in line if isinstance(value, str))
+            if characters + size > limit:
+                if not values:
+                    raise LimitExceededError(
+                        f"Row {target.min_row} of {target} holds more than {limit:,} characters of "
+                        "text, the limit per page. Read fewer columns."
+                    )
+                cut = True
+                break
+            characters += size
+            values.append(line)
+    if cut:
+        last_row = target.min_row + len(values) - 1
     for row in values:
         while row and row[-1] is None:
             row.pop()
@@ -279,21 +299,35 @@ def find_cells(
     exact: bool,
     case_sensitive: bool,
     max_results: int,
+    limits: Limits,
 ) -> FindResult:
+    """Cells whose text contains (or equals) ``query``. The text searched and the text returned
+    are counted, so a workbook of many cells sharing one long text cannot make a search long or
+    its result large."""
+
     def normalize(text: str) -> str:
         return text if case_sensitive else text.casefold()
 
+    scanned = TextBudget(
+        limits.max_loaded_cells,
+        "Searching would read more than {limit} characters of text. Search one sheet at a "
+        "time, or raise --max-loaded-cells.",
+    )
+    page = limits.max_read_cells * CHARS_PER_CELL
     needle = normalize(query)
     matches: dict[str, dict[str, CellValue]] = {}
-    count = 0
+    count = returned = 0
     for sheet in sheets:
         for row, col, value in streamed_cells(sheet):
             shown = _displayed(to_json(value))
-            text = normalize(str(shown))
+            text = str(shown)
+            scanned.spend(len(text))
+            text = normalize(text)
             if not (text == needle if exact else needle in text):
                 continue
-            if count == max_results:
+            if count == max_results or (count and returned + len(text) > page):
                 return FindResult(matches=matches, truncated=True)
             matches.setdefault(sheet.title, {})[cell_name(row, col)] = shown
             count += 1
+            returned += len(text)
     return FindResult(matches=matches)

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/csv_export.py

@@ -14,6 +14,7 @@ from excel_mcp.errors import InvalidArgumentError, LimitExceededError
 from excel_mcp.operations.calculated import read_calculated
 from excel_mcp.operations.csv_format import DELIMITER_CHARACTERS, FORMULA_STARTS, Encoding
 from excel_mcp.refs import CellRange, cell_name, parse_range
+from excel_mcp.text_budget import CHARS_PER_CELL, TextBudget
 from excel_mcp.values import CellValue
 from excel_mcp.workspace import Workspace, get_streamed_sheet
 
@@ -42,9 +43,14 @@ def export_csv(
     data = read_calculated(workspace, path, sheet, ref, max_cells)
     if data.next_range:
         raise LimitExceededError(
-            f"The range has more than {max_cells:,} cells, the limit per call. Export a "
-            "smaller range or raise --max-cells."
+            f"The range has more than {max_cells:,} cells or {max_cells * CHARS_PER_CELL:,} "
+            "characters of text, the limit per call. Export a smaller range or raise --max-cells."
         )
+    budget = TextBudget(
+        max_cells,
+        "The range as displayed has more than {limit} characters of text, the limit per call. "
+        "Export a smaller range or raise --max-cells.",
+    )
     area = parse_range(data.range)
     formats = _formats(workspace, path, sheet, area) if formatted else None
     buffer = io.StringIO(newline="")
@@ -57,6 +63,7 @@ def export_csv(
             number_format = formats[row][column] if formats else None
             try:
                 fields.append(_field(value, number_format, escape_formulas))
+                budget.spend(len(fields[-1]))
             except UncalculableError as reason:
                 where = cell_name(area.min_row + row, area.min_col + column)
                 raise InvalidArgumentError(

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/csv_import.py

@@ -1,8 +1,10 @@
 """Reading a CSV file into a worksheet."""
 
 import csv
+from collections.abc import Iterator
 from dataclasses import dataclass
 from pathlib import Path
+from typing import TextIO
 
 from openpyxl.cell.cell import ILLEGAL_CHARACTERS_RE
 from openpyxl.worksheet.worksheet import Worksheet
@@ -48,7 +50,8 @@ def import_csv(
         with file.open(encoding=codec, newline="") as stream:
             separator = _separator(stream.read(_SAMPLE_CHARACTERS), delimiter)
             stream.seek(0)
-            for offset, record in enumerate(csv.reader(stream, delimiter=separator), start=1):
+            lines = _lines_within(stream, separator, max_cells)
+            for offset, record in enumerate(csv.reader(lines, delimiter=separator), start=1):
                 row = first_row + offset - 1
                 if record and (row > MAX_ROW or first_col + len(record) - 1 > MAX_COLUMN):
                     raise InvalidArgumentError(
@@ -56,10 +59,7 @@ def import_csv(
                     )
                 cells += len(record)
                 if cells > max_cells:
-                    raise LimitExceededError(
-                        f"The file has more than {max_cells:,} cells, the limit per call. "
-                        "Split the file or raise --max-cells."
-                    )
+                    raise _too_many_cells(max_cells)
                 for index, text in enumerate(record):
                     column = first_col + index
                     if width := _store(sheet, row, column, text, offset, rules):
@@ -79,6 +79,23 @@ def import_csv(
     return WriteResult(sheet=sheet.title, range=str(written), cells_written=cells)
 
 
+def _too_many_cells(max_cells: int) -> LimitExceededError:
+    return LimitExceededError(
+        f"The file has more than {max_cells:,} cells, the limit per call. "
+        "Split the file or raise --max-cells."
+    )
+
+
+def _lines_within(stream: TextIO, separator: str, max_cells: int) -> Iterator[str]:
+    """The lines of the file, refusing one with more delimiters than the limit has cells before
+    the reader makes a field of each: a record is held whole, so its length is not bounded by
+    the count of cells made so far."""
+    for line in stream:
+        if line.count(separator) >= max_cells:
+            raise _too_many_cells(max_cells)
+        yield line
+
+
 def _separator(sample: str, delimiter: str) -> str:
     """The delimiter named, or for 'auto' the most frequent usual one in the first record."""
     if delimiter != "auto":

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/duplicates.py

@@ -8,6 +8,7 @@ from excel_mcp.operations.columns import find_column
 from excel_mcp.operations.comparison import FormulaResults, as_number, cell_value
 from excel_mcp.operations.sorting import save_cells, write_rows
 from excel_mcp.refs import CellRange
+from excel_mcp.text_budget import TextBudget
 
 
 def remove_duplicates(
@@ -16,6 +17,7 @@ def remove_duplicates(
     columns: list[str] | None,
     has_header: bool,
     results: FormulaResults,
+    max_cells: int,
 ) -> int:
     """Move the rows to keep up, empty the rows left at the bottom, and return how many went.
 
@@ -35,12 +37,17 @@ def remove_duplicates(
         if columns
         else list(range(area.min_col, area.max_col + 1))
     )
+    budget = TextBudget(
+        max_cells,
+        "Comparing rows would read more than {limit} characters of text. Use fewer rows, or "
+        "raise --max-cells.",
+    )
     seen: set[tuple[object, ...]] = set()
     kept = []
     for cells in sheet.iter_rows(
         min_row=first_row, max_row=area.max_row, min_col=area.min_col, max_col=area.max_col
     ):
-        key = tuple(_comparable(cells[col - area.min_col], results) for col in chosen)
+        key = tuple(_comparable(cells[col - area.min_col], results, budget) for col in chosen)
         if key not in seen:
             seen.add(key)
             kept.append(save_cells(cells))
@@ -60,12 +67,15 @@ def remove_duplicates(
     return removed
 
 
-def _comparable(cell: Cell | MergedCell, results: FormulaResults) -> tuple[str, object]:
+def _comparable(
+    cell: Cell | MergedCell, results: FormulaResults, budget: TextBudget
+) -> tuple[str, object]:
     value = cell_value(cell, results)
     if isinstance(value, bool):
         return "boolean", value
     if (number := as_number(value)) is not None:
         return "number", number
     if isinstance(value, str):
+        budget.spend(len(value))
         return "text", value.casefold()
     return "blank", None

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/fill.py

@@ -134,9 +134,14 @@ def _values(
             raise InvalidArgumentError("A date series starts from a date cell.")
         if step != int(step):
             raise InvalidArgumentError("A date series needs a whole-number step.")
-        values: list[int | float | dt.date] = [
-            _add_dates(seed, unit, int(step) * index) for index in range(count)
-        ]
+        try:
+            values: list[int | float | dt.date] = [
+                _add_dates(seed, unit, int(step) * index) for index in range(count)
+            ]
+        except (OverflowError, ValueError):
+            raise InvalidArgumentError(
+                "The series goes past the last date a cell can hold."
+            ) from None
         numbers = [float(to_excel(value)) for value in values]
     else:
         if isinstance(seed, bool) or not isinstance(seed, int | float):
@@ -172,9 +177,16 @@ def _add_dates(seed: dt.date, unit: DateUnit, amount: int) -> dt.date:
 
 
 def _add_weekdays(seed: dt.date, amount: int) -> dt.date:
-    direction = 1 if amount >= 0 else -1
+    """``amount`` weekdays on from ``seed``: whole weeks at once, then the few days left."""
+    if amount == 0:
+        return seed
+    direction = 1 if amount > 0 else -1
     result = seed
-    for _ in range(abs(amount)):
+    while result.weekday() >= 5:  # a weekend seed counts from the weekday it follows
+        result -= dt.timedelta(days=direction)
+    weeks, days = divmod(abs(amount), 5)
+    result += dt.timedelta(days=7 * weeks * direction)
+    for _ in range(days):
         result += dt.timedelta(days=direction)
         while result.weekday() >= 5:
             result += dt.timedelta(days=direction)

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/layout.py

@@ -19,6 +19,7 @@ from excel_mcp.operations.sheet_view import ViewOptions, apply_view, move_sheet
 from excel_mcp.operations.spans import MAX_ROW_SPAN, parse_span, to_spans
 from excel_mcp.package.lines import Axis
 from excel_mcp.refs import MAX_ROW, parse_cell
+from excel_mcp.text_budget import TextBudget
 
 MIN_AUTOFIT_WIDTH = 8
 MAX_AUTOFIT_WIDTH = 80
@@ -78,9 +79,12 @@ def apply_layout(
         if not 1 <= row <= MAX_ROW:
             raise InvalidArgumentError(f"Row {row} is outside 1 to {MAX_ROW}.")
         sheet.row_dimensions[row].height = height
-    for column in layout.autofit_columns or []:
-        letter = column_letter(column)
-        sheet.column_dimensions[letter].width = estimate_width(sheet, letter)
+    if layout.autofit_columns:
+        fitted = estimate_widths(
+            sheet, [column_letter(c) for c in layout.autofit_columns], max_cells
+        )
+        for letter, width in fitted.items():
+            sheet.column_dimensions[letter].width = width
     if layout.freeze_panes is not None:
         parse_cell(layout.freeze_panes)
         sheet.freeze_panes = layout.freeze_panes.upper()
@@ -187,14 +191,23 @@ def column_letter(column: str) -> str:
         ) from None
 
 
-def estimate_width(sheet: Worksheet, letter: str) -> float:
-    """Approximate a fitting width from the longest text line in the column."""
-    index = column_index_from_string(letter)
-    lines = [
-        line
-        for cell in stored_cells(sheet)
-        if cell.column == index
-        for line in str(cell.value).splitlines()
-    ]
-    longest = max((len(line) for line in lines), default=0)
-    return min(max(longest + 2, MIN_AUTOFIT_WIDTH), MAX_AUTOFIT_WIDTH)
+def estimate_widths(sheet: Worksheet, letters: list[str], max_cells: int) -> dict[str, float]:
+    """Approximate fitting widths from the longest text line in each column, in one pass over the
+    cells however many columns are asked for."""
+    budget = TextBudget(
+        max_cells,
+        "Fitting columns would read more than {limit} characters of text. Fit fewer columns, "
+        "or raise --max-cells.",
+    )
+    wanted = {column_index_from_string(letter): letter for letter in letters}
+    longest = dict.fromkeys(wanted, 0)
+    for cell in stored_cells(sheet):
+        if cell.column in wanted:
+            text = str(cell.value)
+            budget.spend(len(text))
+            lines = max(map(len, text.splitlines()), default=0)
+            longest[cell.column] = max(longest[cell.column], lines)
+    return {
+        letter: min(max(longest[index] + 2, MIN_AUTOFIT_WIDTH), MAX_AUTOFIT_WIDTH)
+        for index, letter in wanted.items()
+    }

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/pivot.py

@@ -32,7 +32,7 @@ from excel_mcp.operations.pivot_options import (
     PivotValue,
     ValuesIn,
 )
-from excel_mcp.operations.pivot_render import Shown, item_label, number_format, render
+from excel_mcp.operations.pivot_render import Shown, item_label, measure, number_format, render
 from excel_mcp.operations.pivot_showas import Figures
 from excel_mcp.operations.pivot_source import Results, Source, read_source, serial
 from excel_mcp.operations.pivot_specs import (
@@ -103,19 +103,22 @@ def create_pivot(
     rows, columns, aggregator = _axes(
         source, calculated, specs, on_rows, on_columns, [*pages, *hidden], request
     )
-    formats = [number_format(spec, _source_format(source, spec)) for spec in specs]
-    figures = Figures(aggregator, rows, columns, specs)
-    table = render(rows, columns, specs, figures, formats, request.layout)
+    # The table is as big as the items of its axes make it, which is not bounded by the source's
+    # cells (a few thousand records can make millions), so it is checked before it is built.
+    size = measure(rows, columns, request.layout)
     start_row, start_col = parse_cell(target_cell)
     filter_height = len(pages) + 1 if pages else 0
     body = CellRange(
         start_row + filter_height,
         start_col,
-        start_row + filter_height + table.header_rows + table.rows - 1,
-        start_col + table.label_columns + table.columns - 1,
+        start_row + filter_height + size.header_rows + size.rows - 1,
+        start_col + size.label_columns + size.columns - 1,
     )
     area = CellRange(start_row, start_col, body.max_row, body.max_col).within(limits.max_cells)
     _check_free(target_sheet, area, source_sheet, source.ref)
+    formats = [number_format(spec, _source_format(source, spec)) for spec in specs]
+    figures = Figures(aggregator, rows, columns, specs)
+    table = render(rows, columns, specs, figures, formats, request.layout)
 
     pivot_name = _pivot_name(workbook, request.name, copy_of_name)
     page_filters = [_page_filter(axis) for axis in pages]

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/pivot_records.py

@@ -26,7 +26,7 @@ ESCAPES = str.maketrans(
         "\t": "	",
     }
 )
-BATCH = 10_000
+BATCH_CHARACTERS = 1 << 20
 
 
 class SharedIndex(int):
@@ -57,9 +57,16 @@ class PivotRecords(RecordList):
 
 def _write_xml(stream: IO[bytes], rows: Sequence[Row]) -> None:
     stream.write(f'<pivotCacheRecords xmlns="{SHEET_MAIN_NS}" count="{len(rows)}">'.encode())
-    for start in range(0, len(rows), BATCH):
-        batch = rows[start : start + BATCH]
-        stream.write("".join(f"<r>{''.join(_items(row))}</r>" for row in batch).encode())
+    batch: list[str] = []
+    size = 0
+    for row in rows:
+        record = f"<r>{''.join(_items(row))}</r>"
+        batch.append(record)
+        size += len(record)
+        if size >= BATCH_CHARACTERS:
+            stream.write("".join(batch).encode())
+            batch, size = [], 0
+    stream.write("".join(batch).encode())
     stream.write(b"</pivotCacheRecords>")
 
 

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/pivot_render.py

@@ -33,6 +33,13 @@ class Table:
     columns: int
 
 
+def measure(rows: Axis, columns: Axis, layout: Layout) -> Table:
+    """The size of the table the axes make, before any of its cells are."""
+    label_columns = 1 if layout == "compact" else len(rows.fields) + rows.value_levels
+    header_rows = 1 + len(columns.fields) + columns.value_levels
+    return Table({}, header_rows, label_columns, len(rows.lines), len(columns.lines))
+
+
 def render(
     rows: Axis,
     columns: Axis,
@@ -42,9 +49,8 @@ def render(
     layout: Layout,
 ) -> Table:
     """``formats`` holds each values field's number format."""
-    label_columns = 1 if layout == "compact" else len(rows.fields) + rows.value_levels
-    header_rows = 1 + len(columns.fields) + columns.value_levels
-    table = Table({}, header_rows, label_columns, len(rows.lines), len(columns.lines))
+    table = measure(rows, columns, layout)
+    header_rows, label_columns = table.header_rows, table.label_columns
     cells = table.cells
     _headers(cells, rows, columns, specs, layout, header_rows, label_columns)
     _column_labels(cells, columns, specs, label_columns)

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/pivot_source.py

@@ -17,6 +17,7 @@ from excel_mcp.lazy_workbook import LazyCells
 from excel_mcp.operations.comparison import FormulaResults
 from excel_mcp.refs import CellRange, cell_name, parse_range
 from excel_mcp.text import quoted
+from excel_mcp.text_budget import TextBudget
 
 Value = str | int | float | bool | dt.datetime | ExcelError | None
 """A cell as a PivotTable sees it. Dates, times and durations are moments counted from `EPOCH`."""
@@ -95,9 +96,20 @@ def read_source(sheet: Worksheet, source_range: str, max_cells: int, results: Re
         )
     if area.rows < 2:
         raise InvalidArgumentError(f"source {area} needs a header row and at least one data row.")
+    # The cache stores a text once per record unless it is an item of an axis, so the text of the
+    # source is counted, not only its cells.
+    budget = TextBudget(
+        max_cells,
+        f"Source {area} has more than {{limit}} characters of text; PivotTables can read at most "
+        "that. Use a smaller source, or raise --max-pivot-cells (environment variable "
+        "EXCEL_MCP_MAX_PIVOT_CELLS).",
+    )
     if isinstance(sheet._cells, LazyCells) and (
         stored := sheet._cells.stored_rows(area.min_row, area.max_row)
     ):
+        budget.spend(
+            sum(len(c[1]) for row in stored for c in row.values() if isinstance(c[1], str))
+        )
         return _read_stored(sheet, area, stored)
     rows = [
         list(row)
@@ -105,6 +117,9 @@ def read_source(sheet: Worksheet, source_range: str, max_cells: int, results: Re
             min_row=area.min_row, max_row=area.max_row, min_col=area.min_col, max_col=area.max_col
         )
     ]
+    budget.spend(
+        sum(len(cell.value) for row in rows for cell in row if isinstance(cell.value, str))
+    )
     names = [_header(cell) for cell in rows[0]]
     folded = [name.strip().casefold() for name in names]
     if len(set(folded)) < len(folded):

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/replace.py

@@ -6,8 +6,12 @@ from openpyxl.worksheet.worksheet import Worksheet
 from pydantic import BaseModel
 
 from excel_mcp import lazy_find
+from excel_mcp.calc.values import MAX_TEXT
+from excel_mcp.config import Limits
+from excel_mcp.errors import LimitExceededError
 from excel_mcp.lazy_workbook import LazyCells
 from excel_mcp.operations.cells import parsed_cells, store_typed
+from excel_mcp.text_budget import TextBudget
 from excel_mcp.workspace import sheet_names
 from excel_mcp.xlfn import display_formula
 
@@ -24,6 +28,7 @@ def replace_cells(
     exact: bool,
     case_sensitive: bool,
     in_formulas: bool,
+    limits: Limits,
 ) -> ReplaceResult:
     """Replace text in text, number and (optionally) formula cells; the result is retyped.
 
@@ -38,6 +43,14 @@ def replace_cells(
     def matches(text: str) -> bool:
         return found(text) is not None
 
+    grown = TextBudget(
+        limits.max_cells,
+        "Replacing would add more than {limit} characters of text. Replace in one sheet at a "
+        "time, with shorter text, or raise --max-cells.",
+    )
+    # A workbook can hold one long text and point millions of cells at it: each text is worked
+    # out once, and its result is shared by every cell that holds it.
+    results: dict[str, str | None] = {}
     replaced: dict[str, int] = {}
     for sheet in sheets:
         names = sheet_names(sheet)
@@ -48,11 +61,11 @@ def replace_cells(
             text = _searchable_text(cell.value, cell.data_type, in_formulas)
             if text is None:
                 continue
-            if exact:
-                new_text = replacement if pattern.fullmatch(text) else text
-            else:
-                new_text = pattern.sub(lambda _: replacement, text)
-            if new_text != text:
+            if text not in results:
+                new_text = _replaced(pattern, text, query, replacement, exact=exact)
+                grown.spend(max(0, len(new_text) - len(text)))
+                results[text] = None if new_text == text else new_text
+            if (new_text := results[text]) is not None:
                 store_typed(cell, new_text, names)
                 changed += 1
         if changed:
@@ -60,6 +73,29 @@ def replace_cells(
     return ReplaceResult(replaced=replaced)
 
 
+def _replaced(
+    pattern: re.Pattern[str], text: str, query: str, replacement: str, *, exact: bool
+) -> str:
+    """``text`` with the matches replaced; refused, before it is built, if too long for a cell."""
+    if exact:
+        if pattern.fullmatch(text) is None:
+            return text
+        _fit(len(replacement))
+        return replacement
+    if len(replacement) > len(query):
+        found = list(pattern.finditer(text))
+        _fit(len(text) + sum(len(replacement) - f.end() + f.start() for f in found))
+    return pattern.sub(lambda _: replacement, text)
+
+
+def _fit(size: int) -> None:
+    if size > MAX_TEXT:
+        raise LimitExceededError(
+            f"Replacing would make a cell longer than {MAX_TEXT:,} characters, the limit of "
+            "an Excel cell."
+        )
+
+
 def _searchable_text(value: object, data_type: str, in_formulas: bool) -> str | None:
     if data_type == "f":
         return display_formula(value) if in_formulas and isinstance(value, str) else None

{excel_mcp_server-2.2.6 → excel_mcp_server-2.2.7}/src/excel_mcp/operations/slicers.py

@@ -80,7 +80,7 @@ def add_slicer(
             raise InvalidArgumentError(
                 "A table slicer connects to its table only, and tables have no timelines."
             )
-        return _table_slicer(workbook, sheet, owner, target, request, results), False
+        return _table_slicer(workbook, sheet, owner, target, request, limits, results), False
     pivots.share_caches(workbook)
     group = _connected(workbook, owner, target, request)
     if request.timeline:
@@ -94,6 +94,7 @@ def _table_slicer(
     owner: Worksheet,
     table: Table,
     request: SlicerRequest,
+    limits: Limits,
     results: Results,
 ) -> str:
     _check_style(request.style, "slicer")
@@ -101,6 +102,8 @@ def _table_slicer(
     _check_free_column(workbook, table, column.name)
     name, cache = _names(workbook, request, "Slicer_")
     if request.selected:
+        # The size of a table is whatever its file says, so it is checked like any range.
+        table_area(table).within(limits.max_cells)
         slicer_table.show_only(
             owner, table, column.name, request.selected, results(owner, table_area(table))
         )