classics-index 0.1.0__tar.gz

classics_index-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 socratic-tutor 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.

classics_index-0.1.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: classics-index
+Version: 0.1.0
+Summary: Chapter indexes (卷 / 篇 / 回) for scanned Chinese books, built from OCR of the running header
+Author: socratic-tutor contributors
+License: MIT
+Keywords: chinese-classics,scanned-books,ocr,table-of-contents,pymupdf
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: ocr
+Requires-Dist: paddleocr>=3; extra == "ocr"
+Requires-Dist: pillow; extra == "ocr"
+Requires-Dist: pymupdf; extra == "ocr"
+Dynamic: license-file
+
+# classics-index
+
+从**扫描本**的版心（页边书眉）OCR 里建章回索引：卷 → 篇 → 回。不依赖任何在线服务，纯 Python，无第三方运行时依赖（OCR 引擎是可选的）。
+
+```
+pip install -e .
+classics-index volumes --headers heads.jsonl --out toc.json
+classics-index pian    --toc toc.json --band titles.jsonl --out toc-pian.json
+classics-index hui     --ocr hui.jsonl --names "1=西游记,2=水浒传" --out hui.json
+classics-index find    --toc toc.json --q 卷3
+```
+
+## 它解决什么问题
+
+点校本、影印本没有文本层，目录页也常常 OCR 不可用。但**每一页的页眉都印着卷次**（"史記卷二"）或回目（"灵根育孕源流出心性修持大道生"）。于是：
+
+| 输入 | 输出 |
+|---|---|
+| 每页页眉带的 OCR（`{"page": n, "vol": 2}`） | 卷的起止页，连续覆盖全书 |
+| 每页右侧标题带的 OCR（`{"page": n, "lines": [...]}`） | 篇名页与篇页码范围 |
+| 章回小说每页页眉 OCR（`{"page": n, "texts": [...]}`） | 回目分段、附录标记、多部书切分 |
+
+## 设计上的三个关键判据
+
+1. **卷靠"连续 ≥5 页"**：目录页也会写出"史記卷十三"，那种孤页会被丢掉。
+2. **篇靠"行的形态"而不是字号**：实测卷眉（48 px 宽）比篇名（46 px）还宽，宽度阈值不可靠；可靠的是"短行 + 序号结尾干净"（目录行末尾是"："或省略号）。
+3. **回靠"页眉标题变化"**：章回小说每页页眉都印着当前回目，标题一变就是新回；附录（"附/录"）重复上一回页眉，不能占回号。
+
+## 数据从哪来
+
+配套的 OCR 脚本在本仓库的 `eval/p3/`（`vertical_header_ocr.py`、`vertical_title_ocr.py`、`novel_hui_ocr.py`），它们只是 PaddleOCR 的一层薄封装：
+
+- 版心带：页面右侧 18%、高度 8%–55%，1.2 s/页；
+- 标题带：右侧 42%、高度 3%–65%，3.5 s/页；
+- 章回页眉：全宽、高度 3%–15%，0.55 s/页。
+
+把任意 OCR 引擎的结果整理成本包要的 JSONL 也行。
+
+## 已在什么数据上验证
+
+| 书 | 规模 | 结果 |
+|---|---|---|
+| 《史记》点校本 一 | 358 页 | 7 卷 + 7 篇，覆盖 358/358 |
+| 《三国志》二 | 140 页 | 卷10–14 五篇篇名正确 |
+| 四大名著合订本 | 2745/5291 页 | 215 回目段 / 3 部（过切 +1%） |
+
+## 限制
+
+- 版心位置是按中华书局版式调的，换版式要调裁切参数；
+- 章回小说的"换书边界"会晚一回（下一部第一回的页眉常没有"第一回"）；
+- 只处理竖排/横排的中文印刷体，不做手写、不做多栏学术期刊。
+
+## 许可
+
+尚未选定（建议 MIT）；选好之前不要发布到任何包索引。

classics_index-0.1.0/README.md

@@ -0,0 +1,55 @@
+# classics-index
+
+从**扫描本**的版心（页边书眉）OCR 里建章回索引：卷 → 篇 → 回。不依赖任何在线服务，纯 Python，无第三方运行时依赖（OCR 引擎是可选的）。
+
+```
+pip install -e .
+classics-index volumes --headers heads.jsonl --out toc.json
+classics-index pian    --toc toc.json --band titles.jsonl --out toc-pian.json
+classics-index hui     --ocr hui.jsonl --names "1=西游记,2=水浒传" --out hui.json
+classics-index find    --toc toc.json --q 卷3
+```
+
+## 它解决什么问题
+
+点校本、影印本没有文本层，目录页也常常 OCR 不可用。但**每一页的页眉都印着卷次**（"史記卷二"）或回目（"灵根育孕源流出心性修持大道生"）。于是：
+
+| 输入 | 输出 |
+|---|---|
+| 每页页眉带的 OCR（`{"page": n, "vol": 2}`） | 卷的起止页，连续覆盖全书 |
+| 每页右侧标题带的 OCR（`{"page": n, "lines": [...]}`） | 篇名页与篇页码范围 |
+| 章回小说每页页眉 OCR（`{"page": n, "texts": [...]}`） | 回目分段、附录标记、多部书切分 |
+
+## 设计上的三个关键判据
+
+1. **卷靠"连续 ≥5 页"**：目录页也会写出"史記卷十三"，那种孤页会被丢掉。
+2. **篇靠"行的形态"而不是字号**：实测卷眉（48 px 宽）比篇名（46 px）还宽，宽度阈值不可靠；可靠的是"短行 + 序号结尾干净"（目录行末尾是"："或省略号）。
+3. **回靠"页眉标题变化"**：章回小说每页页眉都印着当前回目，标题一变就是新回；附录（"附/录"）重复上一回页眉，不能占回号。
+
+## 数据从哪来
+
+配套的 OCR 脚本在本仓库的 `eval/p3/`（`vertical_header_ocr.py`、`vertical_title_ocr.py`、`novel_hui_ocr.py`），它们只是 PaddleOCR 的一层薄封装：
+
+- 版心带：页面右侧 18%、高度 8%–55%，1.2 s/页；
+- 标题带：右侧 42%、高度 3%–65%，3.5 s/页；
+- 章回页眉：全宽、高度 3%–15%，0.55 s/页。
+
+把任意 OCR 引擎的结果整理成本包要的 JSONL 也行。
+
+## 已在什么数据上验证
+
+| 书 | 规模 | 结果 |
+|---|---|---|
+| 《史记》点校本 一 | 358 页 | 7 卷 + 7 篇，覆盖 358/358 |
+| 《三国志》二 | 140 页 | 卷10–14 五篇篇名正确 |
+| 四大名著合订本 | 2745/5291 页 | 215 回目段 / 3 部（过切 +1%） |
+
+## 限制
+
+- 版心位置是按中华书局版式调的，换版式要调裁切参数；
+- 章回小说的"换书边界"会晚一回（下一部第一回的页眉常没有"第一回"）；
+- 只处理竖排/横排的中文印刷体，不做手写、不做多栏学术期刊。
+
+## 许可
+
+尚未选定（建议 MIT）；选好之前不要发布到任何包索引。

