#!/usr/bin/env python3 """Snapshot and replay four Polish Open AGH chemistry textbooks.""" from __future__ import annotations import argparse import ast from collections import Counter, defaultdict from concurrent.futures import ThreadPoolExecutor, as_completed from datetime import datetime, timezone import gzip import hashlib import importlib.metadata import io import json from pathlib import Path import platform import pprint import re import shutil import threading import time import unicodedata import xml.etree.ElementTree as ET import zipfile from bs4 import BeautifulSoup, Comment, NavigableString import requests BASE = "https://epodreczniki.open.agh.edu.pl" BOOK_IDS = (29, 1394, 37, 1893) SOURCE = "open_agh_chemistry_pl" OWN_REPO = "PiotrSty/open-agh-chemistry-pl" TARGET = "SlayerLab/polish-dynaword" LICENSE = "CC-BY-SA-4.0" FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"] LOCK = threading.Lock() NEXT = 0.0 def now(): return datetime.now(timezone.utc).isoformat() def sha(value): if not isinstance(value, bytes): value = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode() return hashlib.sha256(value).hexdigest() def save(path, value): path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(value, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8") def read(path): return json.loads(path.read_text(encoding="utf-8")) def lines(path, rows): path.parent.mkdir(parents=True, exist_ok=True) path.write_text("".join(json.dumps(r, ensure_ascii=False, sort_keys=True) + "\n" for r in rows), encoding="utf-8") def read_lines(path): return [json.loads(s) for s in path.read_text(encoding="utf-8").splitlines() if s] def get(url): global NEXT for attempt in range(5): with LOCK: wait = max(0, NEXT - time.monotonic()) NEXT = max(time.monotonic(), NEXT) + 0.4 time.sleep(wait) response = requests.get(url, timeout=(20, 100), headers={ "User-Agent": "OpenAGHTextResearch/1.0 (PiotrSty; four-book text corpus)", "Accept-Language": "pl"}) if response.status_code not in (429, 500, 502, 503, 504): response.raise_for_status() return response time.sleep(2 ** attempt) response.raise_for_status() def walk(items, chapter=""): for item in items: module = item.get("_embedded", {}).get("module") if module: yield module, chapter else: yield from walk(item.get("children", []), item.get("title", chapter)) def license_from_epub(payload, book_id): with zipfile.ZipFile(io.BytesIO(payload)) as archive: rights = archive.read("OEBPS/main.xhtml") document = ET.fromstring(rights) text = " ".join(" ".join(document.itertext()).split()) links = [n.attrib["href"] for n in document.iter() if "href" in n.attrib] if not any("creativecommons.org/licenses/by-sa/4.0" in link for link in links): raise ValueError("Missing book-specific CC BY-SA 4.0 link") if "Na tych samych warunkach" not in text or f"/handbook/{book_id}" not in text: raise ValueError("Book-specific rights/identity evidence missing") if re.search(r"(?i)licenses/by-nc|CC\s*BY[- ]NC", text + " ".join(links)): raise ValueError("Noncommercial marker in rights page") return {"license": LICENSE, "epub_url": f"{BASE}/rpc/preview/handbooks/{book_id}/epub/light", "epub_sha256": sha(payload), "rights_xhtml": rights.decode("utf-8"), "rights_sha256": sha(rights), "rights_text": text, "links": links, "observed_at": now()} def discover(out): from huggingface_hub import HfApi if (out / "inventory.json").exists(): raise ValueError("Inventory already exists; use a fresh output for a new snapshot") out.mkdir(parents=True, exist_ok=True) api = HfApi(token=False) target = api.dataset_info(TARGET) registry = get(f"https://huggingface.co/datasets/{TARGET}/resolve/{target.sha}/src/sources.py").content.decode("utf-8") discussions = [{"num": d.num, "title": d.title, "status": d.status} for d in api.get_repo_discussions(TARGET, repo_type="dataset")] if SOURCE in registry or any(re.search(r"(?i)\bAGH\b", d["title"]) for d in discussions): raise ValueError("AGH registration/proposal found; inspect before creating another") (out / "target_sources.py").write_text(registry, encoding="utf-8") save(out / "target_audit.json", {"repository": TARGET, "revision": target.sha, "observed_at": now(), "registry_sha256": sha(registry.encode()), "files": [s.rfilename for s in target.siblings], "discussions": discussions, "cross_source_dedup": "pending; registry and title checks do not establish text novelty"}) books = [] for book_id in BOOK_IDS: response = get(f"{BASE}/rest/handbooks/{book_id}?lang=auto") book = response.json() meta = book["_embedded"]["metadata"] if book["id"] != book_id or meta["in_language"] != "pl" or meta.get("private_token") or meta.get("ai_based"): raise ValueError("Unexpected/private/non-Polish/AI-marked edition") item_response = get(book["_links"]["items"]["href"]) occurrences = [] for module, chapter in walk(item_response.json()): embedded = module["_embedded"] occurrences.append({"module_id": module["id"], "title": module["title"], "chapter": chapter, "revision": embedded["revision"]["version"], "authors": [" ".join([a["firstname"], a["lastname"]]) for a in embedded["authors"]], "preview_url": next(f["_links"]["preview"]["href"] for f in embedded["formats"] if f["type"] == "html"), "module_url": module["_links"]["self"]["href"], "reader_url": f"{BASE}/handbook/{book_id}/module/{module['id']}/reader"}) rights_url = next(f["_links"]["preview"]["href"] for f in book["_embedded"]["formats"] if f["type"] == "epub/light") rights = license_from_epub(get(rights_url).content, book_id) books.append({"id": book_id, "title": book["title"], "url": f"{BASE}/handbook/{book_id}", "observed_at": now(), "metadata_sha256": sha(response.content), "items_sha256": sha(item_response.content), "metadata": {k: meta.get(k) for k in ("publisher", "publish_time", "update_time", "isbn", "reviewers", "in_language", "ai_based")}, "license_evidence": rights, "occurrences": occurrences}) save(out / "inventory_progress.json", books) print(f"Verified book {book_id}: {len(occurrences)} modules; {LICENSE}", flush=True) save(out / "inventory.json", books) def module_map(books): modules = {} for book in books: for item in book["occurrences"]: mid = item["module_id"] if mid in modules and any(modules[mid][key] != item[key] for key in ("title", "revision", "authors")): raise ValueError("Shared module has inconsistent identity/version/authors") modules[mid] = item return modules def fetch_one(out, module): path = out / "cache" / f"{module['module_id']}.json.gz" if path.exists(): row = json.loads(gzip.decompress(path.read_bytes())) if row["revision"] != module["revision"] or row["html_sha256"] != sha(row["html"].encode()): raise ValueError("Stale or corrupt module cache") return row response = get(module["preview_url"]) html = response.content.decode("utf-8") current = get(module["module_url"]).json() if current["_embedded"]["revision"]["version"] != module["revision"] or current["title"] != module["title"]: raise ValueError("Module changed since inventory; acquire a new snapshot") row = {"module_id": module["module_id"], "revision": module["revision"], "preview_url": module["preview_url"], "observed_at": now(), "html": html, "html_sha256": sha(html.encode()), "response_sha256": sha(response.content)} path.parent.mkdir(parents=True, exist_ok=True) path.write_bytes(gzip.compress(json.dumps(row, ensure_ascii=False, sort_keys=True).encode(), mtime=0)) return row def fetch(out): modules = module_map(read(out / "inventory.json")) rows, failures = [], [] with ThreadPoolExecutor(max_workers=3) as pool: futures = {pool.submit(fetch_one, out, module): mid for mid, module in sorted(modules.items())} for count, future in enumerate(as_completed(futures), 1): try: rows.append(future.result()) except Exception as error: failures.append({"module_id": futures[future], "error": str(error)}) if count % 25 == 0 or count == len(futures): print(f"Fetched {count}/{len(futures)}; failures={len(failures)}", flush=True) save(out / "fetch_failures.json", failures) if failures: raise ValueError("Fetch incomplete; inspect failures then rerun to resume") lines(out / "modules.jsonl", sorted(rows, key=lambda r: r["module_id"])) def normalize(text): text = unicodedata.normalize("NFKC", text).replace("\u00ad", "").replace("\u200b", "") text = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]", "", text) return re.sub(r"\n{3,}", "\n\n", "\n".join(re.sub(r"[ \t\xa0]+", " ", s).strip() for s in text.splitlines())).strip() def text_key(text): return " ".join(normalize(text).casefold().split()) def extract(html): soup = BeautifulSoup(html, "html.parser") if soup.find(["html", "body"]) or soup.select_one('#root, form[action*="login"]'): raise ValueError("Expected module fragment, received a shell/login document") changes = Counter() for node in list(soup.select("script, style, nav, figure, img, video, audio, iframe, svg")): if node.parent is not None: node.decompose() changes["media_or_ui_removed"] += 1 for comment in soup.find_all(string=lambda n: isinstance(n, Comment)): comment.extract() # Collapse physical source wrapping before inserting semantic paragraph breaks. for node in list(soup.find_all(string=True)): node.replace_with(NavigableString(re.sub(r"\s+", " ", str(node)))) for node in list(soup.find_all(["sub", "sup"])): node.replace_with(NavigableString(("_" if node.name == "sub" else "^") + "{" + node.get_text() + "}")) for node in soup.find_all(["br", "hr"]): node.replace_with(NavigableString("\n")) for node in soup.find_all(["td", "th"]): node.append(NavigableString(" | ")) for node in soup.find_all(["p", "div", "section", "h1", "h2", "h3", "h4", "h5", "li", "table", "tr", "blockquote"]): node.insert_before(NavigableString("\n\n")) node.insert_after(NavigableString("\n\n")) text = normalize(soup.get_text()) for name, pattern in ( ("email", r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b"), ("labelled_phone", r"(?i)(?:\btelefon|\btel\.)\s*:?\s*(?:\+48\s*)?\d(?:[ .-]?\d){8}\b"), ): text, count = re.subn(pattern, "[REDACTED:" + name.upper() + "]", text) changes[name] += count changes["unbalanced_math_delimiters"] = int(text.count(r"\(") != text.count(r"\)") or text.count(r"\[") != text.count(r"\]")) return text, dict(changes) def near_dedup(rows): from datasketch import MinHash, MinHashLSH index, features, kept, dropped = MinHashLSH(threshold=0.8, num_perm=128), {}, [], [] for row in rows: words = re.findall(r"\w+", text_key(row["text"])) shingles = {" ".join(words[i:i + 5]).encode() for i in range(max(0, len(words) - 4))} signature = MinHash(num_perm=128, seed=1) if not shingles: kept.append(row) continue signature.update_batch(sorted(shingles)) for other in sorted(index.query(signature)): score = len(shingles & features[other]) / len(shingles | features[other]) if score >= 0.9: dropped.append({"id": row["id"], "duplicate_of": other, "jaccard": score}) break else: kept.append(row) features[row["id"]] = shingles index.insert(row["id"], signature) return kept, dropped def registry(base): tree = ast.parse(base) node = next(n.value for n in tree.body if isinstance(n, ast.Assign) and any(isinstance(t, ast.Name) and t.id == "SOURCES" for t in n.targets)) if SOURCE in ast.literal_eval(node): raise ValueError("Source already registered") entry = {"file_key": SOURCE, "pretty": "Open AGH - four Polish chemistry textbooks", "license": LICENSE, "license_spdx": LICENSE, "traceable": "Each contributed Polish edition includes explicit CC BY-SA 4.0 terms in its preserved official EPUB rights page. Authors, AGH attribution, original URLs and changes are preserved.", "upstream": BASE, "provenance": "Pinned PiotrSty/open-agh-chemistry-pl source snapshot; public AGH module previews with observed revision identifiers and per-module author attribution.", "domain": "educational/chemistry/materials", "created": "2018-2024 (book publication metadata proxy)", "is_ocr": False, "custom_datasheet": True} offset = sum(len(s) for s in base.splitlines(keepends=True)[:node.lineno - 1]) + node.col_offset + 1 return base[:offset] + "\n " + repr(SOURCE) + ": " + pprint.pformat(entry, width=96, sort_dicts=False).replace("\n", "\n ") + "," + base[offset:] def build(out): import pyarrow as pa import pyarrow.parquet as pq import tiktoken from langid.langid import LanguageIdentifier, model started = now() code_digest = sha(Path(__file__).read_bytes()) books = read(out / "inventory.json") if {b["id"] for b in books} != set(BOOK_IDS): raise ValueError("Four-book allowlist mismatch") modules = module_map(books) snapshot = read_lines(out / "modules.jsonl") if {r["module_id"] for r in snapshot} != set(modules) or len(snapshot) != len(modules): raise ValueError("Incomplete/duplicated module snapshot") memberships = defaultdict(list) for book in books: for occurrence in book["occurrences"]: memberships[occurrence["module_id"]].append({"book_id": book["id"], "book_title": book["title"], "book_url": book["url"], "publish_time": book["metadata"]["publish_time"], "isbn": book["metadata"]["isbn"], "reader_url": occurrence["reader_url"], "chapter": occurrence["chapter"]}) encoder = tiktoken.get_encoding("cl100k_base") lang = LanguageIdentifier.from_modelstring(model, norm_probs=True) lang.set_languages(["pl", "en", "de", "cs", "sk", "uk", "ru", "fr"]) rows, sidecars, decisions, seen = [], [], {}, {} totals = Counter() added = min(r["observed_at"][:10] for r in snapshot) for raw in snapshot: mid = raw["module_id"] module = modules[mid] if raw["html_sha256"] != sha(raw["html"].encode()) or raw["revision"] != module["revision"]: raise ValueError("Module checksum/revision mismatch") body, operations = extract(raw["html"]) totals.update(operations) reason = "" if re.match(r"(?i)^(informacj[ae]\s+o\s+e-podr|bibliografia|spis\s)", module["title"]): reason = "frontmatter_or_bibliography" elif len(body) < 200: reason = "too_short" elif operations["unbalanced_math_delimiters"]: reason = "unbalanced_math" elif len(re.findall(r"[a-zA-Z\u00c0-\u024f]", body)) / len(body) < 0.35: reason = "low_letter_ratio" language, confidence = lang.classify(body[:12000]) if body else ("unknown", 0.0) if not reason and language != "pl" and confidence >= 0.99: reason = "non_polish" if not module["authors"]: reason = "missing_authorship" key = text_key(body) duplicate = seen.get(key) if not reason and duplicate: reason = "normalized_duplicate" row_id = SOURCE + "_" + str(mid) decisions[mid] = {"module_id": mid, "book_ids": [b["book_id"] for b in memberships[mid]], "selected": not bool(reason), "reason": reason or "include", "duplicate_of": duplicate, "html_sha256": raw["html_sha256"]} if reason: continue seen[key] = row_id text = normalize(module["title"]) + "\n\n" + body rows.append({"id": row_id, "text": text, "source": SOURCE, "added": added, "created": min(b["publish_time"][:10] for b in memberships[mid]), "token_count": len(encoder.encode_ordinary(text)), "license": LICENSE, "author": "; ".join(module["authors"])}) sidecars.append({"id": row_id, "module_id": mid, "title": module["title"], "observed_revision": raw["revision"], "observed_at": raw["observed_at"], "url": memberships[mid][0]["reader_url"], "preview_url": raw["preview_url"], "memberships": memberships[mid], "authors": module["authors"], "publisher": "AGH University of Krakow", "original_notice": "Wersja oryginalna e-podr\u0119cznika dost\u0119pna na stronie: " + memberships[mid][0]["book_url"], "license": LICENSE, "license_url": "https://creativecommons.org/licenses/by-sa/4.0/deed.pl", "created_semantics": "book publication metadata proxy, not module authorship date", "text_sha256": sha(text.encode()), "html_sha256": raw["html_sha256"], "transformations": operations, "language": language, "language_confidence": float(confidence)}) rows, removed = near_dedup(rows) for duplicate in removed: mid = int(duplicate["id"].rsplit("_", 1)[1]) decisions[mid].update(selected=False, reason="near_duplicate", duplicate_of=duplicate["duplicate_of"], jaccard=duplicate["jaccard"]) ids = {r["id"] for r in rows} sidecars = [s for s in sidecars if s["id"] in ids] counts = Counter(b["book_id"] for s in sidecars for b in s["memberships"]) if set(counts) != set(BOOK_IDS): raise ValueError("An approved book has no retained text") root = out / "hf_repo" (root / "data").mkdir(parents=True, exist_ok=True) artifacts = root / "artifacts" schema = pa.schema([(name, pa.int64() if name == "token_count" else pa.string()) for name in FIELDS]) pq.write_table(pa.Table.from_pylist(rows, schema=schema), root / "data/train-00000-of-00001.parquet", compression="zstd", row_group_size=128) lines(artifacts / "attribution.jsonl", sidecars) lines(artifacts / "decisions.jsonl", sorted(decisions.values(), key=lambda r: r["module_id"])) samples = {} for book_id in BOOK_IDS: book_ids = {s["id"] for s in sidecars if any(b["book_id"] == book_id for b in s["memberships"])} for row in sorted((r for r in rows if r["id"] in book_ids), key=lambda r: sha(("sample:" + r["id"]).encode()))[:3]: samples[row["id"]] = row lines(artifacts / "sample.jsonl", list(samples.values())) save(artifacts / "books.json", books) shutil.copy2(out / "target_audit.json", artifacts / "target_audit.json") (artifacts / "modules.jsonl.gz").write_bytes(gzip.compress((out / "modules.jsonl").read_bytes(), mtime=0)) qa = {"extraction_operations": dict(totals), "normalized_exact_dedup": True, "module_identity_dedup": True, "near_dedup": {"algorithm": "seeded MinHashLSH .8 candidates and exact 5-word-shingle Jaccard >=.9", "seed": 1, "num_perm": 128, "removed": len(removed), "limitation": "probabilistic retrieval can miss pairs"}, "cross_source_exact_dedup_completed": False, "cross_source_near_dedup_completed": False, "benchmark_overlap_check": "pending", "limitations": ["figures/media omitted; prose can reference missing figures", "LaTeX preserved, not equation correctness verification", "tables flattened into rows", "email/labelled-phone patterns are not complete PII scrubbing; author attribution retained", "published source snapshots are not de-identified", "API revision is an observed label; source content identity is its snapshot hash"]} save(artifacts / "qa.json", qa) stats = {"book_count": len(books), "module_occurrences": sum(len(b["occurrences"]) for b in books), "unique_modules": len(snapshot), "kept": len(rows), "tokens": sum(r["token_count"] for r in rows), "chars": sum(len(r["text"]) for r in rows), "by_book": dict(counts), "drop_by_reason": dict(Counter(d["reason"] for d in decisions.values() if not d["selected"])), "tokenizer": "cl100k_base", "sample_count": len(samples), "license": LICENSE, "added": added} save(artifacts / "stats.json", stats) (root / "src").mkdir(exist_ok=True) for name in ("build_open_agh_pl.py", "publish_open_agh_pl.py", "test_build_open_agh_pl.py", "test_open_agh_contribution.py", "open_agh_requirements.txt"): shutil.copy2(Path(__file__).with_name(name), root / "src" / name) save(artifacts / "run.json", {"started_at": started, "finished_at": now(), "actor_id": "agent:codex", "requested_by": "hf:PiotrSty", "code_sha256": code_digest, "input_sha256": sha((out / "modules.jsonl").read_bytes()), "python": platform.python_version(), "packages": {n: importlib.metadata.version(n) for n in ("beautifulsoup4", "requests", "pyarrow", "tiktoken", "langid", "datasketch")}}) save(artifacts / "checksums.json", {p.relative_to(root).as_posix(): sha(p.read_bytes()) for p in sorted(root.rglob("*")) if p.is_file() and p.name not in ("README.md", "NOTICE.md", "ontology.json", "checksums.json") and "__pycache__" not in p.parts}) print(json.dumps(stats, ensure_ascii=False, indent=2), flush=True) if __name__ == "__main__": parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--output", type=Path, required=True) parser.add_argument("command", choices=["discover", "fetch", "build"]) args = parser.parse_args() globals()[args.command](args.output)