licos-dev-sdk 0.4.0__tar.gz → 0.4.1__tar.gz

{licos_dev_sdk-0.4.0 → licos_dev_sdk-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.4.0
+Version: 0.4.1
 Summary: LICOS Dev SDK - file generation and model capability clients
 Requires-Python: >=3.10
 Requires-Dist: beautifulsoup4>=4.12

{licos_dev_sdk-0.4.0 → licos_dev_sdk-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.4.0"
+version = "0.4.1"
 description = "LICOS Dev SDK - file generation and model capability clients"
 requires-python = ">=3.10"
 dependencies = [

{licos_dev_sdk-0.4.0 → licos_dev_sdk-0.4.1}/src/licos_dev_sdk/document_table_export.py

@@ -60,34 +60,55 @@ def extract_docx_table_columns(
     previous_table_number: int | None = None
 
     for table_number, table in enumerate(tables, start=1):
-        mapped_columns = tuple(
-            _scale_column(start, span, header.column_count, table.column_count)
-            for start, span in header.columns
+        local_header = _find_table_header_layout(
+            table,
+            normalized,
+            table_number=table_number,
         )
-        sequence_column = (
-            _scale_column(
+        layout = local_header or header
+        mapped_columns = (
+            tuple(start for start, _span in layout.columns)
+            if local_header is not None
+            else tuple(
+                _scale_column(start, span, header.column_count, table.column_count)
+                for start, span in header.columns
+            )
+        )
+        if local_header is not None:
+            sequence_column = local_header.sequence_column
+        elif header.sequence_column is not None:
+            sequence_column = _scale_column(
                 header.sequence_column,
                 1,
                 header.column_count,
                 table.column_count,
             )
-            if header.sequence_column is not None
-            else None
-        )
+        else:
+            sequence_column = None
 
         for row in table.rows:
-            if table_number == header.table_number and row.number <= header.row_number:
+            if local_header is not None and row.number <= local_header.row_number:
                 continue
-            if _is_header_row(row, normalized):
+            if _is_header_row(table, row, normalized):
                 continue
 
-            values = tuple(_text_at(row, column) for column in mapped_columns)
+            values = tuple(_text_at(table, row, column) for column in mapped_columns)
             if not any(values):
                 continue
 
-            sequence = _text_at(row, sequence_column) if sequence_column is not None else ""
+            sequence = (
+                _text_at(table, row, sequence_column)
+                if sequence_column is not None
+                else ""
+            )
             populated = sum(bool(value) for value in values)
-            if populated == 1 and not _is_numeric_sequence(sequence):
+            if _is_structural_heading(table, row, mapped_columns):
+                continue
+            if (
+                populated == 1
+                and sequence_column is not None
+                and not _is_numeric_sequence(sequence)
+            ):
                 if rows and previous_table_number == table_number and values[0]:
                     rows[-1][selected[0]] = _join_continuation(rows[-1][selected[0]], values[0])
                 continue
@@ -105,29 +126,56 @@ def _find_header_layout(
     normalized_columns: tuple[str, ...],
 ) -> _HeaderLayout:
     for table_number, table in enumerate(tables, start=1):
-        for row in table.rows:
-            cells = {_normalize_header(cell.text): cell for cell in row.cells if cell.text.strip()}
-            matched = [cells.get(column) for column in normalized_columns]
-            if all(cell is not None for cell in matched):
-                sequence_column = _sequence_column(row)
-                return _HeaderLayout(
-                    table_number=table_number,
-                    row_number=row.number,
-                    column_count=table.column_count,
-                    columns=tuple((cell.column, cell.col_span) for cell in matched if cell is not None),
-                    sequence_column=sequence_column,
-                )
+        layout = _find_table_header_layout(
+            table,
+            normalized_columns,
+            table_number=table_number,
+        )
+        if layout is not None:
+            return layout
     display = ", ".join(normalized_columns)
     raise ValueError(f"no DOCX table header row contains all requested columns: {display}")
 
 
-def _is_header_row(row: TableRow, normalized_columns: tuple[str, ...]) -> bool:
-    available = {_normalize_header(cell.text) for cell in row.cells if cell.text.strip()}
+def _find_table_header_layout(
+    table: TableModel,
+    normalized_columns: tuple[str, ...],
+    *,
+    table_number: int,
+) -> _HeaderLayout | None:
+    for row in table.rows:
+        cells = {
+            _normalize_header(cell.text): cell
+            for cell in _visible_cells(table, row.number)
+            if cell.text.strip()
+        }
+        matched = [cells.get(column) for column in normalized_columns]
+        if all(cell is not None for cell in matched):
+            return _HeaderLayout(
+                table_number=table_number,
+                row_number=row.number,
+                column_count=table.column_count,
+                columns=tuple((cell.column, cell.col_span) for cell in matched if cell is not None),
+                sequence_column=_sequence_column(table, row.number),
+            )
+    return None
+
+
+def _is_header_row(
+    table: TableModel,
+    row: TableRow,
+    normalized_columns: tuple[str, ...],
+) -> bool:
+    available = {
+        _normalize_header(cell.text)
+        for cell in _visible_cells(table, row.number)
+        if cell.text.strip()
+    }
     return all(column in available for column in normalized_columns)
 
 
-def _sequence_column(row: TableRow) -> int | None:
-    for cell in row.cells:
+def _sequence_column(table: TableModel, row_number: int) -> int | None:
+    for cell in _visible_cells(table, row_number):
         if _normalize_header(cell.text) in {"序号", "编号"}:
             return cell.column
     return None
@@ -148,13 +196,40 @@ def _scale_column(
     return min(max(mapped, 1), target_count)
 
 
-def _text_at(row: TableRow, column: int | None) -> str:
+def _text_at(table: TableModel, row: TableRow, column: int | None) -> str:
     if column is None:
         return ""
-    for cell in row.cells:
-        if cell.column <= column < cell.column + cell.col_span:
-            return cell.text.strip()
-    return ""
+    cell = table.cell_at(row.number, column)
+    return cell.text.strip() if cell is not None else ""
+
+
+def _visible_cells(table: TableModel, row_number: int) -> list[TableCell]:
+    cells: list[TableCell] = []
+    seen: set[int] = set()
+    for column in range(1, table.column_count + 1):
+        cell = table.cell_at(row_number, column)
+        if cell is not None and id(cell) not in seen:
+            cells.append(cell)
+            seen.add(id(cell))
+    return cells
+
+
+def _is_structural_heading(
+    table: TableModel,
+    row: TableRow,
+    mapped_columns: tuple[int, ...],
+) -> bool:
+    nonempty = [cell for cell in _visible_cells(table, row.number) if cell.text.strip()]
+    if len(nonempty) != 1:
+        return False
+    cell = nonempty[0]
+    selected_coverage = sum(
+        cell.column <= column < cell.column + cell.col_span
+        for column in mapped_columns
+    )
+    return cell.col_span > 1 and (
+        selected_coverage > 1 or cell.col_span * 2 >= table.column_count
+    )
 
 
 def _normalize_header(value: str) -> str:

{licos_dev_sdk-0.4.0 → licos_dev_sdk-0.4.1}/tests/test_document_table_export.py

@@ -84,6 +84,74 @@ def test_create_xlsx_from_docx_writes_native_workbook(tmp_path: Path):
         workbook.close()
 
 
+def test_extract_docx_columns_without_sequence_preserves_sparse_rows(tmp_path: Path):
+    source = tmp_path / "without-sequence.docx"
+    document = Document()
+    table = document.add_table(rows=5, cols=3)
+    for column, value in enumerate(["名称", "单位", "数量"]):
+        table.cell(0, column).text = value
+    for row, values in enumerate(
+        [
+            ["泵", "台", "2"],
+            ["备用泵", "", ""],
+            ["阀门", "个", ""],
+            ["液位计", "", "1"],
+        ],
+        start=1,
+    ):
+        for column, value in enumerate(values):
+            table.cell(row, column).text = value
+    document.save(source)
+
+    rows = extract_docx_table_columns(source, ["名称", "单位", "数量"])
+
+    assert rows == [
+        {"名称": "泵", "单位": "台", "数量": "2"},
+        {"名称": "备用泵", "单位": "", "数量": ""},
+        {"名称": "阀门", "单位": "个", "数量": ""},
+        {"名称": "液位计", "单位": "", "数量": "1"},
+    ]
+
+
+def test_extract_docx_columns_without_sequence_skips_merged_heading(tmp_path: Path):
+    source = tmp_path / "merged-heading.docx"
+    document = Document()
+    table = document.add_table(rows=3, cols=3)
+    for column, value in enumerate(["名称", "单位", "数量"]):
+        table.cell(0, column).text = value
+    table.cell(1, 0).merge(table.cell(1, 2)).text = "泵类设备"
+    for column, value in enumerate(["循环泵", "台", "2"]):
+        table.cell(2, column).text = value
+    document.save(source)
+
+    rows = extract_docx_table_columns(source, ["名称", "单位", "数量"])
+
+    assert rows == [{"名称": "循环泵", "单位": "台", "数量": "2"}]
+
+
+def test_extract_docx_columns_handles_multilevel_header_and_vertical_data_merge(tmp_path: Path):
+    source = tmp_path / "multilevel-header.docx"
+    document = Document()
+    table = document.add_table(rows=4, cols=3)
+    table.cell(0, 0).merge(table.cell(1, 0)).text = "名称"
+    table.cell(0, 1).merge(table.cell(0, 2)).text = "属性"
+    table.cell(1, 1).text = "单位"
+    table.cell(1, 2).text = "数量"
+    table.cell(2, 0).text = "主泵"
+    table.cell(2, 1).merge(table.cell(3, 1)).text = "台"
+    table.cell(2, 2).text = "2"
+    table.cell(3, 0).text = "备用泵"
+    table.cell(3, 2).text = "1"
+    document.save(source)
+
+    rows = extract_docx_table_columns(source, ["名称", "单位", "数量"])
+
+    assert rows == [
+        {"名称": "主泵", "单位": "台", "数量": "2"},
+        {"名称": "备用泵", "单位": "台", "数量": "1"},
+    ]
+
+
 def test_extract_docx_columns_requires_a_complete_header(tmp_path: Path):
     source = tmp_path / "source.docx"
     document = Document()