classics_index-0.1.0/classics_index/__init__.py

@@ -0,0 +1,6 @@
+"""Chapter indexes (卷 / 篇 / 回) for scanned Chinese books, from OCR of the
+running header. Pure functions plus a small CLI; no storage, no OCR engine."""
+
+from . import core, hui  # noqa: F401
+
+__version__ = "0.1.0"

classics_index-0.1.0/classics_index/cli.py

@@ -0,0 +1,202 @@
+"""Command line for building 卷/篇/回 indexes from OCR dumps.
+
+  classics-index volumes --headers heads.jsonl --out toc.json
+  classics-index pian    --toc toc.json --band titles.jsonl --out toc-pian.json
+  classics-index hui     --ocr hui.jsonl --names "1=西游记,2=水浒传" --out hui.json
+  classics-index find    --toc toc.json --q 卷3
+  classics-index at      --toc toc.json --page 50
+"""
+import argparse
+import json
+import os
+import re
+import sys
+
+from . import core, hui
+
+PIAN = re.compile(r"(本紀|本纪|紀|纪|世家|列傳|列传|傳|传|書|书|表|志)\s*第\s*[〇零一二三四五六七八九十百]{1,4}")
+LEADER = re.compile(r"…|\.{2,}|·{2,}|(……)")
+
+
+def _read_jsonl(path):
+    out = []
+    with open(path, encoding="utf-8") as fh:
+        for line in fh:
+            line = line.strip()
+            if line:
+                out.append(json.loads(line))
+    return out
+
+
+def _width(line):
+    box = line.get("box") or [0, 0, 0, 0]
+    try:
+        return abs(int(box[2]) - int(box[0]))
+    except Exception:
+        return 0
+
+
+def _volumes_from_headers(records, min_run):
+    vols = {int(r["page"]): r.get("vol") for r in records if r.get("vol")}
+    return core.build_from_volumes(core.clean_volumes(vols, min_run=min_run))
+
+
+def _volumes_from_band(records, min_run):
+    vols = {}
+    for rec in records:
+        lines = rec.get("lines") or []
+        vols[int(rec["page"])] = core.volume_of(lines)
+    return core.build_from_volumes(core.clean_volumes(vols, min_run=min_run))
+
+
+def _with_matter(chapters, total):
+    chapters = [dict(c, level=1) for c in chapters]
+    if chapters and chapters[0]["page_start"] > 1:
+        chapters.insert(0, {"ord": 0, "level": 1, "title": "卷首（目錄/出版說明）",
+                            "page_start": 1, "page_end": chapters[0]["page_start"] - 1,
+                            "volume": None, "pages": chapters[0]["page_start"] - 1})
+    if chapters and chapters[-1]["page_end"] < total:
+        last = chapters[-1]
+        chapters.append({"ord": len(chapters), "level": 1, "title": "卷末（附錄）",
+                         "page_start": last["page_end"] + 1, "page_end": total,
+                         "volume": None, "pages": total - last["page_end"]})
+    for i, c in enumerate(chapters):
+        c["ord"] = i
+        c["pages"] = c["page_end"] - c["page_start"] + 1
+    return chapters
+
+
+def _pian_candidates(records, ratio=0.0):
+    """{page: (text, width)} for title-sized 篇 lines."""
+    out = {}
+    for rec in records:
+        lines = rec.get("lines") or []
+        widths = [_width(l) for l in lines if _width(l)]
+        median = sorted(widths)[len(widths) // 2] if widths else 0
+        best = None
+        for line in lines:
+            text = str(line.get("text") or "").strip()
+            m = PIAN.search(text)
+            if len(text) > 12 or not m:
+                continue
+            w = _width(line)
+            if ratio and median and w < median * ratio:
+                continue
+            tail = text[m.end():].strip()
+            if LEADER.search(text) or (tail and re.search(r"[：:.。…·・]", tail)):
+                continue
+            key = (len(text), w)
+            if best is None or key > best[0]:
+                best = (key, (text, w))
+        if best:
+            out[int(rec["page"])] = best[1]
+    return out
+
+
+def cmd_volumes(args):
+    records = _read_jsonl(args.headers or args.band)
+    chapters = (_volumes_from_headers(records, args.min_run) if args.headers
+                else _volumes_from_band(records, args.min_run))
+    total = args.total or max(int(r["page"]) for r in records)
+    chapters = _with_matter(chapters, total)
+    json.dump({"chapters": chapters}, open(args.out, "w", encoding="utf-8"),
+              ensure_ascii=False, indent=1)
+    print("volumes=%d pages=%d -> %s" % (len(chapters), total, args.out))
+
+
+def cmd_pian(args):
+    toc = json.load(open(args.toc, encoding="utf-8"))
+    chapters = [c for c in toc["chapters"] if (c.get("level") or 1) == 1]
+    total = max(c["page_end"] for c in chapters)
+    hits = _pian_candidates(_read_jsonl(args.band), args.ratio)
+    by_vol = {}
+    for page in sorted(hits):
+        vol = core.bind_to_volume(page, chapters)
+        if vol is not None:
+            by_vol.setdefault(vol, []).append((page, hits[page][0]))
+    by_vol = {v: core.pian_sequence(items) for v, items in by_vol.items()}
+    by_vol = {v: items for v, items in by_vol.items() if items}
+    rows = core.merge_pian(chapters, by_vol, total=total)
+    json.dump({"chapters": rows}, open(args.out, "w", encoding="utf-8"),
+              ensure_ascii=False, indent=1)
+    level1 = [r for r in rows if r["level"] == 1]
+    print("rows=%d (篇=%d) coverage=%d/%d -> %s"
+          % (len(rows), len(rows) - len(level1), sum(r["pages"] for r in level1), total, args.out))
+
+
+def cmd_hui(args):
+    names = {}
+    for part in (args.names or "").split(","):
+        if "=" in part:
+            k, v = part.split("=", 1)
+            names[int(k)] = v.strip()
+    books = hui.build(_read_jsonl(args.ocr), threshold=args.threshold,
+                      min_pages=args.min_pages, names=names)
+    json.dump({"books": books}, open(args.out, "w", encoding="utf-8"),
+              ensure_ascii=False, indent=1)
+    for bi, rows in enumerate(books):
+        print("book%d %s: %d 回, p%d-%d"
+              % (bi + 1, rows[0].get("book_name", ""), len(rows),
+                 rows[0]["page_start"], rows[-1]["page_end"]))
+    print("-> " + args.out)
+
+
+def _load(path):
+    return json.load(open(path, encoding="utf-8"))["chapters"]
+
+
+def cmd_find(args):
+    row = core.find(_load(args.toc), args.q)
+    print(json.dumps(row, ensure_ascii=False, indent=1) if row else "not found")
+    return 0 if row else 1
+
+
+def cmd_at(args):
+    row = core.at(_load(args.toc), args.page)
+    print(json.dumps(row, ensure_ascii=False, indent=1) if row else "not found")
+    return 0 if row else 1
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="classics-index", description=__doc__)
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    v = sub.add_parser("volumes", help="卷 boundaries from running-header OCR")
+    v.add_argument("--headers", help="header-strip OCR JSONL (page/vol)")
+    v.add_argument("--band", help="title-band OCR JSONL (page/lines)")
+    v.add_argument("--min-run", type=int, default=5)
+    v.add_argument("--total", type=int, default=0)
+    v.add_argument("--out", required=True)
+    v.set_defaults(func=cmd_volumes)
+
+    p = sub.add_parser("pian", help="篇 rows from title-band OCR")
+    p.add_argument("--toc", required=True)
+    p.add_argument("--band", required=True)
+    p.add_argument("--ratio", type=float, default=0.0)
+    p.add_argument("--out", required=True)
+    p.set_defaults(func=cmd_pian)
+
+    h = sub.add_parser("hui", help="回 segments for 章回 novels")
+    h.add_argument("--ocr", required=True)
+    h.add_argument("--threshold", type=float, default=0.55)
+    h.add_argument("--min-pages", type=int, default=4)
+    h.add_argument("--names", default="")
+    h.add_argument("--out", required=True)
+    h.set_defaults(func=cmd_hui)
+
+    f = sub.add_parser("find", help="locate a chapter by number or title")
+    f.add_argument("--toc", required=True)
+    f.add_argument("--q", required=True)
+    f.set_defaults(func=cmd_find)
+
+    a = sub.add_parser("at", help="chapter containing a page")
+    a.add_argument("--toc", required=True)
+    a.add_argument("--page", type=int, required=True)
+    a.set_defaults(func=cmd_at)
+
+    args = ap.parse_args(argv)
+    return args.func(args) or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

