tablecheck 0.1.0__py3-none-any.whl

tablecheck/__init__.py

@@ -0,0 +1,7 @@
+"""tablecheck —— 中文/繁体 PDF 表格结构检查器（离线、确定性、纯本地）。
+
+对外只暴露版本号；实际逻辑在 cli/detect/struct/cjk/schema 四个模块里。
+"""
+
+__version__ = "0.1.0"
+__all__ = ["__version__"]

tablecheck/cjk.py

@@ -0,0 +1,128 @@
+"""CJK 识别：中文/日文/韩文字符占比、是否混排、是否疑似竖排。
+
+这三个信号是给中文/繁体 PDF 用的前置判断：
+- ``script_ratio`` 低 → 大概率是英文文档，表头判定的规则要另说；
+- ``mixed`` 为真 → 中英混排，单元格换行会破坏表格对齐；
+- ``vertical_suspect`` 为真 → 可能是直排（竖排）文本，几何表格检测会失准。
+
+判定全部基于 PyMuPDF 的文本块，纯本地、确定性，同一文件多次跑结果一致。
+"""
+
+from __future__ import annotations
+
+CJK_RANGES = (
+    (0x2E80, 0x2EFF),  # CJK 部首补充
+    (0x3000, 0x303F),  # CJK 符号与标点
+    (0x3040, 0x30FF),  # 平假名、片假名
+    (0x3400, 0x4DBF),  # CJK 扩展 A
+    (0x4E00, 0x9FFF),  # CJK 统一汉字
+    (0xF900, 0xFAFF),  # 兼容汉字
+    (0xAC00, 0xD7AF),  # 韩文音节
+    (0x1100, 0x11FF),  # 韩文字母
+    (0x20000, 0x2FA1F),  # CJK 扩展 B 及以后
+)
+
+CJK_FONT_HINTS = (
+    "song", "sun", "ming", "kai", "hei", "gothic", "mincho", "fangsong",
+    "noto sans cjk", "notosanscjk", "noto serif cjk", "source han", "sourcehan",
+    "msung", "mingliu", "dfkai", "pmingliu", "simsun", "simhei", "kaiti",
+    "yuanti", "droidsansfallback", "wqy", "arphic", "uming", "ukai",
+)
+
+MIN_BLOCKS_FOR_VERTICAL = 8
+VERTICAL_RATIO = 0.05
+
+
+def _is_cjk(ch: str) -> bool:
+    o = ord(ch)
+    for lo, hi in CJK_RANGES:
+        if lo <= o <= hi:
+            return True
+    return False
+
+
+def _is_latin(ch: str) -> bool:
+    o = ord(ch)
+    return (0x41 <= o <= 0x5A) or (0x61 <= o <= 0x7A) or (0xC0 <= o <= 0x24F)
+
+
+def _font_is_cjk(name: str) -> bool:
+    n = (name or "").lower()
+    return any(h in n for h in CJK_FONT_HINTS)
+
+
+def scan(pdf_path: str, max_pages: int | None = None) -> dict:
+    """扫全文（或前 max_pages 页），返回 cjk 段的字段。"""
+    import pymupdf
+
+    doc = pymupdf.open(pdf_path)
+    try:
+        cjk_chars = latin_chars = 0
+        fonts: list[str] = []
+        seen_fonts: set[str] = set()
+        vertical_blocks = 0
+        total_blocks = 0
+        vertical_wmode_spans = 0
+        pages_scanned = 0
+
+        limit = doc.page_count if max_pages is None else min(max_pages, doc.page_count)
+
+        for pno in range(limit):
+            page = doc[pno]
+            pages_scanned += 1
+            data = page.get_text("dict")
+            for block in data.get("blocks", []):
+                if block.get("type") != 0:  # 0 = 文本块
+                    continue
+                lines = block.get("lines", [])
+                if not lines:
+                    continue
+                total_blocks += 1
+                text_chars = 0
+                for line in lines:
+                    for span in line.get("spans", []):
+                        txt = span.get("text", "")
+                        text_chars += len(txt)
+                        for ch in txt:
+                            if _is_cjk(ch):
+                                cjk_chars += 1
+                            elif _is_latin(ch):
+                                latin_chars += 1
+                        fname = span.get("font", "")
+                        if _font_is_cjk(fname) and fname not in seen_fonts:
+                            seen_fonts.add(fname)
+                            fonts.append(fname)
+                        # 竖排写的字：wmode == 1
+                        if span.get("wmode", 0) == 1:
+                            vertical_wmode_spans += 1
+                x0, y0, x1, y1 = block["bbox"]
+                w, h = x1 - x0, y1 - y0
+                # 疑似竖排：块窄高、且每行平均不到 3 个字、至少 3 行
+                if h > w and len(lines) >= 3 and (text_chars / len(lines)) < 3:
+                    vertical_blocks += 1
+
+        letters = cjk_chars + latin_chars
+        ratio = (cjk_chars / letters) if letters else 0.0
+        latin_ratio = (latin_chars / letters) if letters else 0.0
+        vertical_suspect = bool(
+            vertical_wmode_spans > 0
+            or (
+                vertical_blocks >= MIN_BLOCKS_FOR_VERTICAL
+                and total_blocks > 0
+                and vertical_blocks / total_blocks >= VERTICAL_RATIO
+            )
+        )
+
+        return {
+            "script_ratio": round(ratio, 4),
+            "mixed": bool(ratio >= 0.05 and latin_ratio >= 0.05),
+            "vertical_suspect": vertical_suspect,
+            "cjk_chars": cjk_chars,
+            "latin_chars": latin_chars,
+            "fonts": fonts[:20],
+            "vertical_blocks": vertical_blocks,
+            "total_blocks": total_blocks,
+            "pages_scanned": pages_scanned,
+        }
+    finally:
+        doc.close()

tablecheck/cli.py

