From 513c06c6943abf617da8c8118c39c46e98f93bef Mon Sep 17 00:00:00 2001 From: Afloat Date: Sat, 21 Nov 2026 11:22:10 +0800 Subject: [PATCH] feat(xlsx): allow hidden worksheets to be skipped without renumbering --- .../partition/test_xlsx_hidden_sheets.py | 66 +++++++++++++++++++ unstructured/partition/xlsx.py | 27 +++++++- 2 files changed, 90 insertions(+), 3 deletions(-) create mode 100644 test_unstructured/partition/test_xlsx_hidden_sheets.py diff --git a/test_unstructured/partition/test_xlsx_hidden_sheets.py b/test_unstructured/partition/test_xlsx_hidden_sheets.py new file mode 100644 index 0000000000..39164c1e82 --- /dev/null +++ b/test_unstructured/partition/test_xlsx_hidden_sheets.py @@ -0,0 +1,66 @@ +import io +from unittest.mock import Mock + +import openpyxl +import pytest +import xlrd + +from unstructured.partition import xlsx + + +@pytest.mark.parametrize("find_subtable", [False, True]) +def test_hidden_worksheets_can_be_skipped_without_renumbering(monkeypatch, find_subtable): + workbook = openpyxl.Workbook() + workbook.active.title = "Visible first" + workbook.create_sheet("Hidden").sheet_state = "hidden" + workbook.create_sheet("Very hidden").sheet_state = "veryHidden" + workbook.create_sheet("Visible last") + for sheet in workbook: + sheet.append(["Name", "Value"]) + sheet.append([sheet.title, 1]) + file = io.BytesIO() + workbook.save(file) + parsed = [] + original = xlsx.ExcelWorkbookReader.parse + + def parse(reader, name, *, header=None): + parsed.append(name) + return original(reader, name, header=header) + + monkeypatch.setattr(xlsx.ExcelWorkbookReader, "parse", parse) + + elements = xlsx.partition_xlsx( + file=file, + find_subtable=find_subtable, + include_hidden_sheets=False, + starting_page_number=5, + languages=["eng"], + ) + + assert parsed == ["Visible first", "Visible last"] + assert [e.metadata.page_name for e in elements] == parsed + assert [e.metadata.page_number for e in elements] == [5, 8] + + +def test_hidden_worksheets_remain_included_by_default(): + workbook = openpyxl.Workbook() + workbook.active.append(["Public", "value"]) + hidden = workbook.create_sheet("Hidden") + hidden.sheet_state = "hidden" + hidden.append(["Hidden", "value"]) + file = io.BytesIO() + workbook.save(file) + + elements = xlsx.partition_xlsx(file=file, find_subtable=False, languages=["eng"]) + + assert [e.metadata.page_name for e in elements] == ["Sheet", "Hidden"] + + +@pytest.mark.parametrize(("visibility", "expected"), [(0, False), (1, True), (2, True)]) +def test_xls_hidden_and_very_hidden_states_are_recognized(visibility, expected): + book = Mock(spec=xlrd.book.Book) + book.sheet_by_name.return_value.visibility = visibility + reader = xlsx.ExcelWorkbookReader(Mock(book=book)) + + assert reader.is_sheet_hidden("Legacy sheet") is expected + book.sheet_by_name.assert_called_once_with("Legacy sheet") diff --git a/unstructured/partition/xlsx.py b/unstructured/partition/xlsx.py index 399cb72841..28403a560c 100644 --- a/unstructured/partition/xlsx.py +++ b/unstructured/partition/xlsx.py @@ -60,6 +60,7 @@ def partition_xlsx( file: Optional[IO[bytes]] = None, find_subtable: bool = True, include_header: bool = False, + include_hidden_sheets: bool = True, infer_table_structure: bool = True, starting_page_number: int = 1, **kwargs: Any, @@ -84,6 +85,9 @@ def partition_xlsx( and is the text content of the table (no structure). include_header Determines whether or not header info is included in text and medatada.text_as_html + include_hidden_sheets + Include hidden and very-hidden worksheets by default. When False, skip them without + reading their cell data. Page numbers still refer to the original workbook sheet order. Notes ----- @@ -97,6 +101,7 @@ def partition_xlsx( file=file, find_subtable=find_subtable, include_header=include_header, + include_hidden_sheets=include_hidden_sheets, infer_table_structure=infer_table_structure, ) @@ -104,6 +109,8 @@ def partition_xlsx( for page_number, (sheet_name, sheet) in enumerate( opts.sheets.items(), start=starting_page_number ): + if sheet is None: + continue if not opts.find_subtable: text, html = _render_table(sheet, opts) @@ -200,6 +207,13 @@ def parse(self, sheet_name: str, *, header: int | None = None) -> pd.DataFrame: sheet_name=sheet_name, header=header, keep_default_na=False, na_values=[""] ) + def is_sheet_hidden(self, sheet_name: str) -> bool: + """Whether XLSX/XLS marks the worksheet hidden or very hidden.""" + book = self._reader.book + if isinstance(book, xlrd.book.Book): + return book.sheet_by_name(sheet_name).visibility != 0 + return book[sheet_name].sheet_state != "visible" + @contextmanager def open_excel_workbook( @@ -263,12 +277,14 @@ def __init__( find_subtable: bool, include_header: bool, infer_table_structure: bool, + include_hidden_sheets: bool = True, ): self._file_path = file_path self._file = file self._find_subtable = find_subtable self._include_header = include_header self._infer_table_structure = infer_table_structure + self._include_hidden_sheets = include_hidden_sheets @cached_property def find_subtable(self) -> bool: @@ -304,11 +320,16 @@ def metadata_file_path(self) -> str | None: return self._file_path @cached_property - def sheets(self) -> dict[str, pd.DataFrame]: - """The spreadsheet worksheets, each as a data-frame mapped by sheet-name.""" + def sheets(self) -> dict[str, pd.DataFrame | None]: + """Worksheets in workbook order; skipped hidden sheets retain a None placeholder.""" with open_excel_workbook(self._file_bytes, compact_empty_rows=self.find_subtable) as reader: return { - name: reader.parse(name, header=self.header_row_idx) for name in reader.sheet_names + name: ( + reader.parse(name, header=self.header_row_idx) + if self._include_hidden_sheets or not reader.is_sheet_hidden(name) + else None + ) + for name in reader.sheet_names } @cached_property