classics_index-0.1.0/classics_index/core.py

@@ -0,0 +1,288 @@
+"""Chapter-index core: 卷 / 篇 / 回 from OCR of a scanned book's running headers.
+
+Pure functions only - no storage, no OCR, no I/O beyond dicts and lists, so the
+same code can back a CLI, a service, or a notebook.
+
+Pipeline it supports:
+
+  1. per-page header OCR  -> {page: [{"text": ...}], ...}
+     volume_of + clean_volumes + build_from_volumes  -> level-1 卷 rows
+  2. title-band OCR       -> 篇 candidates
+     bind_to_volume + pian_sequence + merge_pian      -> level-2 篇 rows
+  3. 章回小说 header OCR   -> 回 segments (see hui.py)
+
+Extracted from the sidecar's app/toc.py; the sidecar keeps a superset with
+SQLite storage, so changes here should be mirrored there (or the sidecar should
+depend on this package).
+"""
+import json
+import re
+import sqlite3
+
+
+CN_DIGITS = {"〇": 0, "零": 0, "一": 1, "二": 2, "三": 3, "四": 4, "五": 5,
+             "六": 6, "七": 7, "八": 8, "九": 9}
+CN_UNITS = {"十": 10, "百": 100, "千": 1000}
+
+# "史記卷二十七", "卷二十七", "史记卷 12"
+VOL = re.compile(r"卷\s*([0-9]{1,3}|[〇零一二三四五六七八九十百千]{1,6})")
+PIAN = re.compile(r"(本紀|本纪|紀|纪|世家|列傳|列传|傳|传|書|书|表|志)\s*第\s*([〇零一二三四五六七八九十百]{1,4})")
+
+
+def cn2int(text):
+    """二十七 -> 27; 12 -> 12."""
+    if not text:
+        return None
+    if text.isdigit():
+        return int(text)
+    total, cur = 0, 0
+    for ch in text:
+        if ch in CN_DIGITS:
+            cur = CN_DIGITS[ch]
+        elif ch in CN_UNITS:
+            total += (cur or 1) * CN_UNITS[ch]
+            cur = 0
+        else:
+            return None
+    return total + cur
+
+
+def volume_of(lines):
+    """The volume number a page belongs to, from its running header."""
+    for line in lines:
+        m = VOL.search(str(line.get("text") or ""))
+        if m:
+            n = cn2int(m.group(1))
+            if n:
+                return n
+    return None
+
+
+def build(pages):
+    """pages: {page_no: [ {text, box, score}, ... ]} -> chapter list."""
+    return build_from_volumes({p: volume_of(lines) for p, lines in pages.items()})
+
+
+def clean_volumes(vols, min_run=5):
+    """Drop volume labels that do not survive as a run of pages.
+
+    Front matter (目录) also names volumes, and those names appear in OCR of
+    the same header strip. A real 卷 spans many consecutive pages, so a label
+    that shows up on one or two pages is noise, not a chapter boundary.
+    """
+    runs = []
+    for pno in sorted(vols):
+        vol = vols[pno]
+        if vol is None:
+            continue
+        if runs and runs[-1]["volume"] == vol and pno - runs[-1]["last"] <= 2:
+            runs[-1]["last"] = pno
+            runs[-1]["pages"] += 1
+        else:
+            runs.append({"volume": vol, "first": pno, "last": pno, "pages": 1})
+    kept = [r for r in runs if r["pages"] >= min_run]
+    out = {}
+    for r in kept:
+        for p in range(r["first"], r["last"] + 1):
+            out[p] = r["volume"]
+    return out
+
+
+def build_from_volumes(vols):
+    """vols: {page_no: volume|None} -> chapter list with contiguous page ranges."""
+    chapters = []
+    for pno in sorted(vols):
+        vol = vols[pno]
+        if vol is None:
+            continue
+        if not chapters or chapters[-1]["volume"] != vol:
+            chapters.append({"volume": vol, "page_start": pno, "title": "卷%d" % vol})
+    for i, ch in enumerate(chapters):
+        ch["page_end"] = (chapters[i + 1]["page_start"] - 1
+                          if i + 1 < len(chapters) else max(vols or {1: None}))
+        ch["ord"] = i
+        ch["level"] = 1
+        ch["pages"] = ch["page_end"] - ch["page_start"] + 1
+    return chapters
+
+
+def enrich(chapters, pages):
+    """Append a 篇 name to a volume title when its first page carries one."""
+    for ch in chapters:
+        for line in pages.get(ch["page_start"], []):
+            m = PIAN.search(str(line.get("text") or ""))
+            if m:
+                ch["title"] = "卷%d %s第%s" % (ch["volume"], m.group(1), m.group(2))
+                break
+    return chapters
+
+
+def bind_to_volume(page, chapters, slack=6):
+    """Which 卷 does a candidate title page open?
+
+    Preference order: a chapter that contains the page; otherwise the chapter
+    that starts within slack pages after it (the title page can sit just
+    before the first running header). Front matter stays unbound.
+    """
+    # A 篇 opens the 卷 whose start it sits closest to: the title page can sit a
+    # few leaves before the first running header (the header pass misses early
+    # leaves), so containment alone would bind it to the previous 卷.
+    near = [ch for ch in chapters
+            if ch.get("volume") and abs(ch["page_start"] - page) <= slack]
+    if near:
+        return min(near, key=lambda ch: abs(ch["page_start"] - page))["volume"]
+    for ch in chapters:
+        if ch.get("volume") and ch["page_start"] <= page <= ch["page_end"]:
+            return ch["volume"]
+    return None
+
+
+def pian_sequence(cands, min_gap=3):
+    """Keep a strictly increasing run of 第X titles; drop list-page noise.
+
+    cands: [(page, text)] for one 卷. 目录 pages also spell out 篇 names, so a
+    candidate only survives when its 第X is greater than the previous kept one
+    and it is at least min_gap pages away.
+    """
+    import re as _re
+
+    kept = []
+    last_num = 0
+    last_page = -10
+    for page, text in sorted(cands):
+        m = _re.search(r"第\s*([〇零一二三四五六七八九十百]{1,4})", text)
+        num = cn2int(m.group(1)) if m else None
+        if not num:
+            continue
+        if num <= last_num or page - last_page < min_gap:
+            continue
+        kept.append((page, text))
+        last_num, last_page = num, page
+    return kept
+
+
+def enrich(chapters, pages):
+    """Append a 篇 name to a volume title when its first page carries one."""
+    for ch in chapters:
+        for line in pages.get(ch.get("page_start"), []):
+            m = PIAN.search(str(line.get("text") or ""))
+            if m:
+                ch["title"] = "卷%s %s第%s" % (ch.get("volume"), m.group(1), m.group(2))
+                break
+    return chapters
+
+
+def merge_pian(chapters, hits, total=None):
+    """Fold 篇 title hits into the 卷 rows.
+
+    chapters: level-1 rows from the volume index (may include 卷首/卷末).
+    hits:     {volume: (page, title)} for each 卷 where a 篇 title was found.
+    Returns rows ordered 卷 -> its 篇, with contiguous 卷 ranges; a 卷 start
+    moves earlier when its 篇 title page precedes the running-header page.
+    """
+    rows = []
+    for ch in chapters:
+        ch = dict(ch)
+        ch["level"] = 1
+        hit = hits.get(ch.get("volume"))
+        if hit and isinstance(hit, tuple):
+            hit = [hit]                      # one 篇 per 卷 is the common case
+        items = sorted(hit or [], key=lambda x: x[0])
+        if items:
+            ch["page_start"] = min(ch["page_start"], items[0][0])
+            ch["title"] = "卷%d %s" % (ch["volume"], items[0][1])
+        rows.append(ch)
+        for page, title in items:
+            rows.append({"level": 2, "title": title, "page_start": page,
+                         "page_end": page, "volume": ch["volume"],
+                         "parent": ch["volume"]})
+    total = total or max(r["page_end"] for r in chapters)
+    level1 = [r for r in rows if r["level"] == 1]
+    level1.sort(key=lambda r: r["page_start"])
+    for i, r in enumerate(level1):
+        r["page_end"] = level1[i + 1]["page_start"] - 1 if i + 1 < len(level1) else total
+    for vol in {r.get("volume") for r in rows if r["level"] == 2}:
+        parent = next(x for x in level1 if x.get("volume") == vol)
+        pian = sorted((r for r in rows if r["level"] == 2 and r["volume"] == vol),
+                      key=lambda r: r["page_start"])
+        for i, r in enumerate(pian):
+            r["page_end"] = (pian[i + 1]["page_start"] - 1) if i + 1 < len(pian) else parent["page_end"]
+            r["page_end"] = max(r["page_end"], r["page_start"])
+    for i, r in enumerate(rows):
+        r["ord"] = i
+        r["pages"] = r["page_end"] - r["page_start"] + 1
+    return rows
+
+
+def at(rows, page):
+    """The chapter row that contains a page (innermost wins)."""
+    best = None
+    for r in rows:
+        if r["page_start"] <= page <= r["page_end"]:
+            if best is None or (r.get("level") or 1) > (best.get("level") or 1):
+                best = r
+    return best
+
+
+# OCR output and 点校本 titles are traditional; readers type simplified. A
+# full converter is overkill, so cover the characters that actually appear in
+# the chapter names of the indexed books.
+_TRAD = {
+    "紀": "纪", "傳": "传", "書": "书", "項": "项", "賈": "贾", "詡": "诩",
+    "張": "张", "涼": "凉", "國": "国", "鮑": "鲍", "馬": "马", "鍾": "钟",
+    "華": "华", "劉": "刘", "蔣": "蒋", "繇": "繇", "歆": "歆", "毓": "毓",
+    "禮": "礼", "樂": "乐", "曆": "历", "曆": "历", "邊": "边", "衛": "卫",
+    "權": "权", "陰": "阴", "陽": "阳", "東": "东", "車": "车", "軍": "军",
+    "吳": "吴", "魯": "鲁", "齊": "齐", "鄭": "郑", "晉": "晋", "衛": "卫",
+    "陳": "陈", "韓": "韩", "魏": "魏", "趙": "赵", "楚": "楚", "燕": "燕",
+    "漢": "汉", "秦": "秦", "夏": "夏", "殷": "殷", "周": "周", "帝": "帝",
+}
+
+
+def _simp(text):
+    return "".join(_TRAD.get(ch, ch) for ch in str(text or ""))
+
+
+def _num_in(title, kind):
+    """Pull the printed number out of a title: 卷12 / 第三回."""
+    m = re.search(r"%s\s*(\d{1,4}|[〇零一二三四五六七八九十百千]{1,6})" % kind, title or "")
+    return cn2int(m.group(1)) if m else None
+
+
+def find(rows, query):
+    """Locate a chapter by ordinal, printed number, or a title fragment.
+
+    Accepts "3", "卷3", "第三回", "第7回", "五帝本纪", "项王".
+    """
+    q = str(query or "").strip()
+    if not q:
+        return None
+    m = re.search(r"(卷|第)\s*(\d{1,4}|[〇零一二三四五六七八九十百千]{1,6})", q)
+    if m:
+        kind = "卷" if m.group(1) == "卷" else "第"
+        num = cn2int(m.group(2))
+        if num:
+            hits = [r for r in rows if _num_in(r.get("title"), kind) == num]
+            if hits:
+                return max(hits, key=lambda r: r.get("level") or 1)
+            for r in rows:
+                if kind == "卷" and (r.get("level") or 1) == 1 and r.get("volume") == num:
+                    return r
+                if kind == "第" and r.get("ord") == num - 1:
+                    return r
+            return None
+    if q.isdigit():
+        n = int(q)
+        for r in rows:
+            if r.get("ord") == n:
+                return r
+        for r in rows:
+            if r.get("ord") == n - 1:
+                return r
+    needle = _simp(q.replace("第", "").replace("回", "").replace("卷", "").strip())
+    if needle:
+        hits = [r for r in rows if needle in _simp(r.get("title"))]
+        if hits:
+            return max(hits, key=lambda r: r.get("level") or 1)
+    return None
+

