| |
| """Build an auditable pilot from Polish CC BY-SA books in the ROCK repository.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import ast |
| from collections import Counter |
| from datetime import datetime, timezone |
| import hashlib |
| import json |
| import os |
| from pathlib import Path |
| import pprint |
| import re |
| import shutil |
| import subprocess |
| import sys |
| from difflib import SequenceMatcher |
| import unicodedata |
|
|
| import requests |
|
|
| SOURCE = "rock_pollub_pl" |
| OWN_REPO = "PiotrSty/rock-pollub-pl-books" |
| TARGET = "SlayerLab/polish-dynaword" |
| COLLECTION_ID = "a42db069-319d-4d51-88d1-490ee7e6bad8" |
| API = "https://rock.pollub.pl/server/api" |
| COLLECTION_URL = "https://rock.pollub.pl/collections/a42db069-319d-4d51-88d1-490ee7e6bad8" |
| POLICY_URL = "https://wpl.pollub.pl/pl/i/Polityka-publikacyjna/20" |
| LICENSE = "CC-BY-SA-4.0" |
| LICENSE_URL = "https://creativecommons.org/licenses/by-sa/4.0/" |
| FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"] |
| UA = "ROCKPollubCorpusResearch/0.1 (PiotrSty; open research pilot)" |
| BOOK_SUBTYPES = {"Monograph", "Handbook", "Workbook"} |
| MAX_PDF_BYTES = 50 * 1024 * 1024 |
| EMAIL_RE = re.compile(r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b") |
| PHONE_RE = re.compile(r"(?i)(?:\btelefon|\btel\.)\s*:?[ \t]*(?:\+48[ \t]*)?\d(?:[ .-]?\d){8}\b") |
|
|
|
|
| def now(): |
| return datetime.now(timezone.utc).isoformat() |
|
|
|
|
| def digest(value): |
| if not isinstance(value, bytes): |
| value = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8") |
| 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 write_lines(path, rows): |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8") |
|
|
|
|
| def read_lines(path): |
| return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line] |
|
|
|
|
| def load(path): |
| return json.loads(path.read_text(encoding="utf-8")) |
|
|
|
|
| def values(metadata, key): |
| return [str(item.get("value", "")).strip() for item in metadata.get(key, []) if str(item.get("value", "")).strip()] |
|
|
|
|
| def request_json(url, params=None, attempts=3): |
| response = None |
| for attempt in range(attempts): |
| response = requests.get(url, params=params, headers={"User-Agent": UA}, timeout=(15, 30)) |
| if response.status_code not in (429, 500, 502, 503, 504): |
| response.raise_for_status() |
| return response.json() |
| import time |
| time.sleep(2 ** attempt) |
| response.raise_for_status() |
|
|
|
|
| def download(url, path, attempts=3): |
| response = None |
| for attempt in range(attempts): |
| response = requests.get(url, headers={"User-Agent": UA}, timeout=(15, 120), stream=True) |
| if response.status_code not in (429, 500, 502, 503, 504): |
| response.raise_for_status() |
| with path.open("wb") as handle: |
| for block in response.iter_content(1024 * 1024): |
| if block: |
| handle.write(block) |
| return |
| import time |
| time.sleep(2 ** attempt) |
| response.raise_for_status() |
|
|
|
|
| def embedded(payload, name): |
| return payload.get("_embedded", {}).get(name, []) |
|
|
|
|
| def normalize(text): |
| text = unicodedata.normalize("NFKC", text or "").replace("\u00ad", "").replace("\u200b", "") |
| text = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]", "", text) |
| lines = [re.sub(r"[ \t\xa0]+", " ", line).strip() for line in text.splitlines()] |
| lines = [line for line in lines if not re.fullmatch(r"\d{1,4}", line)] |
| text = "\n".join(lines) |
| text = re.sub(r"(?<=\w)-\n(?=[a-ząćęłńóśźż])", "", text) |
| text = re.sub(r"(?<![.!?:;\n])\n(?!\n)(?=[a-ząćęłńóśźż])", " ", text) |
| return re.sub(r"\n{3,}", "\n\n", text).strip() |
|
|
|
|
| def normalize_title(text): |
| text = unicodedata.normalize("NFKD", text or "").casefold() |
| text = "".join(character for character in text if not unicodedata.combining(character)) |
| return " ".join(re.findall(r"\w+", text)) |
|
|
|
|
| def item_objects(payload): |
| search = payload.get("_embedded", {}).get("searchResult", {}) |
| objects = search.get("_embedded", {}).get("objects", []) |
| return [item.get("_embedded", {}).get("indexableObject", {}) for item in objects] |
|
|
|
|
| def bundle(item_id, name): |
| payload = request_json(f"{API}/core/items/{item_id}/bundles", {"size": 20}) |
| return next((item for item in embedded(payload, "bundles") if item.get("name") == name), None) |
|
|
|
|
| def bitstreams(bundle_id): |
| return embedded(request_json(f"{API}/core/bundles/{bundle_id}/bitstreams", {"size": 100}), "bitstreams") |
|
|
|
|
| def choose_pdf(item_id): |
| original = bundle(item_id, "ORIGINAL") |
| if not original: |
| raise ValueError("missing ORIGINAL bundle") |
| pdfs = [item for item in bitstreams(original["uuid"]) if item.get("name", "").casefold().endswith(".pdf")] |
| if not pdfs: |
| raise ValueError("no PDF in ORIGINAL bundle") |
| return max(pdfs, key=lambda item: (int(item.get("sizeBytes", 0)), item.get("name", ""))) |
|
|
|
|
| def extract_pdf(path): |
| import pdfplumber |
| pages, failures = [], [] |
| with pdfplumber.open(path) as document: |
| for index, page in enumerate(document.pages, 1): |
| try: |
| pages.append(page.extract_text() or "") |
| except Exception as error: |
| pages.append("") |
| failures.append({"page": index, "error": str(error)}) |
| return "\n\n".join(pages), len(pages), failures |
|
|
|
|
| def candidate(item): |
| metadata = item.get("metadata", {}) |
| return ( |
| LICENSE in values(metadata, "dc.rights") |
| and "pl" in values(metadata, "dc.language") |
| and bool(BOOK_SUBTYPES & set(values(metadata, "dc.subtype"))) |
| and "Book" in values(metadata, "dc.type") |
| ) |
|
|
|
|
| def acquire(out, limit): |
| if (out / "inventory.json").exists(): |
| raise ValueError("inventory exists; use a fresh directory for an immutable acquisition") |
| out.mkdir(parents=True, exist_ok=True) |
| raw = out / "raw_text" |
| raw.mkdir(exist_ok=True) |
| temp_pdf = out / ".current.pdf" |
| selected, rejected, pages = [], [], [] |
| page = 0 |
| while len(selected) < limit: |
| payload = request_json(f"{API}/discover/search/objects", [ |
| ("scope", COLLECTION_ID), ("f.license", f"{LICENSE},equals"), |
| ("page", page), ("size", 100), ("sort", "dc.date.issued,DESC"), |
| ]) |
| items = item_objects(payload) |
| if not items: |
| break |
| pages.append({"page": page, "sha256": digest(payload), "items": len(items)}) |
| for item in items: |
| if len(selected) >= limit: |
| break |
| if not candidate(item): |
| continue |
| item_id = item["uuid"] |
| metadata = item["metadata"] |
| try: |
| print(f"Inspecting candidate {item_id}: {item.get('name', '')}", flush=True) |
| pdf = choose_pdf(item_id) |
| pdf_rights = values(pdf.get("metadata", {}), "dc.rights") |
| if LICENSE.replace("-", " ") not in pdf_rights and "CC-BY-SA 4.0" not in pdf_rights: |
| raise ValueError("original PDF bitstream lacks CC-BY-SA 4.0 evidence") |
| if int(pdf.get("sizeBytes", 0)) > MAX_PDF_BYTES: |
| raise ValueError(f"PDF exceeds pilot limit of {MAX_PDF_BYTES} bytes") |
| download(pdf["_links"]["content"]["href"], temp_pdf) |
| if temp_pdf.stat().st_size != int(pdf.get("sizeBytes", 0)): |
| raise ValueError("downloaded PDF byte count differs from repository metadata") |
| pdf_bytes = temp_pdf.read_bytes() |
| repository_checksum = pdf.get("checkSum") or {} |
| if repository_checksum.get("checkSumAlgorithm") == "MD5" and hashlib.md5(pdf_bytes).hexdigest() != repository_checksum.get("value"): |
| raise ValueError("downloaded PDF MD5 differs from repository metadata") |
| decoded, page_count, page_failures = extract_pdf(temp_pdf) |
| path = raw / f"{item_id}.txt" |
| path.write_text(decoded, encoding="utf-8") |
| selected.append({ |
| "item_id": item_id, "title": item.get("name", ""), "handle": item.get("handle"), |
| "landing_url": f"https://rock.pollub.pl/entities/publication/{item_id}", |
| "metadata": metadata, "authors": values(metadata, "dc.contributor.author"), |
| "editors": values(metadata, "dc.contributor.editor"), "issued": values(metadata, "dc.date.issued"), |
| "subtype": values(metadata, "dc.subtype"), "isbn": values(metadata, "dc.identifier.isbn"), |
| "eisbn": values(metadata, "dc.identifier.eisbn"), "item_license": values(metadata, "dc.rights"), |
| "pdf": {"id": pdf["uuid"], "name": pdf["name"], "bytes": pdf.get("sizeBytes"), |
| "checksum": pdf.get("checkSum"), "sha256": digest(pdf_bytes), "rights": pdf_rights, |
| "content_url": pdf["_links"]["content"]["href"]}, |
| "extracted_text": {"extractor": "pdfplumber", "bytes": path.stat().st_size, |
| "sha256": digest(path.read_bytes()), "page_count": page_count, |
| "page_failures": page_failures}, |
| "observed_at": now(), "decoded_characters": len(decoded), |
| }) |
| print(f"Acquired {len(selected)}/{limit}: {item.get('name', '')}", flush=True) |
| except Exception as error: |
| rejected.append({"item_id": item_id, "title": item.get("name", ""), "reason": str(error)}) |
| print(f"Skipped {item_id}: {error}", flush=True) |
| finally: |
| temp_pdf.unlink(missing_ok=True) |
| page += 1 |
| collection = request_json(f"{API}/core/collections/{COLLECTION_ID}") |
| inventory = {"source": SOURCE, "collection_id": COLLECTION_ID, "collection_url": COLLECTION_URL, |
| "collection_sha256": digest(collection), "collection_archived_items": collection.get("archivedItemsCount"), |
| "policy_url": POLICY_URL, "license": LICENSE, "limit": limit, "query_pages": pages, |
| "selected": selected, "acquisition_rejections": rejected, "observed_at": now(), |
| "target_reached": len(selected) == limit} |
| save(out / "inventory.json", inventory) |
| print(json.dumps({"selected": len(selected), "target": limit, "target_reached": len(selected) == limit, |
| "rejected_during_acquisition": len(rejected)}, ensure_ascii=False, indent=2)) |
|
|
|
|
| def shingles(text): |
| words = re.findall(r"\w+", text.casefold()) |
| return {" ".join(words[index:index + 5]) for index in range(max(0, len(words) - 4))} |
|
|
|
|
| def audit_overlap(out): |
| import pyarrow.parquet as pq |
| from huggingface_hub import HfApi, HfFileSystem |
|
|
| inventory = json.loads((out / "inventory.json").read_text(encoding="utf-8")) |
| fs = HfFileSystem() |
| revision = HfApi().dataset_info("SlayerLab/polish-dynaword").sha |
| remote = f"datasets/SlayerLab/polish-dynaword@{revision}/data/biblioteka_nauki/biblioteka_nauki.parquet" |
| with fs.open(remote, "rb") as handle: |
| table = pq.read_table(handle, columns=["id", "attribution"]) |
| target = [] |
| for row in table.to_pylist(): |
| parts = row["attribution"].split(" | ") |
| title = parts[2] if len(parts) >= 4 else row["attribution"] |
| target.append((row["id"], row["attribution"], normalize_title(title))) |
| results = [] |
| for record in inventory["selected"]: |
| title = normalize_title(record["title"]) |
| exact = [{"id": row_id, "attribution": attribution} for row_id, attribution, normalized in target |
| if title and title in normalized] |
| fuzzy = [] |
| if not exact: |
| ranked = sorted(((SequenceMatcher(None, title, normalized).ratio(), row_id, attribution) |
| for row_id, attribution, normalized in target), reverse=True)[:3] |
| fuzzy = [{"score": score, "id": row_id, "attribution": attribution} |
| for score, row_id, attribution in ranked if score >= 0.90] |
| results.append({"item_id": record["item_id"], "title": record["title"], |
| "exact_title_matches": exact, "fuzzy_title_matches": fuzzy}) |
| report = {"target": "SlayerLab/polish-dynaword:data/biblioteka_nauki", "target_revision": revision, |
| "method": "normalized title substring; fallback SequenceMatcher >= 0.90 over attribution", |
| "target_rows": table.num_rows, "candidate_records": len(results), |
| "records_with_exact_title_match": sum(bool(row["exact_title_matches"]) for row in results), |
| "records_with_fuzzy_title_match": sum(bool(row["fuzzy_title_matches"]) for row in results), |
| "text_overlap": "not tested; target-wide text dedup remains an integration gate", |
| "observed_at": now(), "results": results} |
| save(out / "overlap_audit.json", report) |
| print(json.dumps({key: report[key] for key in ("target_rows", "candidate_records", |
| "records_with_exact_title_match", "records_with_fuzzy_title_match")}, ensure_ascii=False, indent=2)) |
|
|
|
|
| def build(out): |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| import tiktoken |
| from langid.langid import LanguageIdentifier, model |
|
|
| inventory = json.loads((out / "inventory.json").read_text(encoding="utf-8")) |
| encoder = tiktoken.get_encoding("cl100k_base") |
| identifier = LanguageIdentifier.from_modelstring(model, norm_probs=True) |
| identifier.set_languages(["pl", "en", "de", "uk", "ru"]) |
| rows, attribution, decisions, seen, features = [], [], [], {}, {} |
| pii = Counter() |
| added = inventory["observed_at"][:10] |
| for record in inventory["selected"]: |
| path = out / "raw_text" / f"{record['item_id']}.txt" |
| payload = path.read_bytes() |
| if digest(payload) != record["extracted_text"]["sha256"]: |
| raise ValueError("text checksum mismatch: " + record["item_id"]) |
| text = normalize(payload.decode("utf-8-sig")) |
| letters = len(re.findall(r"[A-Za-zĄĆĘŁŃÓŚŹŻąćęłńóśźż]", text)) |
| replacement = text.count("\ufffd") |
| if replacement: |
| text = text.replace("\ufffd", "[UNREADABLE_GLYPH]") |
| language, confidence = identifier.classify(text[:30000]) if text else ("unknown", 0.0) |
| reason = "" |
| if len(text) < 5000: |
| reason = "too_little_extractable_text" |
| elif letters / max(len(text), 1) < 0.55: |
| reason = "low_letter_ratio" |
| elif replacement > 5 or replacement / max(len(text), 1) > 0.00001: |
| reason = "excessive_unreadable_glyphs" |
| elif language != "pl" and confidence >= 0.95: |
| reason = "non_polish" |
| text, emails = EMAIL_RE.subn("[REDACTED:EMAIL]", text) |
| text, phones = PHONE_RE.subn("[REDACTED:PHONE]", text) |
| pii.update(email=emails, labelled_phone=phones) |
| normalized_key = " ".join(text.casefold().split()) |
| if not reason and normalized_key in seen: |
| reason = "normalized_duplicate" |
| current_features = shingles(text) |
| duplicate_of = None |
| duplicate_score = 0.0 |
| if not reason: |
| for other_id, other_features in features.items(): |
| score = len(current_features & other_features) / max(len(current_features | other_features), 1) |
| if score >= 0.90: |
| reason, duplicate_of, duplicate_score = "near_duplicate", other_id, score |
| break |
| row_id = f"{SOURCE}_{record['item_id']}" |
| decision = {"id": row_id, "selected": not bool(reason), "reason": reason or "include", |
| "language": language, "language_confidence": float(confidence), "characters": len(text), |
| "letter_ratio": letters / max(len(text), 1), "replacement_characters": replacement} |
| if duplicate_of: |
| decision.update(duplicate_of=duplicate_of, jaccard=duplicate_score) |
| decisions.append(decision) |
| if reason: |
| continue |
| seen[normalized_key] = row_id |
| features[row_id] = current_features |
| author = "; ".join(record["authors"] or record["editors"] or ["Politechnika Lubelska"]) |
| created = record["issued"][0] if record["issued"] else "unknown" |
| row = {"id": row_id, "text": text, "source": SOURCE, "added": added, "created": created, |
| "token_count": len(encoder.encode_ordinary(text)), "license": LICENSE, "author": author} |
| rows.append(row) |
| attribution.append({"id": row_id, "title": record["title"], "author": author, |
| "authors": record["authors"], "editors": record["editors"], "publisher": "Politechnika Lubelska", |
| "subtype": record["subtype"], "issued": record["issued"], "isbn": record["isbn"], "eisbn": record["eisbn"], |
| "landing_url": record["landing_url"], "handle": record["handle"], "license": LICENSE, |
| "license_url": LICENSE_URL, "license_policy_url": POLICY_URL, |
| "license_evidence": {"item": record["item_license"], "pdf_bitstream": record["pdf"]["rights"]}, |
| "pdf": record["pdf"], "extracted_text": record["extracted_text"], "text_sha256": digest(text.encode("utf-8")), |
| "transformations": ["pdfplumber page extraction", "Unicode/whitespace normalization", |
| "page-number-only removal", "line-wrap repair", "limited email/labelled-phone redaction"]}) |
| root = out / "hf_repo" |
| (root / "data").mkdir(parents=True, exist_ok=True) |
| (root / "artifacts").mkdir(exist_ok=True) |
| schema = pa.schema([(field, pa.int64() if field == "token_count" else pa.string()) for field in FIELDS]) |
| pq.write_table(pa.Table.from_pylist(rows, schema=schema), root / "data/train-00000-of-00001.parquet", compression="zstd") |
| write_lines(root / "artifacts/attribution.jsonl", attribution) |
| write_lines(root / "artifacts/decisions.jsonl", decisions) |
| sample = sorted(rows, key=lambda row: digest(("sample:" + row["id"]).encode()))[:12] |
| write_lines(root / "artifacts/sample.jsonl", sample) |
| inventory_public = dict(inventory) |
| save(root / "artifacts/inventory.json", inventory_public) |
| stats = {"pilot_limit": inventory["limit"], "discovered_collection_items": inventory["collection_archived_items"], |
| "acquired": len(inventory["selected"]), "kept": len(rows), "rejected": len(decisions) - len(rows), |
| "tokens": sum(row["token_count"] for row in rows), "characters": sum(len(row["text"]) for row in rows), |
| "author_coverage": sum(bool(row["author"]) for row in rows) / len(rows) if rows else 0, |
| "sample_count": len(sample), "added": added} |
| overlap_path = out / "overlap_audit.json" |
| overlap = json.loads(overlap_path.read_text(encoding="utf-8")) if overlap_path.exists() else None |
| if overlap: |
| save(root / "artifacts/overlap_audit.json", overlap) |
| target_audit_path = out / "target_audit.json" |
| target_audit = load(target_audit_path) if target_audit_path.exists() else None |
| if target_audit: |
| save(root / "artifacts/target_audit.json", target_audit) |
| qa = {"scope": f"pilot target {inventory['limit']}; acquired {len(inventory['selected'])}; not a completeness claim", |
| "target_reached": inventory.get("target_reached", len(inventory["selected"]) == inventory["limit"]), |
| "license_gate": "CC-BY-SA-4.0 in item and matched PDF bitstream metadata", |
| "pii_pattern_matches": dict(pii), "exact_dedup": True, "near_dedup": "exact 5-word-shingle Jaccard >= 0.90 within pilot", |
| "biblioteka_nauki_overlap": overlap or "pending title comparison", "cross_source_dedup": "pending target integration", |
| "benchmark_overlap": "pending", "limitations": ["PDF extraction may flatten tables and equations", |
| "third-party figures and quoted material are not included as images but textual excerpts require review", |
| "isolated PDF extraction replacement characters are represented as [UNREADABLE_GLYPH]", |
| "pattern checks are not comprehensive de-identification", "pilot yield must not be extrapolated without a full inventory run"]} |
| save(root / "artifacts/stats.json", stats) |
| save(root / "artifacts/qa.json", qa) |
| run = {"id": "run:" + digest({"script": digest(Path(__file__).read_bytes()), "inventory": digest(inventory)}), |
| "protocol": "protocol:rock-pilot-v1", "started_at": inventory["observed_at"], "finished_at": now(), |
| "success": True, "actor": "actor:codex", "stats": stats} |
| save(root / "artifacts/run.json", run) |
| checksum_exclusions = {"artifacts/checksums.json", "artifacts/ontology.json"} |
| checks = {path.relative_to(root).as_posix(): digest(path.read_bytes()) for path in sorted(root.rglob("*")) |
| if path.is_file() and path.relative_to(root).as_posix() not in checksum_exclusions} |
| save(root / "artifacts/checksums.json", checks) |
| evidence_id = "evidence:qa:" + digest(qa) |
| inventory_evidence_id = "evidence:inventory:" + digest(inventory) |
| overlap_evidence_id = "evidence:overlap:" + digest(overlap) if overlap else None |
| target_evidence_id = "evidence:target-audit:" + digest(target_audit) if target_audit else None |
| source_version = "version:source:" + digest({"inventory": inventory, "texts": [item["extracted_text"]["sha256"] for item in inventory["selected"]]}) |
| dataset_version = "version:dataset:" + digest(checks) |
| ontology = {"schema": "slayer-research-ontology-profile-v1", |
| "objects": [{"id": "object:source:rock-pollub", "type": "Source"}, {"id": "object:dataset:rock-pollub-pl-pilot", "type": "Dataset"}], |
| "versions": [{"id": source_version, "object": "object:source:rock-pollub", "content_address": source_version.rsplit(":", 1)[-1]}, |
| {"id": dataset_version, "object": "object:dataset:rock-pollub-pl-pilot", "content_address": dataset_version.rsplit(":", 1)[-1]}], |
| "protocols": [{"id": "protocol:rock-pilot-v1", "procedure": "item+PDF rights gate, matched repository text, normalization, PII patterns, exact/near dedup"}], |
| "runs": [run], "evidence": [ |
| {"id": inventory_evidence_id, "observation_type": "source_inventory", |
| "artifact": "artifacts/inventory.json", "content_address": digest(inventory), "produced_by": run["id"]}, |
| {"id": evidence_id, "observation_type": "pilot_qa", "payload": qa, "produced_by": run["id"]}, |
| ] + ([{"id": overlap_evidence_id, "observation_type": "metadata_overlap_audit", |
| "artifact": "artifacts/overlap_audit.json", "content_address": digest(overlap), |
| "produced_by": run["id"]}] if overlap else []) + |
| ([{"id": target_evidence_id, "observation_type": "target_registry_audit", |
| "artifact": "artifacts/target_audit.json", "content_address": digest(target_audit), |
| "produced_by": run["id"]}] if target_audit else []), |
| "claims": [{"id": "claim:pilot-eligibility", "statement": "Retained pilot records have Polish book metadata and CC BY-SA 4.0 evidence at item and matched PDF-bitstream level.", |
| "supported_by": [inventory_evidence_id, evidence_id], "falsification_condition": "A retained record lacks Polish book metadata or either rights assertion."}, |
| {"id": "claim:no-title-overlap-detected", "statement": "No exact or near title match was detected against the current Biblioteka Nauki attribution column.", |
| "supported_by": [overlap_evidence_id] if overlap else [evidence_id], |
| "falsification_condition": "The recorded comparison contains a match, or a rerun against the pinned target version finds one."}, |
| {"id": "claim:not-registered-at-audit", "statement": "The source key and a matching ROCK/Pollub proposal were absent from the pinned DynaWord registry and discussion list at audit time.", |
| "supported_by": [target_evidence_id] if target_audit else [evidence_id], |
| "falsification_condition": "The pinned registry or recorded discussion list contains this source."}, |
| {"id": "claim:training-value-untested", "statement": "Training benefit and full-corpus novelty remain untested hypotheses.", |
| "supported_by": [evidence_id], "falsification_condition": "A controlled ablation and target-wide overlap analysis establish those properties."}], |
| "actors": [{"id": "actor:piotrsty", "type": "Contributor"}, {"id": "actor:politechnika-lubelska", "type": "Organization"}, |
| {"id": "actor:codex", "type": "Agent"}], |
| "relations": [{"source": dataset_version, "predicate": "DERIVED_FROM", "target": source_version}, |
| {"source": dataset_version, "predicate": "GENERATED_BY", "target": run["id"]}] + |
| ([{"source": dataset_version, "predicate": "VALIDATED_AGAINST", |
| "target": "hf:dataset:SlayerLab/polish-dynaword@" + target_audit["revision"]}] |
| if target_audit else []), |
| "pending": ["Biblioteka Nauki text overlap", "full collection inventory", "cross-source deduplication", |
| "benchmark contamination check", "legal review of third-party textual excerpts", "controlled training ablation"]} |
| save(root / "artifacts/ontology.json", ontology) |
| print(json.dumps(stats, ensure_ascii=False, indent=2)) |
|
|
|
|
| def verify(out): |
| import pyarrow.parquet as pq |
| root = out / "hf_repo" |
| table = pq.read_table(root / "data/train-00000-of-00001.parquet") |
| rows = table.to_pylist() |
| stats = json.loads((root / "artifacts/stats.json").read_text(encoding="utf-8")) |
| decisions = read_lines(root / "artifacts/decisions.jsonl") |
| attribution = read_lines(root / "artifacts/attribution.jsonl") |
| sample = read_lines(root / "artifacts/sample.jsonl") |
| assert table.column_names == FIELDS |
| assert len(rows) == stats["kept"] == len(attribution) |
| assert len(decisions) == stats["acquired"] |
| assert sum(item["selected"] for item in decisions) == len(rows) |
| assert sum(row["token_count"] for row in rows) == stats["tokens"] |
| assert all(row["source"] == SOURCE and row["license"] == LICENSE and row["author"] for row in rows) |
| assert all(EMAIL_RE.search(row["text"]) is None for row in rows) |
| by_id = {row["id"]: row for row in rows} |
| assert len(sample) == stats["sample_count"] and all(by_id[row["id"]] == row for row in sample) |
| manifest = json.loads((root / "artifacts/ontology.json").read_text(encoding="utf-8")) |
| evidence = {item["id"] for item in manifest["evidence"]} |
| assert all(item["falsification_condition"] and set(item["supported_by"]) <= evidence for item in manifest["claims"]) |
| checks = json.loads((root / "artifacts/checksums.json").read_text(encoding="utf-8")) |
| assert "artifacts/checksums.json" not in checks and "artifacts/ontology.json" not in checks |
| assert all((root / relative).is_file() and digest((root / relative).read_bytes()) == checksum |
| for relative, checksum in checks.items()) |
| for item in manifest["evidence"]: |
| if item.get("artifact"): |
| artifact = root / item["artifact"] |
| assert artifact.is_file() and digest(json.loads(artifact.read_text(encoding="utf-8"))) == item["content_address"] |
| print(json.dumps({"verified": True, **stats}, ensure_ascii=False, indent=2)) |
|
|
|
|
| def checksum_map(root): |
| excluded = {"artifacts/checksums.json", "artifacts/ontology.json"} |
| return {path.relative_to(root).as_posix(): digest(path.read_bytes()) for path in sorted(root.rglob("*")) |
| if path.is_file() and path.relative_to(root).as_posix() not in excluded} |
|
|
|
|
| def registry(base): |
| tree = ast.parse(base) |
| node = next(item.value for item in tree.body if isinstance(item, ast.Assign) |
| and any(isinstance(target, ast.Name) and target.id == "SOURCES" for target in item.targets)) |
| if SOURCE in ast.literal_eval(node): |
| raise ValueError("source already registered") |
| entry = { |
| "file_key": SOURCE, |
| "pretty": "ROCK Politechnika Lubelska - Polish academic books", |
| "license": LICENSE, |
| "license_spdx": LICENSE, |
| "traceable": "Each retained book has CC BY-SA 4.0 evidence in both the item record and matched original-PDF bitstream metadata; URLs, checksums, attribution and exclusions are preserved.", |
| "upstream": COLLECTION_URL, |
| "provenance": f"Fetched directly from the official ROCK repository by src/fetch_{SOURCE}.py; only the fail-closed eight-record subset with item- and PDF-level rights evidence is included.", |
| "domain": "academic/technical", |
| "created": "2023-2026", |
| "is_ocr": False, |
| "custom_datasheet": True, |
| } |
| offset = sum(len(line) for line 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 prepare(out, target_revision): |
| root = out / "hf_repo" |
| (root / "src").mkdir(parents=True, exist_ok=True) |
| shutil.copy2(Path(__file__), root / f"src/fetch_{SOURCE}.py") |
| shutil.copy2(Path(__file__).with_name("rock_pollub_requirements.txt"), root / "src/requirements.txt") |
| shutil.copy2(Path(__file__).with_name("test_rock_pollub_contribution.py"), root / "src/test_rock_pollub_contribution.py") |
| stats = load(root / "artifacts/stats.json") |
| notice = f"""# Notice and attribution |
| |
| Source collection: {COLLECTION_URL} |
| Publisher policy: {POLICY_URL} |
| |
| The eight retained books expose `{LICENSE}` in both the item record and the metadata of the matched original PDF bitstream. Per-record authors, titles, source URLs, license evidence and source-file checksums are preserved in `artifacts/attribution.jsonl` and `artifacts/inventory.json`. |
| |
| Transformations: PDF text extraction with pdfplumber, Unicode and whitespace normalization, page-number-only removal, line-wrap repair, limited email and labelled-phone redaction, and within-source exact/near deduplication. Images are excluded. Isolated unreadable PDF glyphs are represented as `[UNREADABLE_GLYPH]`. Attribution and ShareAlike obligations remain applicable. |
| """ |
| (root / "NOTICE.md").write_text(notice, encoding="utf-8") |
| readme = f"""--- |
| license: cc-by-sa-4.0 |
| language: |
| - pl |
| task_categories: |
| - text-generation |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: data/train-00000-of-00001.parquet |
| --- |
| |
| # ROCK Politechnika Lubelska PL books |
| |
| A fail-closed Polish academic-book subset extracted from the official ROCK repository of Lublin University of Technology. |
| |
| - Retained books: {stats['kept']} |
| - Text characters: {stats['characters']:,} |
| - Tokens: {stats['tokens']:,} (`cl100k_base` proxy) |
| - Author coverage: {stats['author_coverage']:.1%} |
| - License: CC BY-SA 4.0, confirmed for every retained item and matched PDF bitstream |
| - Source period: 2023-2026 |
| |
| The acquisition target was 20 books, but only eight passed the conservative per-file rights gate. The other inspected candidates are not included. See `NOTICE.md` and `artifacts/` for attribution, decisions, the source inventory, deterministic complete-record samples, QA, checksums, overlap audit and Slayer ontology manifest. |
| |
| ## Limitations |
| |
| PDF extraction can flatten tables and equations. Two isolated unreadable glyphs were marked explicitly. Pattern-based PII checks are not comprehensive de-identification. No title overlap was detected against the pinned `biblioteka_nauki` attribution column, but target-wide text deduplication, benchmark checks and controlled training ablations remain pending. |
| """ |
| (root / "README.md").write_text(readme, encoding="utf-8") |
| build(out) |
| verify(out) |
| if load(out / "target_audit.json")["revision"] != target_revision: |
| raise ValueError("target audit revision mismatch") |
|
|
|
|
| def hf_token(): |
| value = os.environ.get("HF_TOKEN") |
| if not value and os.name == "nt": |
| import winreg |
| with winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Environment") as key: |
| value = winreg.QueryValueEx(key, "HF_TOKEN")[0] |
| if not value or not value.startswith("hf_"): |
| raise ValueError("HF_TOKEN unavailable") |
| return value |
|
|
|
|
| def all_files(root): |
| return [path for path in sorted(root.rglob("*")) if path.is_file() |
| and "__pycache__" not in path.parts and ".pytest_cache" not in path.parts] |
|
|
|
|
| def assemble_pr(out, base, source_commit): |
| root = out / "hf_repo" |
| pr = out / "dynaword_pr" |
| data = pr / "data" / SOURCE |
| data.mkdir(parents=True, exist_ok=True) |
| (pr / "src").mkdir(exist_ok=True) |
| (pr / "artifacts").mkdir(exist_ok=True) |
| shutil.copy2(root / "data/train-00000-of-00001.parquet", data / f"{SOURCE}.parquet") |
| for name in ("attribution.jsonl", "decisions.jsonl", "sample.jsonl", "stats.json", "qa.json", "overlap_audit.json"): |
| shutil.copy2(root / "artifacts" / name, data / f"{SOURCE}.{name}") |
| shutil.copy2(root / "NOTICE.md", data / "NOTICE.md") |
| shutil.copy2(root / "README.md", data / f"{SOURCE}.md") |
| shutil.copy2(root / "artifacts/ontology.json", pr / f"artifacts/{SOURCE}_ontology_manifest.json") |
| shutil.copy2(Path(__file__), pr / f"src/fetch_{SOURCE}.py") |
| shutil.copy2(Path(__file__).with_name("rock_pollub_requirements.txt"), pr / f"src/{SOURCE}_requirements.txt") |
| shutil.copy2(Path(__file__).with_name("test_rock_pollub_contribution.py"), pr / "src/test_rock_pollub_contribution.py") |
| (pr / "src/sources.py").write_text(registry(base), encoding="utf-8") |
| stats = load(root / "artifacts/stats.json") |
| description = f"""## Add eight Polish academic books from ROCK |
| |
| Adds `{SOURCE}`: **{stats['kept']} complete books and {stats['tokens']:,} measured `cl100k_base` proxy tokens** from the official ROCK repository of Lublin University of Technology. |
| |
| Source dataset: https://huggingface.co/datasets/{OWN_REPO}/tree/{source_commit} |
| |
| ### Data sample |
| |
| - [{stats['sample_count']} deterministic complete-record samples](https://huggingface.co/datasets/{OWN_REPO}/blob/{source_commit}/artifacts/sample.jsonl) |
| - [Per-record attribution, source URLs and item/PDF rights evidence](https://huggingface.co/datasets/{OWN_REPO}/blob/{source_commit}/artifacts/attribution.jsonl) |
| - [Fail-closed acquisition inventory and exclusions](https://huggingface.co/datasets/{OWN_REPO}/blob/{source_commit}/artifacts/inventory.json) |
| |
| ### Rights and method |
| |
| Every retained record exposes CC BY-SA 4.0 in both the ROCK item record and the matched original PDF bitstream metadata. The publisher policy, source URLs, checksums and attribution are preserved. The acquisition target was 20 records; only these eight passed the conservative per-file gate. Text was extracted with pdfplumber, normalized, checked for limited PII patterns, and exact/near-deduplicated within source. |
| |
| ### Overlap and Slayer ontology |
| |
| No exact or fuzzy title match was detected against all 42,071 rows of `biblioteka_nauki` at pinned DynaWord revision `{load(out / 'overlap_audit.json')['target_revision']}`. This is metadata evidence, not target-wide text deduplication. The manifest separates content-addressed source/dataset Versions, Protocol, Run, Evidence, falsifiable Claims, Actors and typed lineage. Cross-source text deduplication, benchmark checks, review of quoted third-party text and controlled training ablations remain pending. This PR proposes a source, not a merged or stable release. |
| """ |
| (out / "pr_description.md").write_text(description, encoding="utf-8") |
| return pr |
|
|
|
|
| def publish(out): |
| from huggingface_hub import CommitOperationAdd, HfApi |
|
|
| api = HfApi(token=hf_token()) |
| if api.whoami()["name"].casefold() != "piotrsty": |
| raise ValueError("unexpected HF account") |
| target = api.dataset_info(TARGET) |
| registry_url = f"https://huggingface.co/datasets/{TARGET}/resolve/{target.sha}/src/sources.py" |
| response = requests.get(registry_url, headers={"User-Agent": UA}, timeout=(15, 60)) |
| response.raise_for_status() |
| base = response.text |
| discussions = list(api.get_repo_discussions(TARGET, repo_type="dataset")) |
| matching = [{"num": item.num, "title": item.title, "status": item.status} |
| for item in discussions if "rock" in item.title.casefold() or "pollub" in item.title.casefold()] |
| if SOURCE in base or matching: |
| raise ValueError("ROCK source registration or proposal already exists") |
| target_audit = {"repository": TARGET, "revision": target.sha, "registry_sha256": digest(base.encode("utf-8")), |
| "discussion_count": len(discussions), "matching_discussions": matching, "observed_at": now()} |
| save(out / "target_audit.json", target_audit) |
| prepare(out, target.sha) |
| root = out / "hf_repo" |
| receipt_path = out / "publication.json" |
| receipt = load(receipt_path) if receipt_path.exists() else {} |
| if not receipt: |
| if api.repo_exists(OWN_REPO, repo_type="dataset"): |
| raise ValueError("own HF repository already exists without this run receipt") |
| api.create_repo(OWN_REPO, repo_type="dataset", private=True) |
| receipt = {"source_repo": OWN_REPO, "target_main_revision": target.sha, "created_at": now()} |
| save(receipt_path, receipt) |
| if receipt["target_main_revision"] != target.sha: |
| raise ValueError("target main changed since publication started; inspect before continuing") |
| if not receipt.get("source_commit"): |
| result = api.create_commit(OWN_REPO, repo_type="dataset", |
| commit_message="Add validated eight-book ROCK Polish corpus", |
| operations=[CommitOperationAdd(path_in_repo=path.relative_to(root).as_posix(), path_or_fileobj=str(path)) |
| for path in all_files(root)]) |
| receipt["source_commit"] = result.oid |
| save(receipt_path, receipt) |
| source_revision = receipt["source_commit"] |
| if not any(item.name == "v1.0.0" for item in api.list_repo_refs(OWN_REPO, repo_type="dataset").tags): |
| api.create_tag(OWN_REPO, repo_type="dataset", tag="v1.0.0", revision=source_revision) |
| api.update_repo_settings(OWN_REPO, repo_type="dataset", private=False) |
| pr = assemble_pr(out, base, source_revision) |
| subprocess.run([sys.executable, "-m", "pytest", "-q", str(pr / "src/test_rock_pollub_contribution.py")], check=True) |
| if not receipt.get("pr_url"): |
| result = api.create_commit(TARGET, repo_type="dataset", parent_commit=target.sha, create_pr=True, |
| commit_message="Add eight CC BY-SA 4.0 Polish academic books from ROCK", |
| commit_description=(out / "pr_description.md").read_text(encoding="utf-8"), |
| operations=[CommitOperationAdd(path_in_repo=path.relative_to(pr).as_posix(), path_or_fileobj=str(path)) |
| for path in all_files(pr)]) |
| receipt.update({"tag": "v1.0.0", "pr_url": result.pr_url, "pr_commit": result.oid, "published_at": now()}) |
| save(receipt_path, receipt) |
| print(json.dumps(receipt, ensure_ascii=False, indent=2)) |
|
|
|
|
| def audit(out): |
| from huggingface_hub import HfApi, hf_hub_download |
|
|
| api = HfApi(token=False) |
| receipt = load(out / "publication.json") |
| info = api.dataset_info(OWN_REPO) |
| if info.private or info.sha != receipt["source_commit"]: |
| raise ValueError("source repo visibility or revision mismatch") |
| tags = api.list_repo_refs(OWN_REPO, repo_type="dataset").tags |
| if not any(item.name == receipt["tag"] and item.target_commit == info.sha for item in tags): |
| raise ValueError("release tag mismatch") |
| number = int(receipt["pr_url"].rsplit("/", 1)[-1]) |
| discussion = api.get_discussion_details(TARGET, number, repo_type="dataset") |
| pr_info = api.dataset_info(TARGET, revision=f"refs/pr/{number}") |
| if not discussion.is_pull_request or pr_info.sha != receipt["pr_commit"]: |
| raise ValueError("PR identity mismatch") |
| checked = [] |
| cache = out / "remote_cache" |
| for repo, revision, root in ((OWN_REPO, info.sha, out / "hf_repo"), (TARGET, pr_info.sha, out / "dynaword_pr")): |
| for path in all_files(root): |
| name = path.relative_to(root).as_posix() |
| remote = Path(hf_hub_download(repo, name, repo_type="dataset", revision=revision, |
| token=False, cache_dir=str(cache))) |
| if digest(remote.read_bytes()) != digest(path.read_bytes()): |
| raise ValueError("remote mismatch: " + name) |
| checked.append({"repo": repo, "revision": revision, "path": name, |
| "sha256": digest(remote.read_bytes())}) |
| result = {"observed_at": now(), "source_revision": info.sha, "pr_revision": pr_info.sha, |
| "pr_status": discussion.status, "target_main_revision": api.dataset_info(TARGET).sha, |
| "verified_files": checked} |
| save(out / "publication_audit.json", result) |
| shutil.rmtree(cache, ignore_errors=True) |
| print(json.dumps({**result, "verified_files": len(checked)}, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--output", type=Path, required=True) |
| parser.add_argument("--limit", type=int, default=20) |
| parser.add_argument("command", choices=["acquire", "audit_overlap", "build", "verify", "publish", "audit"]) |
| args = parser.parse_args() |
| acquire(args.output, args.limit) if args.command == "acquire" else globals()[args.command](args.output) |
|
|
