wolne_lektury: move the containment code to src/shingle_containment.py

The 1000_novels dedup (v2#45) uses the same 5-word-shingle containment, so the code
moves to a module both filters import, with its unit tests in
src/test_shingle_containment.py. It adds Match.cover, the share of a document's
shingles held by any reference (the union over Wolne Lektury tomes).

No output change: rebuilding from the v0.2.5 Parquet and stats gives byte-identical
wolne_lektury.parquet, stats.json and eltec_pairs.tsv.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/clean_wolne_lektury.py

@@ -8,7 +8,8 @@ licence. Wolne Lektury splits long novels into tomes, so the test is containment
   score = |S(wl) & S(novel)| / |S(wl)|
 
 S() is the set of 5-word shingles over NFKC-casefolded \\w+ tokens (the tokenisation of the
-repo's near_dedup), and `novel` is the ELTeC novel sharing the most shingles with the WL doc.
+repo's near_dedup), and `novel` is the ELTeC novel sharing the most shingles with the WL doc;
+the shingling and scoring code is in src/shingle_containment.py.
 A trailing Wolne Lektury footer is cut from WL text before scoring (the #45 measurement's rule);
 the released text is not changed. Docs scoring >= DROP_AT are dropped. Docs scoring
 >= REPORT_AT but below DROP_AT are only partly in an ELTeC novel; they are kept and listed.
@@ -25,17 +26,15 @@ import csv
 import hashlib
 import json
 import os
-import re
-import unicodedata
 from collections import Counter
-from functools import lru_cache
 from pathlib import Path
 
-import numpy as np
 import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.parquet as pq
 
+from shingle_containment import best_containment, strip_wl_footer
+
 SOURCE = "wolne_lektury"
 ROOT = Path(__file__).resolve().parents[1]
 DATA = ROOT / "data" / SOURCE
@@ -43,66 +42,11 @@ ELTEC = ROOT / "data" / "eltec_pol" / "eltec_pol.parquet"
 INPUT_SHA256 = "5833c25db296f2479b3c09745ebedd550b2425dd6ebaf021f0095e684a0221a1"  # v0.2.1-v0.2.5
 ELTEC_SHA256 = "ba40061741dff11165149f6c2cf3d5526e1b6c759e7ce1e03ccc164d58838325"  # v0.2.1-v0.2.5
 PAIRS = f"{SOURCE}.eltec_pairs.tsv"
-K = 5
 # Thresholds sit in empty stretches of the v0.2.5 score distribution: no doc scores between
 # 0.7588 and 0.9636 (above: 63 docs, the novels; below: two tomes of an abridged ELTeC
 # Trędowata), and none between 0.2203 and 0.4267 (below: poems quoted in a novel).
 DROP_AT = 0.9
 REPORT_AT = 0.3
-WORD = re.compile(r"\w+")
-# Odd 64-bit multipliers that mix the K word hashes of a shingle in order.
-MULT = np.array([0x9E3779B97F4A7C15, 0xC2B2AE3D27D4EB4F, 0x165667B19E3779F9,
-                 0xD6E8FEB86659FD93, 0xFF51AFD7ED558CCD], dtype=np.uint64)
-
-
-def strip_wl_footer(text: str) -> str:
-    """Text before a trailing "-----" footer that names wolnelektury, else the text unchanged."""
-    j = text.rfind("\n-----")
-    if j >= 0 and len(text) - j < 5000 and "wolnelektury" in text[j:].lower():
-        return text[:j]
-    return text
-
-
-@lru_cache(maxsize=None)
-def _word_hash(word: str) -> int:
-    # blake2b, not hash(): str hashing is salted per process, and the scores must be reproducible.
-    return int.from_bytes(hashlib.blake2b(word.encode("utf-8"), digest_size=8).digest(), "little")
-
-
-def shingles(text: str) -> np.ndarray:
-    """Sorted unique uint64 hashes of the text's K-word shingles."""
-    words = WORD.findall(unicodedata.normalize("NFKC", text).casefold())
-    n = len(words) - K + 1
-    if n <= 0:
-        return np.empty(0, np.uint64)
-    h = np.fromiter((_word_hash(w) for w in words), dtype=np.uint64, count=len(words))
-    s = np.zeros(n, np.uint64)
-    for i in range(K):
-        s += h[i:i + n] * MULT[i]
-    s ^= s >> np.uint64(31)
-    return np.unique(s)
-
-
-def best_containment(docs: list[str], novels: list[str]) -> list[tuple[int, float]]:
-    """For each doc: (index of the novel holding most of its shingles, share held), (-1, 0.0) if none."""
-    sets = [shingles(text) for text in novels]
-    hashes = np.concatenate(sets)
-    owner = np.concatenate([np.full(len(s), i, np.int32) for i, s in enumerate(sets)])
-    order = np.argsort(hashes, kind="stable")
-    hashes, owner = hashes[order], owner[order]
-    out = []
-    for text in docs:
-        a = shingles(text)
-        if not len(a):
-            out.append((-1, 0.0))
-            continue
-        lo, hi = np.searchsorted(hashes, a, "left"), np.searchsorted(hashes, a, "right")
-        lens = hi - lo
-        idx = np.repeat(lo - np.cumsum(lens) + lens, lens) + np.arange(lens.sum())
-        shared = np.bincount(owner[idx], minlength=len(novels))
-        best = int(shared.argmax())
-        out.append((best, shared[best] / len(a)) if shared[best] else (-1, 0.0))
-    return out
 
 
 def wl_title(text: str) -> str:

src/shingle_containment.py

@@ -0,0 +1,94 @@
+"""Shingle containment between documents and a set of reference documents.
+
+Shared by the cross-source dedup filters (src/clean_wolne_lektury.py, src/clean_1000_novels.py).
+S() is the set of K-word shingles over NFKC-casefolded \\w+ tokens, the tokenisation of the repo's
+near_dedup. Containment, not Jaccard: a document is scored by the share of its own shingles that
+a reference holds, because Wolne Lektury splits long novels into tomes.
+"""
+from __future__ import annotations
+
+import hashlib
+import re
+import unicodedata
+from functools import lru_cache
+from typing import NamedTuple
+
+import numpy as np
+
+K = 5
+WORD = re.compile(r"\w+")
+# Odd 64-bit multipliers that mix the K word hashes of a shingle in order.
+MULT = np.array([0x9E3779B97F4A7C15, 0xC2B2AE3D27D4EB4F, 0x165667B19E3779F9,
+                 0xD6E8FEB86659FD93, 0xFF51AFD7ED558CCD], dtype=np.uint64)
+
+
+def strip_wl_footer(text: str) -> str:
+    """Text before a trailing "-----" footer that names wolnelektury, else the text unchanged."""
+    j = text.rfind("\n-----")
+    if j >= 0 and len(text) - j < 5000 and "wolnelektury" in text[j:].lower():
+        return text[:j]
+    return text
+
+
+@lru_cache(maxsize=None)
+def _word_hash(word: str) -> int:
+    # blake2b, not hash(): str hashing is salted per process, and the scores must be reproducible.
+    return int.from_bytes(hashlib.blake2b(word.encode("utf-8"), digest_size=8).digest(), "little")
+
+
+def shingles(text: str) -> np.ndarray:
+    """Sorted unique uint64 hashes of the text's K-word shingles."""
+    words = WORD.findall(unicodedata.normalize("NFKC", text).casefold())
+    n = len(words) - K + 1
+    if n <= 0:
+        return np.empty(0, np.uint64)
+    h = np.fromiter((_word_hash(w) for w in words), dtype=np.uint64, count=len(words))
+    s = np.zeros(n, np.uint64)
+    for i in range(K):
+        s += h[i:i + n] * MULT[i]
+    s ^= s >> np.uint64(31)
+    return np.unique(s)
+
+
+class Match(NamedTuple):
+    """How much of one document's shingle set the references hold."""
+    shingles: int      # unique shingles in the document
+    covered: int       # of those, how many occur in at least one reference
+    refs: np.ndarray   # indices of the references sharing at least one shingle, ascending
+    shared: np.ndarray  # shingles shared with each of those references
+
+    @property
+    def cover(self) -> float:
+        """Share of the document's shingles found in any reference (the union of the references)."""
+        return self.covered / self.shingles if self.shingles else 0.0
+
+    def best(self) -> tuple[int, float]:
+        """(index of the reference holding most shingles, share it holds); (-1, 0.0) if none."""
+        if not len(self.refs):
+            return -1, 0.0
+        i = int(self.shared.argmax())  # ties go to the lowest reference index
+        return int(self.refs[i]), self.shared[i] / self.shingles
+
+
+def containment(docs: list[str], refs: list[str]) -> list[Match]:
+    """Match every doc against all refs at once."""
+    sets = [shingles(text) for text in refs] or [np.empty(0, np.uint64)]
+    hashes = np.concatenate(sets)
+    owner = np.concatenate([np.full(len(s), i, np.int32) for i, s in enumerate(sets)])
+    order = np.argsort(hashes, kind="stable")
+    hashes, owner = hashes[order], owner[order]
+    out = []
+    for text in docs:
+        a = shingles(text)
+        lo, hi = np.searchsorted(hashes, a, "left"), np.searchsorted(hashes, a, "right")
+        lens = hi - lo
+        # Every (doc shingle, ref) hit: each ref's set is unique, so a shingle counts once per ref.
+        idx = np.repeat(lo - np.cumsum(lens) + lens, lens) + np.arange(lens.sum())
+        ref_ids, shared = np.unique(owner[idx], return_counts=True)
+        out.append(Match(len(a), int((lens > 0).sum()), ref_ids, shared))
+    return out
+
+
+def best_containment(docs: list[str], refs: list[str]) -> list[tuple[int, float]]:
+    """For each doc: (index of the ref holding most of its shingles, share held), (-1, 0.0) if none."""
+    return [m.best() for m in containment(docs, refs)]

src/test_shingle_containment.py

@@ -0,0 +1,52 @@
+"""Unit tests for the shared cross-source containment code (src/shingle_containment.py)."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from shingle_containment import best_containment, containment, shingles, strip_wl_footer
+
+NOVEL = " ".join(f"w{i}" for i in range(400))
+OTHER = " ".join(f"x{i}" for i in range(400))
+
+
+def test_shingles_are_reproducible_across_processes():
+    # Fixed values: a salted hash() would change them on every interpreter start.
+    assert shingles("Ala ma kota, a kot ma Alę.").tolist() == [
+        1095117514565903941, 11979537242062189157, 12971353317152582320]
+    assert shingles("ALA  ma\nkota, a kot ma alę").tolist() == shingles("Ala ma kota, a kot ma Alę.").tolist()
+    assert shingles("a b c d e").tolist() != shingles("e d c b a").tolist()
+    assert len(shingles("a b c d")) == 0
+
+
+def test_strip_wl_footer_cuts_only_a_trailing_wolne_lektury_footer():
+    footer = "\n-----\nTa lektura pochodzi ze strony wolnelektury.pl.\n"
+    assert strip_wl_footer("Tekst." + footer) == "Tekst."
+    assert strip_wl_footer("Tekst.\n-----\nKoniec.") == "Tekst.\n-----\nKoniec."
+    assert strip_wl_footer("Tekst." + footer + "x" * 5000) == "Tekst." + footer + "x" * 5000
+
+
+def test_best_containment_finds_tomes_and_partial_copies():
+    words = NOVEL.split()
+    tome = " ".join(words[100:300]).upper()
+    half = " ".join(words[:100] + OTHER.split()[:100])
+    unrelated = " ".join(f"y{i}" for i in range(50))
+    novels = [" ".join(OTHER.split()[:50]), NOVEL]
+    scores = best_containment([tome, half, unrelated, "za krótki", NOVEL], novels)
+    assert scores[0] == (1, 1.0)
+    assert scores[1][0] == 1 and 0.45 < scores[1][1] < 0.55  # novel 1 holds more than novel 0
+    assert scores[2] == scores[3] == (-1, 0.0)
+    assert scores[4] == (1, 1.0)
+
+
+def test_cover_is_the_union_of_the_references():
+    words = NOVEL.split()
+    tomes = [" ".join(words[:200]), " ".join(words[196:])]  # two tomes, no shingle in both
+    whole, empty = containment([NOVEL, ""], tomes)
+    assert whole.shingles == whole.covered == 396 and whole.cover == 1.0
+    assert whole.refs.tolist() == [0, 1] and whole.shared.tolist() == [196, 200]
+    assert whole.best() == (1, 200 / 396)  # no single tome holds half of it
+    assert (empty.shingles, empty.covered, empty.cover, empty.best()) == (0, 0, 0.0, (-1, 0.0))
+    [alone] = containment([NOVEL], [])
+    assert (alone.covered, alone.cover, alone.best()) == (0, 0.0, (-1, 0.0))

src/test_wolne_lektury_contract.py

@@ -13,45 +13,13 @@ import pytest
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 
-from clean_wolne_lektury import (DATA, DROP_AT, ELTEC, ELTEC_SHA256, PAIRS, REPORT_AT,
-                                 best_containment, build, shingles, strip_wl_footer, wl_title)
+from clean_wolne_lektury import (DATA, DROP_AT, ELTEC, ELTEC_SHA256, PAIRS, REPORT_AT, build,
+                                 wl_title)
 
-NOVEL = " ".join(f"w{i}" for i in range(400))
-OTHER = " ".join(f"x{i}" for i in range(400))
 # Hand-checked: only part of each is in its ELTeC novel, so they stay (see the findings entry).
 PARTIAL_IDS = {"wolne_lektury_2375475", "wolne_lektury_2375476", "wolne_lektury_2376242"}
 
 
-def test_shingles_are_reproducible_across_processes():
-    # Fixed values: a salted hash() would change them on every interpreter start.
-    assert shingles("Ala ma kota, a kot ma Alę.").tolist() == [
-        1095117514565903941, 11979537242062189157, 12971353317152582320]
-    assert shingles("ALA  ma\nkota, a kot ma alę").tolist() == shingles("Ala ma kota, a kot ma Alę.").tolist()
-    assert shingles("a b c d e").tolist() != shingles("e d c b a").tolist()
-    assert len(shingles("a b c d")) == 0
-
-
-def test_containment_finds_tomes_and_partial_copies():
-    words = NOVEL.split()
-    tome = " ".join(words[100:300]).upper()
-    half = " ".join(words[:100] + OTHER.split()[:100])
-    unrelated = " ".join(f"y{i}" for i in range(50))
-    novels = [" ".join(OTHER.split()[:50]), NOVEL]
-    scores = best_containment([tome, half, unrelated, "za krótki", NOVEL], novels)
-    assert scores[0] == (1, 1.0)
-    assert scores[1][0] == 1 and 0.45 < scores[1][1] < 0.55  # novel 1 holds more than novel 0
-    assert scores[2] == scores[3] == (-1, 0.0)
-    assert scores[4] == (1, 1.0)
-    assert REPORT_AT < scores[1][1] < DROP_AT  # a half copy is listed and kept
-
-
-def test_strip_wl_footer_cuts_only_a_trailing_wolne_lektury_footer():
-    footer = "\n-----\nTa lektura pochodzi ze strony wolnelektury.pl.\n"
-    assert strip_wl_footer("Tekst." + footer) == "Tekst."
-    assert strip_wl_footer("Tekst.\n-----\nKoniec.") == "Tekst.\n-----\nKoniec."
-    assert strip_wl_footer("Tekst." + footer + "x" * 5000) == "Tekst." + footer + "x" * 5000
-
-
 def test_wl_title_is_the_first_two_nonempty_lines():
     assert wl_title("Stefan Żeromski\n\nDzieje grzechu\n\nISBN 1\n\nText") == "Stefan Żeromski / Dzieje grzechu"