classics_index-0.1.0/classics_index/hui.py

@@ -0,0 +1,172 @@
+"""章回小说: turn per-page header OCR into 回 segments.
+
+A 章回 novel prints the current 回 title in the running header of every leaf,
+so a change of header title is a chapter boundary. Numbers come from leaves
+that also show "第X回"; the rest are filled by counting. An inserted 附录
+(common in 西游记) repeats the previous header and must not consume a number.
+
+Pure functions: pass in the parsed pages, get rows back.
+"""
+import difflib
+import re
+
+from . import core
+
+# Chinese numerals dominate old typesetting, but modern reprints print 第12回.
+NUM = re.compile(r"第\s*([〇零一二三四五六七八九十百千]{1,6}|\d{1,4})\s*回")
+CJK = re.compile(r"[\u3400-\u9fff]")
+
+
+def clean(text):
+    return "".join(CJK.findall(text or ""))
+
+
+def parse_records(records):
+    """OCR records -> {page: {"num", "title", "appendix"}}.
+
+    Accepts the JSONL objects written by novel_hui_ocr.py: {"page", "texts"}.
+    """
+    pages = {}
+    for rec in records:
+        texts = [t for t in (rec.get("texts") or []) if str(t).strip()]
+        num, titles = None, []
+        for t in texts:
+            m = NUM.search(t)
+            if m:
+                if num is None:
+                    num = core.cn2int(m.group(1))
+                continue
+            c = clean(t)
+            if 4 <= len(c) <= 16:
+                titles.append(c)
+        if num is None:
+            m = NUM.search("".join(texts))
+            if m:
+                num = core.cn2int(m.group(1))
+        appendix = any(clean(t) in ("附", "录", "錄", "附录", "附錄") for t in texts)
+        pages[int(rec["page"])] = {"num": num,
+                                   "title": max(titles, key=len) if titles else "",
+                                   "appendix": appendix}
+    return pages
+
+
+def sim(a, b):
+    return difflib.SequenceMatcher(None, a, b).ratio()
+
+
+def segment(pages, threshold=0.55):
+    """Split pages into runs of one header title."""
+    runs = []
+    for pno in sorted(pages):
+        rec = pages[pno]
+        title = rec["title"]
+        if not title:
+            continue
+        if runs and sim(title, runs[-1]["title"]) >= threshold:
+            runs[-1]["end"] = pno
+            runs[-1]["count"] += 1
+            continue
+        nxt = pages.get(pno + 1, {}).get("title", "")
+        if runs and not rec["num"] and nxt and sim(nxt, runs[-1]["title"]) >= threshold:
+            runs[-1]["end"] = pno
+            continue
+        runs.append({"start": pno, "end": pno, "title": title, "count": 1})
+    return runs
+
+
+def merge_short(runs, min_pages=4):
+    """A one- or two-leaf run is an OCR blip, not a chapter: fold it back."""
+    out = []
+    for r in runs:
+        if out and (r["end"] - r["start"] + 1) < min_pages:
+            out[-1]["end"] = r["end"]
+            out[-1]["count"] += r.get("count", 1)
+            continue
+        out.append(r)
+    return out
+
+
+def mark_appendix(runs, pages):
+    for r in runs:
+        r["appendix"] = any(pages.get(p, {}).get("appendix")
+                            for p in range(r["start"], r["end"] + 1))
+    return runs
+
+
+def number(runs, pages):
+    """Assign 回 numbers: trust detected ones, count the rest, skip 附录."""
+    for r in runs:
+        r["num"] = None
+        r["detected"] = None
+    for r in runs:
+        for p in range(r["start"], min(r["end"], r["start"] + 3) + 1):
+            rec = pages.get(p) or {}
+            if rec.get("num"):
+                r["num"] = rec["num"]
+                r["detected"] = rec["num"]
+                break
+    last = 0
+    for r in runs:
+        if r.get("appendix"):
+            r["num"] = None
+            continue
+        if r["num"] is None and last:
+            r["num"] = last + 1
+        last = r["num"] or last
+    for i in range(len(runs) - 1, -1, -1):
+        if runs[i].get("appendix"):
+            continue
+        if runs[i]["num"] is None and i + 1 < len(runs):
+            nxt = next((r["num"] for r in runs[i + 1:] if r["num"]), None)
+            if nxt:
+                runs[i]["num"] = nxt - 1
+    return runs
+
+
+def trim(runs):
+    """Drop front matter before the first numbered 回; number rows by position."""
+    first = next((i for i, r in enumerate(runs) if r["num"]), 0)
+    runs = runs[first:]
+    for i, r in enumerate(runs):
+        r["page_start"], r["page_end"] = r["start"], r["end"]
+        r["ord"] = i
+        r["level"] = 2
+    for i, r in enumerate(runs):
+        r["page_end"] = runs[i + 1]["start"] - 1 if i + 1 < len(runs) else r["end"]
+        r["pages"] = r["page_end"] - r["page_start"] + 1
+        r["printed"] = r["num"]
+        r["num"] = i + 1
+        r["title_text"] = ("附录 " + r["title"]) if r.get("appendix") else r["title"]
+    return runs
+
+
+def split_books(runs):
+    """A new novel starts where the printed 回 number falls back to the top."""
+    books, cur, last = [], [], 0
+    for r in runs:
+        # The printed number resets to 1 at a new novel; the counted number does
+        # not, so the split must look at what the header actually said.
+        pr = r.get("detected") or 0
+        if cur and pr and pr <= 3 and last >= 10:
+            books.append(cur)
+            cur = []
+        cur.append(r)
+        last = pr or last
+    if cur:
+        books.append(cur)
+    return books
+
+
+def build(records, threshold=0.55, min_pages=4, names=None):
+    pages = parse_records(records)
+    runs = segment(pages, threshold)
+    runs = merge_short(runs, min_pages)
+    runs = mark_appendix(runs, pages)
+    runs = trim(number(runs, pages))
+    books = split_books(runs)
+    names = names or {}
+    for bi, rows in enumerate(books):
+        for r in rows:
+            r["book"] = bi + 1
+            r["book_name"] = names.get(bi + 1, "第%d部" % (bi + 1))
+    return books