@@ -0,0 +1,252 @@
+"""命令行入口：``tablecheck <pdf...> [--json out.json] [--md out.md] [--strict]``。
+
+退出码：
+  0  跑完，没问题（或在非 strict 模式下发现问题）
+  1  跑不起来（文件不存在 / 打不开 / schema 自检失败）
+  2  --strict 下发现结构问题（用来当 CI 门禁）
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+from . import __version__
+from .cjk import scan as cjk_scan
+from .detect import detect_pages, shape_of
+from .schema import BAD_STATUSES, SCHEMA_VERSION, validate
+from .struct import header_quality, read_structure
+
+TOOL_NAME = "tablecheck"
+
+
+def sha256_of(path: str) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _status(detected: int, tagged: int, th: int) -> str:
+    """沿用 table_audit.py 的枚举与判定顺序，不改名、不重排。"""
+    if detected and tagged == 0:
+        return "NOT TAGGED"
+    if detected and th == 0:
+        return "NO HEADER"
+    if detected and th < tagged:
+        return "PARTIAL HEADER"
+    if detected:
+        return "OK"
+    return "TAGGED-ONLY"
+
+
+def audit_file(path: str) -> dict:
+    """跑单个文件，返回 schema v1 的 file 段（不含 schema_version/tool）。"""
+    p = Path(path)
+    if not p.is_file():
+        raise FileNotFoundError(path)
+
+    detected, page_count = detect_pages(path)
+    struct = read_structure(path)
+
+    tables_by_page: dict[int, list[dict]] = {}
+    orphan_tables = 0
+    for t in struct["tables"]:
+        if t["page"] is None:
+            orphan_tables += 1
+            continue
+        tables_by_page.setdefault(t["page"], []).append(t)
+
+    rows = []
+    pages = sorted(set(detected) | set(struct["per_page"]))
+    for pno in pages:
+        det = detected.get(pno, [])
+        mk = struct["per_page"].get(pno, {"tables": 0, "th": 0, "td": 0, "tr": 0})
+        n_det = len(det)
+        hq = header_quality(tables_by_page.get(pno, []))
+        rows.append(
+            {
+                "page": pno,
+                "detected": n_det,
+                "shape": shape_of(det),
+                "tagged_tables": mk["tables"],
+                "th": mk["th"],
+                "td": mk["td"],
+                "header_quality": hq,
+                "status": _status(n_det, mk["tables"], mk["th"]),
+            }
+        )
+
+    totals = struct["totals"]
+    summary = {
+        "pages": page_count,
+        "pages_with_tables": len(rows),
+        "tables_detected": sum(r["detected"] for r in rows),
+        "tables_tagged": totals["Table"],
+        "tr_total": totals["TR"],
+        "th_total": totals["TH"],
+        "td_total": totals["TD"],
+        "pages_not_tagged": sum(1 for r in rows if r["status"] == "NOT TAGGED"),
+        "pages_no_header": sum(1 for r in rows if r["status"] == "NO HEADER"),
+        "pages_partial_header": sum(1 for r in rows if r["status"] == "PARTIAL HEADER"),
+        "pages_ok": sum(1 for r in rows if r["status"] == "OK"),
+        "pages_tagged_only": sum(1 for r in rows if r["status"] == "TAGGED-ONLY"),
+        "pages_with_structparents": struct["pages_with_structparents"],
+        "has_struct_tree": struct["has_struct_tree"],
+        "tables_without_page": orphan_tables,
+        "th_missing_scope": sum(r["header_quality"]["th_missing_scope"] for r in rows),
+        "col_count_mismatch": sum(r["header_quality"]["col_count_mismatch"] for r in rows),
+        "empty_header_cells": sum(r["header_quality"]["empty_header_cells"] for r in rows),
+    }
+
+    return {
+        "file": {"name": p.name, "pages": page_count, "sha256": sha256_of(path)},
+        "cjk": cjk_scan(path),
+        "summary": summary,
+        "pages": rows,
+    }
+
+
+def _envelope(results: list[dict]) -> dict:
+    head = {"schema_version": SCHEMA_VERSION, "tool": {"name": TOOL_NAME, "version": __version__}}
+    if len(results) == 1:
+        head.update(results[0])
+        return head
+    head["files"] = results
+    return head
+
+
+def has_problems(doc: dict) -> bool:
+    """strict 模式的判据：结构状态不合格，或表头质量有硬伤。
+
+    注意 ``col_count_mismatch`` **不参与**门禁：合并单元格（ColSpan/RowSpan）会让它必然非零，
+    拿它当门禁会在真实文档上大面积误报。它在 JSON 里作为信息项保留，交给用户自己看。
+    """
+    files = doc["files"] if "files" in doc else [doc]
+    for f in files:
+        for r in f["pages"]:
+            if r["status"] in BAD_STATUSES:
+                return True
+            hq = r["header_quality"]
+            if hq["th_missing_scope"] or hq["empty_header_cells"]:
+                return True
+        s = f["summary"]
+        if s["tables_detected"] and s["tables_tagged"] == 0:
+            return True
+    return False
+
+
+def to_md(doc: dict) -> str:
+    files = doc["files"] if "files" in doc else [doc]
+    out = []
+    for f in files:
+        s = f["summary"]
+        out.append(f"## {f['file']['name']}（{f['file']['pages']} 页）\n\n")
+        out.append(
+            f"- sha256 `{f['file']['sha256']}`\n"
+            f"- 检出表格 **{s['tables_detected']}** 张 · 结构树 Table **{s['tables_tagged']}** 个 · "
+            f"TR {s['tr_total']} · TH {s['th_total']} · TD {s['td_total']}\n"
+            f"- 页面判定：未打标 {s['pages_not_tagged']} · 无表头 {s['pages_no_header']} · "
+            f"表头不全 {s['pages_partial_header']} · 正常 {s['pages_ok']} · "
+            f"仅标注 {s['pages_tagged_only']}\n"
+            f"- 表头质量：缺 Scope 的 TH {s['th_missing_scope']} 个 · 列数不一致 {s['col_count_mismatch']} 表 · "
+            f"空表头单元格 {s['empty_header_cells']} 个\n"
+            f"- CJK：script_ratio {f['cjk']['script_ratio']} · mixed {f['cjk']['mixed']} · "
+            f"vertical_suspect {f['cjk']['vertical_suspect']}\n\n"
+        )
+        bad = [r for r in f["pages"] if r["status"] in BAD_STATUSES]
+        if bad:
+            out.append("| 页 / page | 检出 det | 形状 shape | 已标 Table | TH | TD | 判定 status |\n")
+            out.append("|---|---|---|---|---|---|---|\n")
+            for r in bad:
+                out.append(
+                    f"| {r['page']} | {r['detected']} | {r['shape']} | "
+                    f"{r['tagged_tables']} | {r['th']} | {r['td']} | {r['status']} |\n"
+                )
+            out.append("\n")
+    return "".join(out)
+
+
+def _text_summary(doc: dict) -> str:
+    files = doc["files"] if "files" in doc else [doc]
+    lines = []
+    for f in files:
+        s = f["summary"]
+        lines.append(
+            f"{f['file']['name']}: {f['file']['pages']}p  "
+            f"detected={s['tables_detected']}  tagged={s['tables_tagged']}  "
+            f"TH={s['th_total']}  TD={s['td_total']}  "
+            f"NOT TAGGED={s['pages_not_tagged']}  NO HEADER={s['pages_no_header']}  "
+            f"PARTIAL={s['pages_partial_header']}  OK={s['pages_ok']}  "
+            f"TAGGED-ONLY={s['pages_tagged_only']}"
+        )
+        c = f["cjk"]
+        lines.append(
+            f"  cjk: script_ratio={c['script_ratio']} mixed={c['mixed']} "
+            f"vertical_suspect={c['vertical_suspect']}"
+        )
+    return "\n".join(lines) + "\n"
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(
+        prog=TOOL_NAME,
+        description="检查 PDF 里几何存在的表格与结构树标注的差距（中文/繁体友好，离线确定性）。",
+    )
+    ap.add_argument("pdf", nargs="+", help="待检查的 PDF（可多个）")
+    ap.add_argument("--json", metavar="OUT", help="把结果写成 JSON（schema v1）")
+    ap.add_argument("--md", metavar="OUT", help="把结果写成 Markdown 报告")
+    ap.add_argument(
+        "--strict",
+        action="store_true",
+        help="发现结构问题（未打标/缺表头/缺 Scope/列数不一致/空表头）时返回退出码 2",
+    )
+    ap.add_argument("--quiet", action="store_true", help="不在 stdout 打印摘要")
+    ap.add_argument("--version", action="version", version=f"{TOOL_NAME} {__version__}")
+    a = ap.parse_args(argv)
+
+    results = []
+    try:
+        for pdf in a.pdf:
+            results.append(audit_file(pdf))
+    except FileNotFoundError as e:
+        print(f"tablecheck: 文件不存在: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:  # 打不开/损坏的 PDF
+        print(f"tablecheck: 读取失败: {type(e).__name__}: {e}", file=sys.stderr)
+        return 1
+
+    doc = _envelope(results)
+
+    errors = validate(doc)
+    if errors:
+        print("tablecheck: 输出不符合 schema v1（内部错误）：", file=sys.stderr)
+        for e in errors[:20]:
+            print(f"  - {e}", file=sys.stderr)
+        return 1
+
+    if not a.quiet:
+        sys.stdout.write(_text_summary(doc))
+
+    if a.json:
+        Path(a.json).parent.mkdir(parents=True, exist_ok=True)
+        Path(a.json).write_text(json.dumps(doc, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        if not a.quiet:
+            print(f"JSON -> {a.json}")
+    if a.md:
+        Path(a.md).parent.mkdir(parents=True, exist_ok=True)
+        Path(a.md).write_text(to_md(doc), encoding="utf-8")
+        if not a.quiet:
+            print(f"MD   -> {a.md}")
+
+    if a.strict and has_problems(doc):
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tablecheck/detect.py

@@ -0,0 +1,81 @@
+"""几何表格检测（纯 PyMuPDF，不依赖结构树）。
+
+检测逻辑沿用既有基线工具的做法，保持数字可比：
+
+1. ``page.find_tables()`` 拿几何表；
+2. ``clean_cols`` 去掉只含货币符号/空白/破折号一类的假列；
+3. 过滤假表：有效列 < 2、行数 < 3 一律不算表。
+
+这两条过滤规则是历史基线的来源，改动会让 374 / 11 这些数字漂移，所以保持原样。
+"""
+
+from __future__ import annotations
+
+FAKE_CELL_VALUES = ("$", "€", "£", "%", "-", "—")
+
+MIN_COLS = 2
+MIN_ROWS = 3
+
+
+def clean_cols(table) -> int:
+    """返回去掉假列后的有效列数。
+
+    ``table`` 是 pymupdf 的 Table 对象；用 ``extract()`` 的文本矩阵判断，
+    某列只要有一个非空、且不属于货币符号/破折号的单元格就算有效列。
+    """
+    data = table.extract()
+    if not data:
+        return 0
+    ncols = max(len(row) for row in data)
+    keep = 0
+    for c in range(ncols):
+        vals = []
+        for row in data:
+            if c < len(row) and row[c]:
+                vals.append(str(row[c]).strip())
+        meaningful = [v for v in vals if v and v not in FAKE_CELL_VALUES]
+        if meaningful:
+            keep += 1
+    return keep
+
+
+def detect_pages(pdf_path: str) -> tuple[dict[int, list[dict]], int]:
+    """逐页检测几何表格。
+
+    返回 ``({页码1-based: [table_dict, ...]}, 总页数)``。
+    table_dict: ``{"rows", "cols_raw", "cols", "bbox"}``。
+    """
+    import pymupdf
+
+    doc = pymupdf.open(pdf_path)
+    try:
+        found: dict[int, list[dict]] = {}
+        for pno, page in enumerate(doc, 1):
+            try:
+                tabs = page.find_tables()
+            except Exception:
+                # 单页解析失败不影响整份文件，跳过该页（与历史实现一致）
+                continue
+            items = []
+            for t in tabs.tables:
+                cols = clean_cols(t) or t.col_count
+                if cols < MIN_COLS or t.row_count < MIN_ROWS:
+                    continue
+                items.append(
+                    {
+                        "rows": t.row_count,
+                        "cols_raw": t.col_count,
+                        "cols": cols,
+                        "bbox": [round(float(v), 1) for v in t.bbox],
+                    }
+                )
+            if items:
+                found[pno] = items
+        return found, doc.page_count
+    finally:
+        doc.close()
+
+
+def shape_of(items: list[dict]) -> str:
+    """把一页里的表形状压成 ``3r x 4c; 2r x 2c`` 这种字符串。"""
+    return "; ".join(f"{d['rows']}r x {d['cols']}c" for d in items) if items else ""

tablecheck/schema.py

@@ -0,0 +1,131 @@
+"""输出 JSON 的 schema 版本与校验。
+
+字段名是合同：外部脚本会按这里的名字取值，改名字 = 破坏性变更 = 升大版本。
+
+v1.0.0 单文件形态::
+
+    {
+      "schema_version": "1.0.0",
+      "tool": {"name": "tablecheck", "version": "0.1.0"},
+      "file": {"name": "...", "pages": 20, "sha256": "..."},
+      "cjk":  {"script_ratio": 0.0, "mixed": false, "vertical_suspect": false, ...},
+      "summary": {...},
+      "pages": [
+        {"page": 1, "detected": 2, "shape": "3r x 4c", "tagged_tables": 2,
+         "th": 4, "td": 12, "header_quality": {...}, "status": "OK"}
+      ]
+    }
+
+多文件形态只是把上面的 ``file``/``cjk``/``summary``/``pages`` 四项装进 ``files[]``::
+
+    {"schema_version": "1.0.0", "tool": {...}, "files": [ {...}, {...} ]}
+"""
+
+from __future__ import annotations
+
+SCHEMA_VERSION = "1.0.0"
+
+STATUSES = ("NOT TAGGED", "NO HEADER", "PARTIAL HEADER", "OK", "TAGGED-ONLY")
+BAD_STATUSES = ("NOT TAGGED", "NO HEADER", "PARTIAL HEADER")
+
+FILE_KEYS = ("file", "cjk", "summary", "pages")
+CJK_KEYS = ("script_ratio", "mixed", "vertical_suspect")
+PAGE_KEYS = ("page", "detected", "shape", "tagged_tables", "th", "td",
+             "header_quality", "status")
+HQ_KEYS = ("tables", "th_in_first_row", "th_in_first_col", "th_total",
+           "th_missing_scope", "col_count_mismatch", "empty_header_cells")
+
+
+def _type_errors(obj, key, types, where, errors):
+    if key not in obj:
+        errors.append(f"{where}: 缺字段 {key}")
+        return
+    if not isinstance(obj[key], types):
+        errors.append(f"{where}.{key}: 类型应为 {types}, 实际 {type(obj[key]).__name__}")
+    elif isinstance(obj[key], bool) and bool not in (types,):
+        errors.append(f"{where}.{key}: 不该是 bool")
+
+
+def validate(doc: dict) -> list[str]:
+    """校验输出的 JSON 结构，返回错误列表（空列表 = 合规）。"""
+    errors: list[str] = []
+    if not isinstance(doc, dict):
+        return ["顶层必须是对象"]
+
+    if doc.get("schema_version") != SCHEMA_VERSION:
+        errors.append(f"schema_version 应为 {SCHEMA_VERSION}，实际 {doc.get('schema_version')!r}")
+
+    tool = doc.get("tool")
+    if not isinstance(tool, dict):
+        errors.append("缺 tool 对象")
+    else:
+        for k in ("name", "version"):
+            _type_errors(tool, k, (str,), "tool", errors)
+
+    if "files" in doc:
+        files = doc["files"]
+        if not isinstance(files, list) or not files:
+            errors.append("files 必须是非空数组")
+            return errors
+        for i, f in enumerate(files):
+            errors.extend(_validate_file(f, f"files[{i}]"))
+        return errors
+
+    errors.extend(_validate_file(doc, ""))
+    return errors
+
+
+def _validate_file(doc: dict, where: str) -> list[str]:
+    errors: list[str] = []
+    prefix = f"{where}." if where else ""
+
+    f = doc.get("file")
+    if not isinstance(f, dict):
+        errors.append(f"{prefix}缺 file 对象")
+    else:
+        _type_errors(f, "name", (str,), prefix + "file", errors)
+        _type_errors(f, "pages", (int,), prefix + "file", errors)
+        _type_errors(f, "sha256", (str,), prefix + "file", errors)
+        if isinstance(f.get("sha256"), str) and len(f["sha256"]) != 64:
+            errors.append(f"{prefix}file.sha256 长度应为 64")
+
+    cjk = doc.get("cjk")
+    if not isinstance(cjk, dict):
+        errors.append(f"{prefix}缺 cjk 对象")
+    else:
+        for k in CJK_KEYS:
+            if k not in cjk:
+                errors.append(f"{prefix}cjk: 缺字段 {k}")
+        if isinstance(cjk.get("script_ratio"), (int, float)) and not isinstance(
+            cjk["script_ratio"], bool
+        ):
+            if not 0.0 <= float(cjk["script_ratio"]) <= 1.0:
+                errors.append(f"{prefix}cjk.script_ratio 应在 0..1 之间")
+        for k in ("mixed", "vertical_suspect"):
+            if k in cjk and not isinstance(cjk[k], bool):
+                errors.append(f"{prefix}cjk.{k} 应为布尔")
+
+    if not isinstance(doc.get("summary"), dict):
+        errors.append(f"{prefix}缺 summary 对象")
+
+    pages = doc.get("pages")
+    if not isinstance(pages, list):
+        errors.append(f"{prefix}pages 必须是数组")
+        return errors
+    for i, p in enumerate(pages):
+        w = f"{prefix}pages[{i}]"
+        if not isinstance(p, dict):
+            errors.append(f"{w} 必须是对象")
+            continue
+        for k in PAGE_KEYS:
+            if k not in p:
+                errors.append(f"{w}: 缺字段 {k}")
+        if p.get("status") not in STATUSES:
+            errors.append(f"{w}.status 非法值 {p.get('status')!r}")
+        if not isinstance(p.get("header_quality"), dict):
+            errors.append(f"{w}.header_quality 必须是对象")
+        else:
+            for k in HQ_KEYS:
+                if k not in p["header_quality"]:
+                    errors.append(f"{w}.header_quality: 缺字段 {k}")
+    return errors

tablecheck/struct.py

@@ -0,0 +1,277 @@
+"""结构树读取：/Table /TR /TH /TD、/Scope、/StructParents。
+
+用 pikepdf 走 /StructTreeRoot，产出一棵「表 → 行 → 单元格」的朴素树，
+供上层做表头质量判定。只读，绝不改文件。
+
+页归属规则（依次回退）：
+1. 元素自带的 ``/Pg``；
+2. 最近的祖先元素的 ``/Pg``（很多生成器只在 /Table 上写 /Pg）；
+3. 都没有 → ``None``（记进 ``table["page"] = None``，只进全局总数，不算到任何页）。
+"""
+
+from __future__ import annotations
+
+TABLE_TAGS = ("/Table", "/TR", "/TH", "/TD")
+CONTENT_TAGS = ("/TH", "/TD")
+
+
+def _as_int(obj):
+    """pikepdf 的整数 Object 转 python int；不是整数返回 None。"""
+    if obj is None:
+        return None
+    try:
+        return int(obj)
+    except (TypeError, ValueError):
+        return None
+
+
+def _kids(node):
+    """把 /K 归一化成 list（可能是单 dict / 单 ref / 整数 MCID / Array）。"""
+    import pikepdf
+
+    if not isinstance(node, pikepdf.Dictionary):
+        return []
+    kids = node.get("/K")
+    if kids is None:
+        return []
+    if isinstance(kids, pikepdf.Dictionary):
+        return [kids]
+    if isinstance(kids, pikepdf.Array):
+        return list(kids)
+    return []
+
+
+def _scope_of(elem):
+    """读 /Scope：既认元素上的直写，也认 /A 属性字典（Word/InDesign 走的是 /A）。"""
+    import pikepdf
+
+    direct = elem.get("/Scope")
+    if direct is not None:
+        return str(direct).lstrip("/").lower()
+    # pikepdf 的 Array/Dictionary 都是 Object；/A 还可能是单个字典而非数组
+    attrs = elem.get("/A")
+    if isinstance(attrs, pikepdf.Array):
+        candidates = list(attrs)
+    elif attrs is not None:
+        candidates = [attrs]
+    else:
+        candidates = []
+    for a in candidates:
+        if not isinstance(a, pikepdf.Dictionary):
+            continue
+        s = a.get("/Scope")
+        if s is not None:
+            return str(s).lstrip("/").lower()
+    return None
+
+
+def _span_of(elem) -> int:
+    """读 /ColSpan（直写或 /A 里的），缺省 1。合并单元格靠它算实际列数。"""
+    import pikepdf
+
+    def pick(obj):
+        if obj is None:
+            return None
+        v = obj.get("/ColSpan") if isinstance(obj, pikepdf.Dictionary) else None
+        return _as_int(v)
+
+    span = pick(elem)
+    if span is None:
+        attrs = elem.get("/A")
+        if isinstance(attrs, pikepdf.Array):
+            for a in attrs:
+                span = pick(a)
+                if span:
+                    break
+        else:
+            span = pick(attrs)
+    return span if span and span > 0 else 1
+
+
+def _content_refs(elem, depth=0) -> int:
+    """单元格里有多少个内容引用（MCID 整数 / OBJR 对象引用）。
+
+    MCID 常常不是直接挂在 TH/TD 上，而是挂在一层嵌套的 /P 之类 StructElem 里，
+    所以这里要往下钻几层，否则所有单元格都会被误判成「空表头」。
+    """
+    if depth > 6:
+        return 0
+    n = 0
+    for k in _kids(elem):
+        if _as_int(k) is not None:
+            n += 1
+            continue
+        try:
+            if str(k.get("/Type", "")) == "/OBJR":
+                n += 1
+                continue
+        except AttributeError:
+            continue
+        n += _content_refs(k, depth + 1)
+    return n
+
+
+def read_structure(pdf_path: str) -> dict:
+    """返回 ``{"has_struct_tree", "totals", "per_page", "tables", "pages_with_structparents"}``。"""
+    import pikepdf
+
+    result = {
+        "has_struct_tree": False,
+        "totals": {"Table": 0, "TR": 0, "TH": 0, "TD": 0},
+        "per_page": {},
+        "tables": [],
+        "pages_with_structparents": 0,
+    }
+
+    pdf = pikepdf.open(pdf_path)
+    try:
+        # /StructParents 只做统计：有多少页挂了 /StructParents（结构树的锚点页）
+        for pg in pdf.pages:
+            if pg.obj.get("/StructParents") is not None:
+                result["pages_with_structparents"] += 1
+
+        root = pdf.Root.get("/StructTreeRoot")
+        if root is None:
+            return result
+        result["has_struct_tree"] = True
+
+        page_index = {pg.obj.objgen: i for i, pg in enumerate(pdf.pages, 1)}
+
+        def page_of(obj, inherited):
+            ref = obj.get("/Pg") if isinstance(obj, pikepdf.Dictionary) else None
+            if ref is None:
+                return inherited
+            try:
+                return page_index.get(ref.objgen, inherited)
+            except AttributeError:
+                return inherited
+
+        seen = set()
+
+        def walk(node, inherited_page, depth=0):
+            if depth > 120:
+                return
+            for k in _kids(node):
+                if not isinstance(k, pikepdf.Dictionary):
+                    continue
+                try:
+                    ident = k.objgen
+                except AttributeError:
+                    ident = None
+                # 结构树里出现环是真实存在的毛病，按对象号去重兜住
+                if ident is not None:
+                    if ident in seen:
+                        continue
+                    seen.add(ident)
+
+                s = str(k.get("/S", ""))
+                pno = page_of(k, inherited_page)
+                if s in TABLE_TAGS:
+                    result["totals"][s.lstrip("/")] += 1
+                    if pno is not None:
+                        d = result["per_page"].setdefault(
+                            pno, {"tables": 0, "th": 0, "td": 0, "tr": 0}
+                        )
+                        if s == "/Table":
+                            d["tables"] += 1
+                        elif s == "/TH":
+                            d["th"] += 1
+                        elif s == "/TD":
+                            d["td"] += 1
+                        elif s == "/TR":
+                            d["tr"] += 1
+
+                if s == "/Table":
+                    result["tables"].append(_read_table(k, pno))
+
+                # 继续下钻：TH/TD/TR 的计数要靠这一趟走完（seen 已按对象号去重，不会重复计）
+                walk(k, pno, depth + 1)
+
+        walk(root, None)
+        return result
+    finally:
+        pdf.close()
+
+
+def _read_table(table_elem, page_no):
+    """把一棵 /Table 子树读成 ``{page, n_rows, rows:[[cell,...]], th, td}``。"""
+    import pikepdf
+
+    rows = []
+    th = td = 0
+    # /Table 的直接子元素应该是 /TR；有的生成器会插一层 /THead /TBody
+    trs = []
+
+    def collect_tr(node, depth=0):
+        if depth > 12:
+            return
+        for k in _kids(node):
+            if not isinstance(k, pikepdf.Dictionary):
+                continue
+            s = str(k.get("/S", ""))
+            if s == "/TR":
+                trs.append(k)
+            elif s in ("/THead", "/TBody", "/TFoot"):
+                collect_tr(k, depth + 1)
+
+    collect_tr(table_elem)
+
+    for tr in trs:
+        row = []
+        for k in _kids(tr):
+            if not isinstance(k, pikepdf.Dictionary):
+                continue
+            s = str(k.get("/S", ""))
+            if s not in CONTENT_TAGS:
+                continue
+            is_th = s == "/TH"
+            if is_th:
+                th += 1
+            else:
+                td += 1
+            row.append(
+                {
+                    "type": "TH" if is_th else "TD",
+                    "scope": _scope_of(k) if is_th else None,
+                    "colspan": _span_of(k),
+                    "empty": _content_refs(k) == 0,
+                }
+            )
+        if row:
+            rows.append(row)
+
+    return {"page": page_no, "n_rows": len(rows), "rows": rows, "th": th, "td": td}
+
+
+def header_quality(tables: list[dict]) -> dict:
+    """对一组已标注的表给表头质量指标（聚合计数，不是布尔）。"""
+    q = {
+        "tables": 0,
+        "th_in_first_row": 0,
+        "th_in_first_col": 0,
+        "th_total": 0,
+        "th_missing_scope": 0,
+        "col_count_mismatch": 0,
+        "empty_header_cells": 0,
+    }
+    for t in tables:
+        rows = t["rows"]
+        if not rows:
+            continue
+        q["tables"] += 1
+        q["th_total"] += t["th"]
+        if any(c["type"] == "TH" for c in rows[0]):
+            q["th_in_first_row"] += 1
+        if any(r and r[0]["type"] == "TH" for r in rows):
+            q["th_in_first_col"] += 1
+        for r in rows:
+            for c in r:
+                if c["type"] == "TH":
+                    if c["scope"] is None:
+                        q["th_missing_scope"] += 1
+                    if c["empty"]:
+                        q["empty_header_cells"] += 1
+        width = sum(c.get("colspan", 1) for c in rows[0])
+        if any(sum(c.get("colspan", 1) for c in r) != width for r in rows):
+            q["col_count_mismatch"] += 1
+    return q

tablecheck-0.1.0.dist-info/METADATA

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: tablecheck
+Version: 0.1.0
+Summary: Check PDF table structure: geometry-detected tables vs tagged /Table /TH /TD, CJK-aware (中文/繁體).
+Author: tablecheck contributors
+License: MIT
+Project-URL: Homepage, https://github.com/xeology13/tablecheck
+Keywords: pdf,pdfua,accessibility,table,cjk,chinese
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Text Processing
+Requires-Python: <3.15,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pymupdf>=2.0
+Requires-Dist: pikepdf>=8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# tablecheck
+
+PDF 表格结构检查器 / PDF table-structure checker — 专治中文、繁体 PDF 里「看得见表格、结构树里没有」的问题。
+
+离线、确定性、无模型、无网络。同输入同输出，`sha256` 写在结果里，方便多方对账。
+
+An offline, deterministic CLI that compares **geometrically detected tables** against the
+**tagged structure tree** (`/Table` `/TR` `/TH` `/TD`, `/Scope`), with CJK-specific signals
+for Chinese/Traditional-Chinese/Japanese/Korean documents.
+
+---
+
+## 它查什么 / What it checks
+
+1. **几何表格 vs 结构标注** — 每页给出「检出几张表、结构树里标了几个 `/Table`」，再判状态：
+   `NOT TAGGED`（有表没标）、`NO HEADER`（标了但一个 `/TH` 都没有）、
+   `PARTIAL HEADER`（TH 少于表数）、`OK`、`TAGGED-ONLY`（结构树里有表，几何上没检出）。
+2. **表头质量** — 每张已标注的表：TH 是否出现在首行/首列、缺 `/Scope` 的 TH 有多少、
+   同一张表里各 `TR` 的单元格数与表头行是否一致、空表头单元格（无任何内容引用的 TH）有几个。
+3. **CJK 识别** — 中日韩字符占比 `script_ratio`、是否中英混排 `mixed`、
+   是否疑似竖排 `vertical_suspect`（直排文本会让几何检测失准，先给出信号）。
+4. **可复跑** — 每个结果带文件 `sha256` 与页数；同一文件重复跑，JSON 逐字节相同。
+
+## 它不查什么 / What it does NOT check
+
+- 不判 PDF/UA 或 WCAG 整体合规（只判表格这一段；元数据、语言、替代文本不在此列）。
+- 不判阅读顺序、不做 OCR：扫描件没有文字层时，几何检测只会看到图片。
+- 不修改文件，一个字节都不写进输入 PDF（只读）。
+- 不联网、不调用任何模型、不下载任何东西。
+- 合并单元格（rowspan/colspan）会被如实记成「列数不一致」，这是**报告**不是**修复**。
+- 竖排文本只给「疑似」信号，不做竖排表格的几何修正。
+
+---
+
+## 安装 / Install
+
+要求 Python **3.11 – 3.14**。下界是 pymupdf/pikepdf 2.x 世代 wheel 的共同起点；
+上界卡在 3.14 是因为传递依赖 onnxruntime 尚未发布 cp315 wheel（实测 3.15 下
+`pip install` 直接 ResolutionImpossible，与 tablecheck 无关）。
+
+```bash
+python3.14 -m venv .venv
+.venv/bin/pip install .        # 发布后可改为: pip install tablecheck
+.venv/bin/tablecheck --version
+```
+
+English: requires Python 3.11–3.14. Direct dependencies are just `pymupdf>=2.0` and
+`pikepdf>=8.0`; pymupdf 2.x pulls onnxruntime/numpy etc. transitively (~200 MB installed) —
+that is the price of the v1 detection baseline. pymupdf 1.28 installs much smaller but
+its `find_tables()` drifts (measured 380 vs 374 on a 264-page sample), so it is not
+recommended. No extras to choose from: the layout engine ships inside pymupdf 2.x.
+Dev install: `pip install -e ".[dev]"` (pytest).
+
+## 用法 / Usage
+
+```bash
+# 人看的摘要
+tablecheck 文件.pdf
+
+# 机器读的 JSON（schema v1.0.0）
+tablecheck 文件.pdf --json out.json
+
+# Markdown 报告（只列问题页）
+tablecheck 文件.pdf --md out.md
+
+# 当 CI 门禁：发现问题就返回退出码 2
+tablecheck 文件.pdf --strict
+
+# 多份文件一起跑（JSON 变成 {"schema_version","tool","files":[...]}）
+tablecheck a.pdf b.pdf --json batch.json
+```
+
+退出码 / exit codes：
+
+| code | 含义 |
+|---|---|
+| 0 | 跑完，未发现问题（或未加 `--strict`，发现问题也返回 0） |
+| 1 | 跑不起来：文件不存在、PDF 打不开、内部 schema 自检失败 |
+| 2 | `--strict` 模式下发现结构问题 |
+
+`--strict` 判定为问题的条件：任一页 `status ∈ {NOT TAGGED, NO HEADER, PARTIAL HEADER}`，
+或任一页存在缺 `/Scope` 的 TH、空表头单元格，或「有检出表但全篇零标注」。
+
+`col_count_mismatch`（列数不一致）**不进** strict 门禁：合并单元格会让它必然非零，
+拿它当 CI 门禁在真实文档上一定误报；它只在 JSON 里作为信息项给出。
+
+---
+
+## 输出 JSON（schema v1.0.0，字段名固定）
+
+单文件：
+
+```json
+{
+  "schema_version": "1.0.0",
+  "tool": {"name": "tablecheck", "version": "0.1.0"},
+  "file": {"name": "样本.pdf", "pages": 20, "sha256": "…64 hex…"},
+  "cjk": {
+    "script_ratio": 0.9929,
+    "mixed": false,
+    "vertical_suspect": false,
+    "cjk_chars": 9392, "latin_chars": 67,
+    "fonts": ["SimSun", "SimHei"], "vertical_blocks": 0,
+    "total_blocks": 641, "pages_scanned": 20
+  },
+  "summary": {
+    "pages": 20, "pages_with_tables": 8,
+    "tables_detected": 11, "tables_tagged": 13,
+    "tr_total": 51, "th_total": 36, "td_total": 134,
+    "pages_not_tagged": 0, "pages_no_header": 0, "pages_partial_header": 0,
+    "pages_ok": 8, "pages_tagged_only": 0,
+    "pages_with_structparents": 20, "has_struct_tree": true,
+    "tables_without_page": 0,
+    "th_missing_scope": 0, "col_count_mismatch": 2, "empty_header_cells": 0
+  },
+  "pages": [
+    {
+      "page": 13, "detected": 2, "shape": "4r x 4c; 4r x 4c",
+      "tagged_tables": 2, "th": 4, "td": 24,
+      "header_quality": {
+        "tables": 2, "th_in_first_row": 2, "th_in_first_col": 2,
+        "th_total": 4, "th_missing_scope": 0,
+        "col_count_mismatch": 0, "empty_header_cells": 0
+      },
+      "status": "OK"
+    }
+  ]
+}
+```
+
+多文件时，`file` / `cjk` / `summary` / `pages` 这四个键装进 `files[]`，其余不变：
+
+```json
+{"schema_version": "1.0.0", "tool": {...}, "files": [ {...}, {...} ]}
+```
+
+字段语义速查：
+
+| 字段 | 含义 |
+|---|---|
+| `file.sha256` | 输入文件的 sha256（小写 hex），与 `shasum -a 256` 一致 |
+| `cjk.script_ratio` | 中日韩字符 / (中日韩字符 + 拉丁字母)，0..1 |
+| `cjk.mixed` | `script_ratio >= 0.05` 且拉丁字母占比 `>= 0.05` |
+| `cjk.vertical_suspect` | 存在 wmode=1 的文字，或「窄高块 + 单字换行」块 ≥ 8 且占比 ≥ 5% |
+| `pages[].detected` | 几何检出的表数（有效列 ≥ 2 且行数 ≥ 3） |
+| `pages[].shape` | 每张表的 `行r x 列c`，多张用 `; ` 分隔 |
+| `pages[].tagged_tables` | 该页结构树里 `/Table` 的个数 |
+| `pages[].status` | `NOT TAGGED` / `NO HEADER` / `PARTIAL HEADER` / `OK` / `TAGGED-ONLY` |
+| `header_quality.th_missing_scope` | 既没有 `/Scope` 也没有 `/A /Scope` 的 TH 个数 |
+| `header_quality.col_count_mismatch` | 各 TR 单元格数与首行不一致的**表**数 |
+| `header_quality.empty_header_cells` | 没有任何内容引用（MCID/OBJR）的 TH 个数 |
+| `summary.tables_without_page` | 结构树里没有 `/Pg` 且祖先也没写的表（只进总数，不归任何页） |
+
+判定顺序（沿用既有实现，不重排）：
+`detected>0 且 tagged==0 → NOT TAGGED`；`detected>0 且 th==0 → NO HEADER`；
+`detected>0 且 th<tagged → PARTIAL HEADER`；`detected>0 → OK`；`否则 TAGGED-ONLY`。
+
+---
+
+## 实测基线 / Measured baseline
+
+三份真实样本（私有医疗/公文 PDF，**不进仓库**），pymupdf 2.x 下逐条对齐，2026-11-14 复测仍 0 差：
+
+| 指标 / metric | AR-1 (264p, 简中) | 回归-20页-FINAL-FINAL (20p, 中文打标产物) | reg-ar01-OUT (274p, 繁体未标) |
+|---|---|---|---|
+| 检出 / 已标 Table | 374 / 378 | 11 / 13 | 109 / 0 |
+| TR / TH / TD | 1510 / 866 / 4330 | 51 / 36 / 134 | 0 / 0 / 0 |
+| 缺 `/Scope` 的 TH | 0 | 0 | — |
+| 列数不一致的表 | 22 | 2 | — |
+| 空表头单元格 | 4 | 0 | — |
+| 页面判定 | 未标 3 · 正常 237 · 仅标注 7 | 正常 8 | 未标 99 |
+| `cjk.script_ratio` | 0.9926 | 0.9929 | 0.2352 |
+| `cjk.mixed` / `vertical_suspect` | false / false | false / false | **true** / false |
+
+读法：两份中文样本 `/Scope` 全齐说明生成路径规范；AR-1 的 22 张「列数不一致」几乎全是
+合并单元格；繁体样本 `mixed=true` 是拉丁字符占 76% 的真实混排，274 页里 99 页检出表但零标注，
+是「全篇表格没标」的典型形态。
+
+## 检测口径 / Detection rules
+
+几何检测（`detect.py`）：
+
+- 用 PyMuPDF `page.find_tables()`（基于页面上的格线）；
+- 去掉「只含 `$ € £ % - —` 或空白」的假列后，有效列 < 2 或行数 < 3 的表不算表；
+- 单页解析失败跳过该页，不影响整份文件。
+
+这两条过滤是历史基线的来源（264 页样本检出 374 张表），改口径会让数字漂移，
+所以对外承诺：**v1 期间口径不变**。
+
+结构树（`struct.py`）：`/StructTreeRoot` 深度优先，`/Pg` 逐级继承；
+遇到对象号重复（结构树有环）直接跳过，不死循环。
+
+## 复跑与对账 / Reproduce
+
+```bash
+shasum -a 256 文件.pdf
+tablecheck 文件.pdf --json a.json
+tablecheck 文件.pdf --json b.json
+diff a.json b.json          # 应该完全相同
+```
+
+`tests/test_gold.py` 固化了四个基线用例（上表样本）。样本目录用环境变量
+`TABLE_CHECK_SAMPLES` 指定（默认 `~/HermesWorkspace/tablecheck/samples`）；
+样本是私有 PDF，不在仓库里，没有样本时这些用例自动 skip。
+`pytest tests/test_smoke.py` 用现造 PDF 冒烟，无外部依赖。
+
+---
+
+## 已知短板 / Known limits
+
+- 无框线（只靠留白）的表格 `find_tables()` 抓不到，会低估 `detected`。
+- 扫描件、图片型表格不检测（无文字层）。
+- 合并单元格一定会在 `col_count_mismatch` 里出现，属于预期噪音。
+- 只判「结构树里有没有表、表头长什么样」，不判单元格内容对不对。
+- 严格来说这是**体检工具**，不是修复工具：它告诉你差在哪一页哪一张表。
+
+## License
+
+MIT，见 `LICENSE`。

tablecheck-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+tablecheck/__init__.py,sha256=UIKVEHrrxOEhPbZruSawwg8QrOD4UFwOBbBcui92J7Y,245
+tablecheck/cjk.py,sha256=rcmwZgDoVampUcoTfKs3e2V67Ja2A2A9hHZb65GO5xw,4676
+tablecheck/cli.py,sha256=yxWaIj3tRSBAFPcN9tBWFaDvXwY783zDB9WZ_29a_Ho,9493
+tablecheck/detect.py,sha256=w8xyCu3nqistE1E11wnP7R1LaON3nDwAbxTDxrfVOKE,2674
+tablecheck/schema.py,sha256=2gPt5UZicJ-VkSrr1grhVAXaqE8A-_2ySF6jBpuHo3c,4936
+tablecheck/struct.py,sha256=m6K4Ht-kEdS3Xdmlwaf_Ar6SGxa1b6rcgWCsMyHaoRU,8810
+tablecheck-0.1.0.dist-info/licenses/LICENSE,sha256=2_dBN6YgLicWy13Tob7uuKB-n8nd1yQz7tmuut28lZM,1080
+tablecheck-0.1.0.dist-info/METADATA,sha256=LFnIz3oNhicgRZNG2XzXGzjLFvyG8tdm0nuOL3V5C7Q,10333
+tablecheck-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+tablecheck-0.1.0.dist-info/entry_points.txt,sha256=42Tf7-mmXkXzB_ngOLpQKPKFhkA1mJUjmAm-l_8qXc8,51
+tablecheck-0.1.0.dist-info/top_level.txt,sha256=Ixo-C8B9nv6BD_2YC7I7_EV7Nkx-6Wat1sZprsKZ2b8,11
+tablecheck-0.1.0.dist-info/RECORD,,

tablecheck-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tablecheck-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tablecheck = tablecheck.cli:main

tablecheck-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tablecheck contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tablecheck-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tablecheck