Show an estimated page count for each built book

Bindery counts the pages as the last step of a build, from the text of the ePub. The story list and the OPDS catalog show the count. A story has no count until its book is built.

The method follows "Paragraphs (APNX Accurate)" of the Count Pages plugin for calibre. Bindery counts each paragraph that a reader sees, so the same text gives the same count as <p> elements, as <div> elements and as lines with <br> between them. An empty paragraph is not counted.

tests/js/flows.test.mjs

@@ -380,7 +380,7 @@ test('story list stacks on a narrow screen instead of scrolling sideways', async
   const wrap = nodes(main).find((el) => el.className === 'table-wrap stories-table');
   assert.ok(wrap);
   const dataLabels = nodes(wrap).filter((el) => el.tagName === 'td').map((el) => el.attributes['data-label']);
-  assert.deepEqual(dataLabels, [undefined, 'Author', 'Site', 'Chapters', 'Status', 'Last change', 'Last check']);
+  assert.deepEqual(dataLabels, [undefined, 'Author', 'Site', 'Chapters', 'Pages', 'Status', 'Last change', 'Last check']);
 });
 
 test('the story list shows removed and revised chapter counts, only when there are any', async () => {

tests/js/layout.test.mjs

@@ -114,6 +114,12 @@ test('sortable headings show direction and remain usable above story cards on na
   assert.doesNotMatch(css, /\.stories-table thead\s*\{[^}]*clip-path/);
 });
 
+test('on narrow screens a story cell with no value shows no line', () => {
+  const start = css.indexOf('@media (max-width: 600px)', css.indexOf('.stories-table th button'));
+  assert.equal(declarations('.stories-table td:empty', css.slice(start)).display, 'none');
+  assert.doesNotMatch(css.slice(0, start), /\.stories-table td:empty/);
+});
+
 test('on narrow screens the headings are sort chips, and only the sorted chip is tinted with an arrow', () => {
   const start = css.indexOf('@media (max-width: 600px)', css.indexOf('.stories-table th button'));
   const mobile = css.slice(start);

tests/js/story-list.test.mjs

@@ -21,7 +21,7 @@ const story = (id, title, changes = {}) => ({
   id, title, url: `https://example.com/${id}`,
   sort_title: (title || `https://example.com/${id}`).trim().replace(/^(?:the|an?)\s+/i, '').toLowerCase(),
   author: 'Reader', site: 'example.com',
-  chapter_count: 42, offsite_count: 0, revised_count: 0, status: 'ok', message: 'No changes',
+  chapter_count: 42, page_count: 120, offsite_count: 0, revised_count: 0, status: 'ok', message: 'No changes',
   last_changed: null, last_checked: null, ...changes,
 });
 const rows = () => {
@@ -106,6 +106,39 @@ test('chapter sorting compares counts numerically and keeps equal counts in titl
   assert.equal(heading('Chapters').attributes['aria-sort'], 'ascending');
 });
 
+test('pages show beside the chapters and sort numerically', async (t) => {
+  await mount(t, [
+    story(1, 'Zeta', { page_count: 9 }),
+    story(2, 'Alpha', { page_count: 1200 }),
+    story(3, 'Beta', { page_count: 0 }),
+    story(4, 'Gamma', { page_count: 9 }),
+  ]);
+  const cells = nodes(rows()[0]).filter((el) => el.tagName === 'td').map((el) => el.attributes['data-label']);
+  assert.deepEqual(cells.slice(3, 5), ['Chapters', 'Pages']);
+  assert.equal(find(app, 'button', 'Pages').attributes['aria-label'], 'Sort by pages, most first');
+  await click(app, 'Pages');
+  assert.deepEqual(titles(), ['Alpha', 'Gamma', 'Zeta', 'Beta']);
+  await click(app, 'Pages');
+  assert.deepEqual(titles(), ['Beta', 'Gamma', 'Zeta', 'Alpha']);
+  assert.deepEqual(JSON.parse(window.localStorage.getItem(SORT_KEY)), { column: 'page_count', direction: 1 });
+});
+
+test('a story with no built book shows no page count and sorts last in each direction', async (t) => {
+  await mount(t, [
+    story(1, 'Alpha', { page_count: null }),
+    story(2, 'Beta', { page_count: 300 }),
+    story(3, 'Gamma', { page_count: 0 }),
+    story(4, 'Delta', { page_count: null }),
+  ]);
+  const pages = () => rows().map((row) => cell(row, 'Pages'));
+  assert.deepEqual(pages().map((el) => el.textContent), ['', '300', '', '0']);
+  assert.deepEqual(pages().map((el) => el.children.length), [0, 1, 0, 1], 'An empty cell hides on a narrow screen');
+  await click(app, 'Pages');
+  assert.deepEqual(titles(), ['Beta', 'Gamma', 'Alpha', 'Delta']);
+  await click(app, 'Pages');
+  assert.deepEqual(titles(), ['Gamma', 'Beta', 'Alpha', 'Delta']);
+});
+
 for (const [label, key] of [['Author', 'author'], ['Site', 'site'], ['Status', 'status']]) {
   test(`${label} sorts alphabetically in either direction and uses titles to break ties`, async (t) => {
     await mount(t, [
@@ -248,7 +281,7 @@ test('date columns keep each timestamp on one line, with last change before last
   const checked = '2026-01-03T05:06:00Z';
   await mount(t, [story(1, 'Alpha', { last_changed: changed, last_checked: checked })]);
   const headings = nodes(app).filter((el) => el.tagName === 'th').map((el) => el.textContent);
-  assert.deepEqual(headings, ['Title', 'Author', 'Site', 'Chapters', 'Status', 'Last change', 'Last check']);
+  assert.deepEqual(headings, ['Title', 'Author', 'Site', 'Chapters', 'Pages', 'Status', 'Last change', 'Last check']);
   for (const [label, value] of [['Last change', changed], ['Last check', checked]]) {
     const dateCell = cell(rows()[0], label);
     const time = nodes(dateCell).find((el) => el.tagName === 'time');

tests/test_build_keys.py

@@ -11,7 +11,7 @@ from test_deliver import fake as fake
 from test_deliver import jobs as jobs
 from test_deliver import story_epub as story_epub
 
-from bindery import config, orchestrator
+from bindery import config, orchestrator, pages
 from bindery.jobs import DownloadMode, Job
 
 ONE = [(1, "One", "a")]
@@ -242,6 +242,59 @@ def test_a_download_builds_a_book_that_has_no_file_or_that_changed(builds, clien
     assert story(story_id)["last_changed"]
 
 
+# Page counts
+
+LONG = "A line of the story. " * 20
+
+
+def listed_pages(story_id):
+    return {s["id"]: s["page_count"] for s in orchestrator.list_stories()}[story_id]
+
+
+def test_a_story_has_no_page_count_until_its_book_is_built(builds, monkeypatch):
+    story_id = linked_story(ONE)
+    assert listed_pages(story_id) is None
+    site(monkeypatch, ONE)
+    update(story_id)
+    (built,) = config.TMP_DIR.iterdir()
+    assert listed_pages(story_id) == pages.epub_pages(built) == 1
+
+
+def test_each_build_counts_the_pages_of_the_new_book(builds, client, monkeypatch):
+    story_id = linked_story(ONE)
+    site(monkeypatch, [*ONE, *[(n, f"Chapter {n}", "<br/>".join([LONG] * 31)) for n in range(2, 6)]])
+    update(story_id)
+    long_book = listed_pages(story_id)
+    # Each of the 124 lines is a paragraph and 6 lines of text.
+    assert long_book >= 4 * 31 * 7 // 31
+    # The count is of the built book, so a rule that removes text changes it without a download.
+    orchestrator.save_rules(story_id, [{"pattern": "(A line of the story. ){19}", "replacement": ""}])
+    download(client, story_id)
+    assert builds.call_count == 2
+    assert 0 < listed_pages(story_id) < long_book / 3
+
+
+def test_a_book_from_before_the_page_count_is_counted_without_a_build(builds, client, monkeypatch):
+    story_id = linked_story(ONE)
+    site(monkeypatch, ONE)
+    update(story_id)
+    orchestrator.store.set_setting(story_id, "page_count", None)
+    download(client, story_id)
+    assert builds.call_count == 1
+    assert listed_pages(story_id) == 1
+
+
+def test_a_book_that_cannot_be_counted_is_still_built(builds, monkeypatch):
+    def fail(path):
+        raise orchestrator.EpubError("unreadable")
+
+    monkeypatch.setattr(pages, "epub_pages", fail)
+    story_id = linked_story(ONE)
+    site(monkeypatch, ONE)
+    assert "library book 1" in update(story_id)
+    assert listed_pages(story_id) is None
+
+
 def test_stop_tracking_deletes_the_built_book(builds, client):
     story_id, other = add_story(), orchestrator.store.create_story("https://other", "s", "Other", "W", [])
     download(client, story_id)

tests/test_opds.py

@@ -205,6 +205,17 @@ def test_entry_shows_the_book_metadata_and_cover(client):
     assert client.get(f"/opds/books/{add_book()}/cover").status_code == 404
 
 
+def test_entry_shows_the_page_count_of_a_built_book(client):
+    sid = add_book()
+    orchestrator.store.set_setting(sid, "page_count", 321)
+    add_book(title="Not built")
+    contents = {
+        e.findtext("a:title", namespaces=NS): e.findtext("a:content", namespaces=NS)
+        for e in entries(feed(client.get("/opds/title")))
+    }
+    assert contents == {"A book": "Chapters: 1\nPages: 321", "Not built": "Chapters: 1"}
+
+
 def test_cover_of_an_unsafe_type_is_left_out(client):
     sid = add_book()
     orchestrator.store.put_image(sid, "https://example.com/c.svg", "svg", "image/svg+xml", b"<svg/>", is_cover=True)

tests/test_pages.py

@@ -0,0 +1,122 @@
+"""The page estimate of a document and of a built epub."""
+
+import zipfile
+
+import pytest
+
+from bindery import pages
+from bindery.epub import EpubError, spine_documents
+from bindery.pages import Measure
+
+TEXT = ["One line of the story.", "Another, longer line of the story that goes on for a while.", "The end."]
+CHARS = sum(map(len, TEXT))
+
+
+def test_a_paragraph_is_text_after_a_block_or_a_line_break():
+    assert pages.measure("<p>One</p><p>Two</p>") == Measure(2, 6)
+    assert pages.measure("<div>One<br/><br/>Two<br>Three</div>") == Measure(3, 11)
+    assert pages.measure("<div><div>One</div><div>Two</div></div>") == Measure(2, 6)
+    # Text before, between and after the blocks of an element counts too.
+    assert pages.measure("<div>Intro<p>One</p>Middle<p>Two</p>End</div>") == Measure(5, 20)
+    assert pages.measure("<h3>Title</h3><ul><li>One</li><li>Two</li></ul><blockquote>Three</blockquote>") == Measure(
+        4, 16
+    )
+
+
+@pytest.mark.parametrize(
+    "book",
+    [
+        "".join(f"<p>{line}</p>" for line in TEXT),
+        "".join(f'<p class="a">{line}</p>\n' for line in TEXT),
+        "<div>" + "".join(f"<div>{line}</div>" for line in TEXT) + "</div>",
+        "<div>" + "<br/><br/>".join(TEXT) + "</div>",
+        "<div>" + "<br>\n".join(TEXT) + "</div>",
+        f"<div>{TEXT[0]}<p>{TEXT[1]}</p>{TEXT[2]}</div>",
+    ],
+)
+def test_the_same_text_gives_the_same_measure_in_each_markup(book):
+    assert pages.measure(book) == Measure(3, CHARS)
+
+
+def test_inline_elements_and_table_cells_stay_in_the_line():
+    assert pages.measure('<p>ab<b>cd</b><a href="x">ef</a> <span><i>gh</i></span></p>') == Measure(1, 9)
+    assert pages.measure("<table><tr><td>Name</td><td>Value</td></tr><tr><th>a</th><td>b</td></tr></table>") == Measure(
+        2, 11
+    )
+    assert pages.measure('<p>Before<img src="a.png"/>after</p>') == Measure(1, 11)
+
+
+def test_only_the_text_of_the_book_counts():
+    document = (
+        '<?xml version="1.0"?><html><head><title>Hidden title</title><style>p { color: red }</style>'
+        '<link href="a.css"/></head><body><script>var hidden;</script><script src="x.js"/>'
+        "<!-- a note --><p>Shown &amp; counted</p>\n\n<p> </p><p></p></body></html>"
+    )
+    assert pages.measure(document) == Measure(1, len("Shown & counted"))
+    assert pages.measure("") == Measure(0, 0)
+    assert pages.measure("<p>\n</p>") == Measure(0, 0)
+
+
+def test_a_paragraph_that_only_spaces_the_text_is_not_counted():
+    spaced = "<p>One</p><p>&nbsp;</p><p>\xa0</p><p> &#160; </p><p><br/></p><p><span>&nbsp;</span></p><p>Two</p>"
+    assert pages.measure(spaced) == pages.measure("<p>One</p><p>Two</p>") == Measure(2, 6)
+    assert pages.measure("<div>One<br/>&nbsp;<br/>Two</div>") == Measure(2, 6)
+    # A no-break space inside a paragraph is a character of its text.
+    assert pages.measure("<p>One&nbsp;<b>two</b>\xa0three</p>") == Measure(1, 13)
+
+
+def test_a_page_is_31_lines_and_a_line_is_a_paragraph_or_70_characters():
+    assert pages.page_count(Measure(62, 620)) == (62 + 620 // 70) // 31 == 2
+    assert pages.page_count(Measure(31 * 9, 31 * 9)) == 9
+    assert pages.page_count(Measure(1000, 177_000)) == (1000 + 177_000 // 70) // 31
+
+
+def test_a_short_book_has_one_page_and_a_book_with_no_text_has_none():
+    assert pages.page_count(Measure(1, 10)) == 1
+    assert pages.page_count(Measure(30, 30)) == 1
+    assert pages.page_count(Measure()) == 0
+    # One block of text: 2400 characters start the second page before 31 lines do.
+    assert pages.page_count(Measure(1, 2399)) == 1
+    assert pages.page_count(Measure(1, 2400)) == 2
+
+
+def epub(path, documents, spine=None):
+    names = [f"file {n}.xhtml" for n in range(len(documents))]
+    items = "".join(f'<item id="f{n}" href="{name.replace(" ", "%20")}"/>' for n, name in enumerate(names))
+    items += '<item id="css" href="stylesheet.css"/>'
+    refs = "".join(f'<itemref idref="f{n}"/>' for n in (spine or range(len(documents))))
+    with zipfile.ZipFile(path, "w") as z:
+        z.writestr(
+            "META-INF/container.xml",
+            '<container xmlns="urn:oasis:names:tc:opendocument:xmlns:container"><rootfiles>'
+            '<rootfile full-path="OEBPS/content.opf"/></rootfiles></container>',
+        )
+        z.writestr(
+            "OEBPS/content.opf",
+            f'<package xmlns="http://www.idpf.org/2007/opf"><metadata/><manifest>{items}</manifest>'
+            f"<spine>{refs}</spine></package>",
+        )
+        z.writestr("OEBPS/stylesheet.css", "p { margin: 0 }")
+        for name, document in zip(names, documents, strict=True):
+            z.writestr(f"OEBPS/{name}", document)
+    return path
+
+
+def test_an_epub_is_counted_from_the_documents_of_its_spine(tmp_path):
+    chapter = "<html><head><title>T</title></head><body>" + "<p>x</p>" * 31 + "</body></html>"
+    book = epub(tmp_path / "book.epub", [chapter, "<html><body><p>Not in the spine</p></body></html>", chapter], [2, 0])
+    assert spine_documents(book) == [chapter, chapter]
+    # 62 paragraphs of one character.
+    assert pages.epub_pages(book) == 2
+    assert pages.epub_pages(epub(tmp_path / "empty.epub", ["<html><body><img src='a.png'/></body></html>"])) == 0
+
+
+def test_a_file_that_is_not_an_epub_cannot_be_counted(tmp_path):
+    path = tmp_path / "bad.epub"
+    path.write_bytes(b"not a zip")
+    with pytest.raises(EpubError):
+        pages.epub_pages(path)
+    with zipfile.ZipFile(path, "w") as z:
+        z.writestr("META-INF/container.xml", "<container/>")
+    with pytest.raises(EpubError):
+        pages.epub_pages(path)