classics_index-0.1.0/classics_index.egg-info/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: classics-index
+Version: 0.1.0
+Summary: Chapter indexes (卷 / 篇 / 回) for scanned Chinese books, built from OCR of the running header
+Author: socratic-tutor contributors
+License: MIT
+Keywords: chinese-classics,scanned-books,ocr,table-of-contents,pymupdf
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: ocr
+Requires-Dist: paddleocr>=3; extra == "ocr"
+Requires-Dist: pillow; extra == "ocr"
+Requires-Dist: pymupdf; extra == "ocr"
+Dynamic: license-file
+
+# classics-index
+
+从**扫描本**的版心（页边书眉）OCR 里建章回索引：卷 → 篇 → 回。不依赖任何在线服务，纯 Python，无第三方运行时依赖（OCR 引擎是可选的）。
+
+```
+pip install -e .
+classics-index volumes --headers heads.jsonl --out toc.json
+classics-index pian    --toc toc.json --band titles.jsonl --out toc-pian.json
+classics-index hui     --ocr hui.jsonl --names "1=西游记,2=水浒传" --out hui.json
+classics-index find    --toc toc.json --q 卷3
+```
+
+## 它解决什么问题
+
+点校本、影印本没有文本层，目录页也常常 OCR 不可用。但**每一页的页眉都印着卷次**（"史記卷二"）或回目（"灵根育孕源流出心性修持大道生"）。于是：
+
+| 输入 | 输出 |
+|---|---|
+| 每页页眉带的 OCR（`{"page": n, "vol": 2}`） | 卷的起止页，连续覆盖全书 |
+| 每页右侧标题带的 OCR（`{"page": n, "lines": [...]}`） | 篇名页与篇页码范围 |
+| 章回小说每页页眉 OCR（`{"page": n, "texts": [...]}`） | 回目分段、附录标记、多部书切分 |
+
+## 设计上的三个关键判据
+
+1. **卷靠"连续 ≥5 页"**：目录页也会写出"史記卷十三"，那种孤页会被丢掉。
+2. **篇靠"行的形态"而不是字号**：实测卷眉（48 px 宽）比篇名（46 px）还宽，宽度阈值不可靠；可靠的是"短行 + 序号结尾干净"（目录行末尾是"："或省略号）。
+3. **回靠"页眉标题变化"**：章回小说每页页眉都印着当前回目，标题一变就是新回；附录（"附/录"）重复上一回页眉，不能占回号。
+
+## 数据从哪来
+
+配套的 OCR 脚本在本仓库的 `eval/p3/`（`vertical_header_ocr.py`、`vertical_title_ocr.py`、`novel_hui_ocr.py`），它们只是 PaddleOCR 的一层薄封装：
+
+- 版心带：页面右侧 18%、高度 8%–55%，1.2 s/页；
+- 标题带：右侧 42%、高度 3%–65%，3.5 s/页；
+- 章回页眉：全宽、高度 3%–15%，0.55 s/页。
+
+把任意 OCR 引擎的结果整理成本包要的 JSONL 也行。
+
+## 已在什么数据上验证
+
+| 书 | 规模 | 结果 |
+|---|---|---|
+| 《史记》点校本 一 | 358 页 | 7 卷 + 7 篇，覆盖 358/358 |
+| 《三国志》二 | 140 页 | 卷10–14 五篇篇名正确 |
+| 四大名著合订本 | 2745/5291 页 | 215 回目段 / 3 部（过切 +1%） |
+
+## 限制
+
+- 版心位置是按中华书局版式调的，换版式要调裁切参数；
+- 章回小说的"换书边界"会晚一回（下一部第一回的页眉常没有"第一回"）；
+- 只处理竖排/横排的中文印刷体，不做手写、不做多栏学术期刊。
+
+## 许可
+
+尚未选定（建议 MIT）；选好之前不要发布到任何包索引。

