mirror of
https://github.com/infiniflow/ragflow.git
synced 2026-11-12 14:21:03 +08:00
292 lines
9.4 KiB
Python
292 lines
9.4 KiB
Python
#
|
||
# Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
|
||
#
|
||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||
# you may not use this file except in compliance with the License.
|
||
# You may obtain a copy of the License at
|
||
#
|
||
# http://www.apache.org/licenses/LICENSE-2.0
|
||
#
|
||
# Unless required by applicable law or agreed to in writing, software
|
||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
# See the License for the specific language governing permissions and
|
||
# limitations under the License.
|
||
#
|
||
|
||
import importlib.util
|
||
import os
|
||
import sys
|
||
from io import BytesIO
|
||
from unittest import mock
|
||
|
||
import pytest
|
||
|
||
# Import RAGFlowExcelParser directly by file path to avoid triggering
|
||
# deepdoc/parser/__init__.py and rag.nlp, which pull in heavy dependencies.
|
||
for _m in ["rag.nlp", "rag.utils", "rag.utils.lazy_image"]:
|
||
if _m not in sys.modules:
|
||
sys.modules[_m] = mock.MagicMock()
|
||
|
||
|
||
def _find_project_root(marker="pyproject.toml"):
|
||
d = os.path.dirname(os.path.abspath(__file__))
|
||
while d != os.path.dirname(d):
|
||
if os.path.exists(os.path.join(d, marker)):
|
||
return d
|
||
d = os.path.dirname(d)
|
||
return None
|
||
|
||
|
||
_PROJECT_ROOT = _find_project_root()
|
||
_spec = importlib.util.spec_from_file_location(
|
||
"deepdoc.parser.excel_parser",
|
||
os.path.join(_PROJECT_ROOT, "deepdoc", "parser", "excel_parser.py"),
|
||
)
|
||
_mod = importlib.util.module_from_spec(_spec)
|
||
sys.modules["deepdoc.parser.excel_parser"] = _mod
|
||
_spec.loader.exec_module(_mod)
|
||
|
||
RAGFlowExcelParser = _mod.RAGFlowExcelParser
|
||
|
||
|
||
def _test_find_codec(binary):
|
||
for encoding in ("utf-8-sig", "gb18030"):
|
||
try:
|
||
binary.decode(encoding)
|
||
return encoding
|
||
except UnicodeDecodeError:
|
||
continue
|
||
raise UnicodeDecodeError("test", binary, 0, 1, "undecodable")
|
||
|
||
|
||
_mod.find_codec = _test_find_codec
|
||
_mod.decode_text = lambda binary, document_type="text": (binary.decode(_test_find_codec(binary)), _test_find_codec(binary))
|
||
|
||
|
||
def _make_xlsx(n_data_rows):
|
||
from openpyxl import Workbook
|
||
|
||
wb = Workbook()
|
||
ws = wb.active
|
||
ws.append(["H1", "H2"])
|
||
for i in range(n_data_rows):
|
||
ws.append([f"a{i}", f"b{i}"])
|
||
buf = BytesIO()
|
||
wb.save(buf)
|
||
buf.seek(0)
|
||
return buf.read()
|
||
|
||
|
||
def _chunk_has_no_data_cells(chunk):
|
||
return "<td>" not in chunk and "<td></td>" not in chunk
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_exact_multiple_does_not_emit_header_only_chunk():
|
||
# 12 data rows with chunk_rows=12 (the value rag/app/naive.py uses).
|
||
chunks = RAGFlowExcelParser().html(_make_xlsx(12), chunk_rows=12)
|
||
assert len(chunks) == 1
|
||
assert all(not _chunk_has_no_data_cells(c[0]) for c in chunks)
|
||
assert chunks[0][1][0] == 0 and chunks[0][1][1] == 2 and chunks[0][1][2] == 13
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_multiple_of_chunk_rows_splits_without_spurious_chunk():
|
||
# 24 data rows with chunk_rows=12 -> exactly 2 data chunks, no trailing header-only chunk.
|
||
chunks = RAGFlowExcelParser().html(_make_xlsx(24), chunk_rows=12)
|
||
assert len(chunks) == 2
|
||
assert all(not _chunk_has_no_data_cells(c[0]) for c in chunks)
|
||
assert chunks[0][1][1] == 2 and chunks[0][1][2] == 13
|
||
assert chunks[1][1][1] == 14 and chunks[1][1][2] == 25
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_html_col_max_uses_widest_row():
|
||
from openpyxl import Workbook
|
||
|
||
wb = Workbook()
|
||
ws = wb.active
|
||
ws.append(["H1"])
|
||
ws.append(["a", "b", "c"])
|
||
buf = BytesIO()
|
||
wb.save(buf)
|
||
buf.seek(0)
|
||
chunks = RAGFlowExcelParser().html(buf.read(), chunk_rows=12)
|
||
assert chunks[0][1][3] == 1 and chunks[0][1][4] == 3
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_non_multiple_unchanged():
|
||
# 13 data rows with chunk_rows=12 -> 2 chunks (12 + 1).
|
||
chunks = RAGFlowExcelParser().html(_make_xlsx(13), chunk_rows=12)
|
||
assert len(chunks) == 2
|
||
assert all(not _chunk_has_no_data_cells(c[0]) for c in chunks)
|
||
|
||
|
||
def _make_xlsx_with_values(header, row):
|
||
from openpyxl import Workbook
|
||
|
||
wb = Workbook()
|
||
ws = wb.active
|
||
ws.append(header)
|
||
ws.append(row)
|
||
buf = BytesIO()
|
||
wb.save(buf)
|
||
buf.seek(0)
|
||
return buf.read()
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_call_keeps_zero_valued_cells():
|
||
# __call__ produces the text used for indexing. A numeric 0 (and 0.0 / False)
|
||
# is real data, not an empty cell, so it must survive. The header is only
|
||
# emitted alongside a kept value, so a dropped 0 also loses its "stock" label.
|
||
lines = RAGFlowExcelParser()(_make_xlsx_with_values(["name", "stock"], ["widget", 0]))
|
||
joined = " ".join(text for text, _ in lines)
|
||
assert "stock" in joined and "0" in joined, lines
|
||
assert lines[0][1][1] == 2
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_call_omits_a_blank_header_instead_of_labelling_it_none():
|
||
# A blank header cell has no label to give. str(None) is "None", which is
|
||
# truthy, so it defeats the separator guard and the literal token "None" is
|
||
# indexed and shown alongside the value it pretends to describe.
|
||
lines = RAGFlowExcelParser()(_make_xlsx_with_values(["name", None, "city"], ["widget", "note-1", "paris"]))
|
||
joined = " ".join(text for text, _ in lines)
|
||
assert joined == "name：widget; note-1; city：paris", lines
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_call_keeps_a_zero_header():
|
||
# Guards the tempting shorter fix, str(ti[i].value or ""), which would drop
|
||
# a numeric 0 header the same way it drops a None one. 0 is a real label.
|
||
lines = RAGFlowExcelParser()(_make_xlsx_with_values(["name", 0], ["widget", "note-1"]))
|
||
joined = " ".join(text for text, _ in lines)
|
||
assert "0：note-1" in joined, lines
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_call_skips_truly_empty_cells():
|
||
# None / empty-string cells carry no value and should still be skipped.
|
||
lines = RAGFlowExcelParser()(_make_xlsx_with_values(["name", "note"], ["widget", None]))
|
||
joined = " ".join(text for text, _ in lines)
|
||
assert "note" not in joined, lines
|
||
|
||
|
||
@pytest.mark.p2
|
||
@pytest.mark.parametrize("encoding", ["utf-8", "utf-8-sig", "gbk", "gb18030"])
|
||
def test_csv_encoding_is_detected_without_losing_unicode(encoding):
|
||
binary = "项目名称,备注\n核心系统重构,包含GBK语料导入测试\n".encode(encoding)
|
||
lines = RAGFlowExcelParser()(binary)
|
||
joined = " ".join(text for text, _ in lines)
|
||
assert "项目名称" in joined
|
||
assert "包含GBK语料导入测试" in joined
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_csv_accepts_gb18030_characters_not_supported_by_gbk():
|
||
binary = "项目名称,备注\n扩展字符,𠀀\n".encode("gb18030")
|
||
lines = RAGFlowExcelParser()(binary)
|
||
assert "备注：𠀀" in lines[0][0]
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_corrupt_csv_encoding_still_fails():
|
||
with pytest.raises(Exception, match="Failed to parse CSV"):
|
||
RAGFlowExcelParser()(b"\xff\xfe\xfa\xfb")
|
||
|
||
|
||
def _make_two_sheet_xlsx():
|
||
from openpyxl import Workbook
|
||
|
||
wb = Workbook()
|
||
ws1 = wb.active
|
||
ws1.title = "s1"
|
||
ws1.append(["H"])
|
||
ws1.append(["a"])
|
||
ws2 = wb.create_sheet("s2")
|
||
ws2.append(["H"])
|
||
ws2.append(["b"])
|
||
buf = BytesIO()
|
||
wb.save(buf)
|
||
buf.seek(0)
|
||
return buf.read()
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_call_emits_zero_based_sheet_index():
|
||
# Flow JSON stores this index unchanged; add_positions later does pn+1 so
|
||
# sheet 2 is stored as 2 and the preview selects xs.datas[1].
|
||
lines = RAGFlowExcelParser()(_make_two_sheet_xlsx())
|
||
sheets = {pos[0] for _, pos in lines}
|
||
assert sheets == {0, 1}
|
||
second = next(pos for _, pos in lines if pos[0] == 1)
|
||
assert second == (1, 2, 2, 1, 1)
|
||
|
||
|
||
def _make_large_used_range_xlsx(first_data_row, last_data_row, inflate_row=12000):
|
||
from openpyxl import Workbook
|
||
from openpyxl.styles import Font
|
||
|
||
wb = Workbook()
|
||
ws = wb.active
|
||
ws.cell(row=first_data_row, column=1, value="question")
|
||
ws.cell(row=first_data_row, column=2, value="answer")
|
||
for r in range(first_data_row + 1, last_data_row + 1):
|
||
ws.cell(row=r, column=1, value=f"Q{r}")
|
||
ws.cell(row=r, column=2, value=f"A{r}")
|
||
ws.cell(row=inflate_row, column=1).font = Font(bold=True)
|
||
buf = BytesIO()
|
||
wb.save(buf)
|
||
buf.seek(0)
|
||
return buf.read()
|
||
|
||
|
||
def _make_gap_xlsx(gap_rows, inflate_row=12000):
|
||
from openpyxl import Workbook
|
||
|
||
wb = Workbook()
|
||
ws = wb.active
|
||
ws["A1"] = "Name"
|
||
ws["B1"] = "City"
|
||
for r in range(2, 202):
|
||
ws.cell(row=r, column=1, value=f"n{r}")
|
||
ws.cell(row=r, column=2, value=f"c{r}")
|
||
second_block_start = 202 + gap_rows
|
||
for r in range(second_block_start, second_block_start + 200):
|
||
ws.cell(row=r, column=1, value=f"n{r}")
|
||
ws.cell(row=r, column=2, value=f"c{r}")
|
||
ws.cell(row=inflate_row, column=3, value=" ")
|
||
buf = BytesIO()
|
||
wb.save(buf)
|
||
buf.seek(0)
|
||
return buf.read()
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_large_used_range_with_blank_preamble_parses_all_rows():
|
||
# Regression for #19236: data below row 100 must not be treated as empty.
|
||
xlsx = _make_large_used_range_xlsx(150, 350)
|
||
rows = RAGFlowExcelParser()(xlsx)
|
||
assert len(rows) == 201
|
||
assert "Q350" in rows[-1][0]
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_large_used_range_with_blank_gap_parses_both_blocks():
|
||
# Regression for #19185: a blank gap must not truncate rows after it.
|
||
xlsx = _make_gap_xlsx(gap_rows=600)
|
||
rows = RAGFlowExcelParser()(xlsx)
|
||
assert len(rows) == 400
|
||
assert "n201" in rows[199][0]
|
||
assert "n802" in rows[200][0]
|
||
|
||
|
||
@pytest.mark.p2
|
||
def test_row_number_includes_rows_after_blank_gap():
|
||
xlsx = _make_gap_xlsx(gap_rows=600)
|
||
total = RAGFlowExcelParser.row_number("test.xlsx", xlsx)
|
||
assert total >= 1001
|