classics_index-0.1.0/classics_index.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+classics_index/__init__.py
+classics_index/cli.py
+classics_index/core.py
+classics_index/hui.py
+classics_index.egg-info/PKG-INFO
+classics_index.egg-info/SOURCES.txt
+classics_index.egg-info/dependency_links.txt
+classics_index.egg-info/entry_points.txt
+classics_index.egg-info/requires.txt
+classics_index.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_core.py
+tests/test_hui.py

classics_index-0.1.0/classics_index.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

classics_index-0.1.0/classics_index.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+classics-index = classics_index.cli:main

classics_index-0.1.0/classics_index.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[ocr]
+paddleocr>=3
+pillow
+pymupdf

classics_index-0.1.0/classics_index.egg-info/top_level.txt

@@ -0,0 +1 @@
+classics_index

classics_index-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "classics-index"
+version = "0.1.0"
+description = "Chapter indexes (卷 / 篇 / 回) for scanned Chinese books, built from OCR of the running header"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "socratic-tutor contributors" }]
+keywords = ["chinese-classics", "scanned-books", "ocr", "table-of-contents", "pymupdf"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Topic :: Text Processing :: Linguistic",
+]
+license = { text = "MIT" }
+dependencies = []
+
+[project.optional-dependencies]
+ocr = ["paddleocr>=3", "pillow", "pymupdf"]
+
+[project.scripts]
+classics-index = "classics_index.cli:main"
+
+[tool.setuptools]
+packages = ["classics_index"]

classics_index-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

classics_index-0.1.0/tests/test_cli.py

@@ -0,0 +1,39 @@
+import json
+import os
+import tempfile
+import unittest
+
+from classics_index import cli
+
+HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+EX = os.path.join(HERE, "examples")
+
+
+class TestCliOnExamples(unittest.TestCase):
+    def test_volumes_and_pian_match_expected(self):
+        tmp = tempfile.mkdtemp()
+        toc = os.path.join(tmp, "toc.json")
+        idx = os.path.join(tmp, "index.json")
+        cli.main(["volumes", "--headers", os.path.join(EX, "demo-headers.jsonl"),
+                  "--out", toc])
+        cli.main(["pian", "--toc", toc,
+                  "--band", os.path.join(EX, "demo-titles.jsonl"), "--out", idx])
+        got = json.load(open(idx, encoding="utf-8"))["chapters"]
+        want = json.load(open(os.path.join(EX, "expected-toc.json"), encoding="utf-8"))["chapters"]
+        self.assertEqual(len(got), len(want))
+        for g, w in zip(got, want):
+            self.assertEqual(g["title"], w["title"])
+            self.assertEqual((g["page_start"], g["page_end"]), (w["page_start"], w["page_end"]))
+            self.assertEqual(g["level"], w["level"])
+
+    def test_find_and_at(self):
+        tmp = tempfile.mkdtemp()
+        toc = os.path.join(tmp, "toc.json")
+        cli.main(["volumes", "--headers", os.path.join(EX, "demo-headers.jsonl"), "--out", toc])
+        rows = json.load(open(toc, encoding="utf-8"))["chapters"]
+        self.assertEqual(rows[1]["page_start"], 3)
+        self.assertIn("卷1", rows[1]["title"])
+
+
+if __name__ == "__main__":
+    unittest.main()

classics_index-0.1.0/tests/test_core.py

@@ -0,0 +1,77 @@
+import unittest
+
+from classics_index import core
+
+
+ROWS = [
+    {"ord": 0, "level": 1, "title": "卷首", "page_start": 1, "page_end": 18, "volume": None},
+    {"ord": 1, "level": 1, "title": "卷1 五帝本紀第一", "page_start": 19, "page_end": 66, "volume": 1},
+    {"ord": 2, "level": 2, "title": "五帝本紀第一", "page_start": 19, "page_end": 66, "volume": 1},
+    {"ord": 3, "level": 1, "title": "卷2 夏本紀第二", "page_start": 67, "page_end": 108, "volume": 2},
+    {"ord": 4, "level": 2, "title": "夏本紀第二", "page_start": 67, "page_end": 108, "volume": 2},
+]
+
+
+class TestCn2Int(unittest.TestCase):
+    def test_values(self):
+        self.assertEqual(core.cn2int("二十七"), 27)
+        self.assertEqual(core.cn2int("一百零五"), 105)
+        self.assertEqual(core.cn2int("12"), 12)
+
+
+class TestVolumes(unittest.TestCase):
+    def test_volume_of_running_header(self):
+        self.assertEqual(core.volume_of([{"text": "正文"}, {"text": "史記卷二"}]), 2)
+
+    def test_clean_drops_single_page_noise(self):
+        vols = {10: 13, 11: None, 12: 28, 20: 1, 21: 1, 22: 1, 23: 1, 24: 1}
+        clean = core.clean_volumes(vols, min_run=5)
+        self.assertEqual(set(clean.values()), {1})
+
+    def test_ranges_are_contiguous(self):
+        vols = {1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 2, 7: 2, 8: 2, 9: 2, 10: 2}
+        rows = core.build_from_volumes(core.clean_volumes(vols, min_run=5))
+        self.assertEqual([r["volume"] for r in rows], [1, 2])
+        self.assertEqual(rows[0]["page_end"], 5)
+
+
+class TestBind(unittest.TestCase):
+    def test_inside(self):
+        self.assertEqual(core.bind_to_volume(40, ROWS), 1)
+
+    def test_title_page_before_header(self):
+        self.assertEqual(core.bind_to_volume(19, ROWS), 1)
+        self.assertEqual(core.bind_to_volume(66, ROWS), 2)
+
+    def test_far_front_matter(self):
+        self.assertIsNone(core.bind_to_volume(5, ROWS))
+
+
+class TestFind(unittest.TestCase):
+    def test_fragment(self):
+        self.assertEqual(core.find(ROWS, "夏本纪")["title"], "夏本紀第二")
+
+    def test_juan(self):
+        self.assertEqual(core.find(ROWS, "卷2")["volume"], 2)
+
+    def test_missing(self):
+        self.assertIsNone(core.find(ROWS, "不存在"))
+
+
+class TestMergePian(unittest.TestCase):
+    def test_start_moves_to_title_page(self):
+        rows = core.merge_pian([r for r in ROWS if r["level"] == 1], {2: (67, "夏本紀第二")}, total=108)
+        vol2 = [r for r in rows if r.get("volume") == 2 and r["level"] == 1][0]
+        self.assertEqual(vol2["page_start"], 67)
+        self.assertEqual(vol2["title"], "卷2 夏本紀第二")
+
+    def test_multiple_pian_in_one_volume(self):
+        level1 = [r for r in ROWS if r["level"] == 1]
+        rows = core.merge_pian(level1, {1: [(19, "五帝本紀第一"), (30, "夏本紀第二")]}, total=108)
+        pian = [r for r in rows if r["level"] == 2 and r.get("volume") == 1]
+        self.assertEqual([p["page_start"] for p in pian], [19, 30])
+        self.assertEqual(pian[0]["page_end"], 29)
+
+
+if __name__ == "__main__":
+    unittest.main()

classics_index-0.1.0/tests/test_hui.py

@@ -0,0 +1,66 @@
+import unittest
+
+from classics_index import hui
+
+
+def rec(page, texts):
+    return {"page": page, "texts": texts}
+
+
+# Distinct 回 titles: two 回 with similar headers would be one segment.
+TITLES = [
+    "灵根育孕源流出心性修持", "悟彻菩提真妙理断魔归本", "四海千山皆拱伏九幽十类",
+    "官封弼马心何足名注齐天", "乱蟠桃大圣偷丹反天宫", "观音赴会问原因小圣施威",
+    "八卦炉中逃大圣五行山", "我佛造经传极乐观音奉旨", "陈光蕊赴任逢灾江流僧",
+    "老龙王拙计犯天条魏征", "二将军宫门镇鬼唐太宗", "还受生唐王遵善果度孤魂",
+]
+
+
+def book(start, end, num, title, with_number=True):
+    """Pages of one 回: the first leaf carries "第X回", the rest only the title."""
+    out = []
+    for p in range(start, end + 1):
+        texts = [title]
+        if with_number and p == start:
+            texts.insert(0, "第%d回" % num)
+        out.append(rec(p, texts))
+    return out
+
+
+class TestHui(unittest.TestCase):
+    def test_segments_by_header(self):
+        records = book(1, 5, 1, "灵根育孕源流出心性修持大道生")
+        records += book(6, 10, 2, "悟彻菩提真妙理断魔归本合元神")
+        rows = hui.build(records)[0]
+        self.assertEqual(len(rows), 2)
+        self.assertEqual((rows[0]["page_start"], rows[0]["page_end"]), (1, 5))
+        self.assertEqual(rows[1]["page_start"], 6)
+
+    def test_short_run_is_merged(self):
+        records = book(1, 5, 1, "甲乙丙丁戊己庚辛壬癸")
+        records.append(rec(6, ["子丑寅卯辰巳午未申酉"]))   # one-leaf blip
+        records += book(7, 11, 1, "甲乙丙丁戊己庚辛壬癸", with_number=False)
+        rows = hui.build(records)[0]
+        self.assertEqual(len(rows), 1)
+
+    def test_appendix_does_not_consume_a_number(self):
+        records = book(1, 5, 1, "灵根育孕源流出心性修持大道生")
+        records += [rec(p, ["陈光蕊赴任逢灾江流僧复仇报本", "附", "录"]) for p in range(6, 11)]
+        records += book(11, 15, 9, "袁守诚妙算无私曲老龙王拙计犯天条")
+        rows = hui.build(records)[0]
+        self.assertEqual(len(rows), 3)
+        self.assertIn("附录", rows[1]["title_text"])
+        self.assertEqual(rows[2]["num"], 3)
+
+    def test_book_split_on_number_reset(self):
+        records = []
+        for i in range(1, 11):                      # a real novel runs well past 10
+            records += book((i - 1) * 6 + 1, i * 6, i, TITLES[i - 1])
+        records += book(61, 66, 1, "三国开篇宴桃园豪杰三结义")
+        books = hui.build(records)
+        self.assertEqual(len(books), 2)
+        self.assertEqual(books[1][0]["page_start"], 61)
+
+
+if __name__ == "__main__":
+    unittest.main()