#!/usr/bin/env python3 """Build an auditable corpus of UZP public-procurement rulings (KIO/SO/SA/SN). Source: https://orzeczenia.uzp.gov.pl - the official decision search service of the Polish Public Procurement Office (Urzad Zamowien Publicznych). Documents are official rulings of the National Appeals Chamber (KIO), district courts (SO), administrative courts (SA) and the Supreme Court (SN) in public procurement matters. Legal basis: official documents are excluded from copyright under Polish Copyright Act art. 4(2) (same basis as the SAOS slice). """ from __future__ import annotations import argparse from collections import Counter from concurrent.futures import ThreadPoolExecutor, as_completed from datetime import datetime, timezone import gzip import hashlib import html as html_module import io import ipaddress import json from pathlib import Path import re import time import requests SOURCE = "uzp_orzeczenia_pl" OWN_REPO = "PiotrSty/uzp-orzeczenia-pl" TARGET = "SlayerLab/polish-dynaword" BASE = "https://orzeczenia.uzp.gov.pl" SEARCH_URL = BASE + "/Home/Search" RESULTS_URL = BASE + "/Home/GetResults" SOURCE_URL = BASE + "/" FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"] UA = "UzpOrzeczeniaCorpusResearch/0.1 (PiotrSty; open research slice)" LICENSE_LABEL = "public-domain (official documents)" LICENSE_SPDX = "LicenseRef-Polish-Official-Documents" LEGAL_BASIS = ("Polish Copyright Act art. 4(2): official documents are not subject to copyright; " "UZP search service republishes KIO/SO/SA/SN rulings in public procurement matters") MIN_TEXT_CHARS = 1_500 PAGE_SIZE = 10 # fixed server-side; #sp-page-size is not a serialized form field KINDS = ("KIO", "SO", "SA", "SN") 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\.|\bphone)\s*:?[ \t]*(?:\+48[ \t]*)?\d(?:[ .-]?\d){8}\b") IPV4_RE = re.compile(r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b") IPV6_RE = re.compile(r"(?i)\b(?:[0-9a-f]{1,4}:){3,}[0-9a-f]{1,4}\b") IPV6_CANDIDATE_RE = re.compile(r"(?]+>", " ", fragment))).strip() def parse_result_items(page_html): """Parse /Home/GetResults response into per-document records.""" records = [] for block in re.findall(r'
([^<]+)\s*([^<]+)", block): fields[label.strip().rstrip(":")] = strip_html(value) records.append({ "doc_id": int(link.group(1)), "organ": fields.get("Organ wydający", ""), "doc_type": fields.get("Rodzaj dokumentu", ""), "signature": fields.get("Sygnatura", ""), "issued": fields.get("Data wydania", ""), }) counts = RESULT_COUNTS_RE.search(page_html) totals = [int(value) for value in counts.group(1).split(",")] if counts else [] return records, totals def parse_counts(page_html): """Return dict kind -> count from the resultCounts hidden field.""" _records, totals = parse_result_items(page_html) kinds = ["ALL", "KIO", "SO", "SA", "SN"] return {kinds[index]: value for index, value in enumerate(totals)} if totals else {} def parse_details(page_html, doc_id): """Parse /Home/Details/{id} metadata page.""" pdf = PDF_LINK_RE.search(page_html) body = re.sub(r"", " ", page_html, flags=re.S) fields = {} for label, value in re.findall(r"\s*([^<]+)", body): fields[label.strip().rstrip(":")] = strip_html(value) return { "doc_id": doc_id, "organ": fields.get("Organ wydający", ""), "doc_type": fields.get("Rodzaj dokumentu", ""), "issued": fields.get("Data wydania rozstrzygnięcia", ""), "chairman": fields.get("Przewodniczący", ""), "purchaser": fields.get("Zamawiający", ""), "city": fields.get("Miejscowość", ""), "signature": fields.get("Sygnatura akt / Sposób rozstrzygnięcia", fields.get("Sygnatura akt / Sygnatura KIO / Sposób rozstrzygnięcia", "")), "provisions": fields.get("Kluczowe przepisy ustawy Pzp", ""), "pdf_path_url": BASE + pdf.group(1) if pdf else "", "pdf_kind": pdf.group(3) if pdf else "", } def session(): s = requests.Session() s.headers.update({"User-Agent": UA}) s.get(SEARCH_URL, timeout=20) return s def post_results(sess, kind, page, attempts=5): data = {"Phrase": "", "Fle": "1", "SCnt": "1", "CountStats": "true", "Kind": kind, "Srt": "", "Pg": str(page)} for attempt in range(attempts): try: r = sess.post(RESULTS_URL, data=data, timeout=30) if r.status_code in (429, 500, 502, 503, 504): time.sleep(2 ** attempt) continue r.raise_for_status() return r.text except requests.RequestException: if attempt == attempts - 1: raise time.sleep(2 ** attempt) raise RuntimeError("unreachable") def request(url, attempts=5, timeout=(15, 90), binary=False, sess=None): client = sess or requests response = None for attempt in range(attempts): response = client.get(url, headers={"User-Agent": UA}, timeout=timeout) if response.status_code not in (429, 500, 502, 503, 504): response.raise_for_status() return response.content if binary else response.content.decode("utf-8", "replace") time.sleep(2 ** attempt) response.raise_for_status() def request_json(url): return json.loads(request(url)) def discover(out, workers): """Enumerate every document via the kind-filtered result pages.""" seen = {} counts = {} for kind in KINDS: body = post_results(session(), kind, 1) first, totals = parse_result_items(body) all_counts = parse_counts(body) counts[kind] = all_counts.get(kind, len(first)) total = counts[kind] pages = max(1, -(-total // PAGE_SIZE)) if total else 1 for record in first: record["kind"] = kind seen[record["doc_id"]] = record def fetch_page(page): return page, post_results(session(), kind, page) with ThreadPoolExecutor(max_workers=workers) as pool: futures = {pool.submit(fetch_page, p): p for p in range(2, pages + 1)} for index, future in enumerate(as_completed(futures), 1): _, body = future.result() for record in parse_result_items(body)[0]: record["kind"] = kind seen[record["doc_id"]] = record if index % 200 == 0: print(f" {kind} {index}/{pages - 1} pages", flush=True) print(f" {kind}: {pages} pages, total {total}", flush=True) records = sorted(seen.values(), key=lambda record: record["doc_id"]) write_lines(out / "source_manifest.jsonl", records) selection = { "observed_at": now(), "search_url": SEARCH_URL, "reported_totals": counts, "enumerated": len(records), "per_kind": dict(Counter(record["kind"] for record in records)), "selected": len(records), "selected_ids": [record["doc_id"] for record in records], "source_manifest_sha256": digest((out / "source_manifest.jsonl").read_bytes()), } save(out / "selection.json", selection) print(json.dumps(selection, ensure_ascii=False, indent=2)) def acquire(out, workers): selection = load(out / "selection.json") manifest = {record["doc_id"]: record for record in read_lines(out / "source_manifest.jsonl")} (out / "raw_pages").mkdir(parents=True, exist_ok=True) (out / "raw_pdf").mkdir(parents=True, exist_ok=True) (out / "raw_text").mkdir(parents=True, exist_ok=True) results = [] def fetch(doc_id): record = manifest[doc_id] page_path = out / "raw_pages" / f"{doc_id}.html.gz" pdf_path = out / "raw_pdf" / f"{doc_id}.pdf" text_path = out / "raw_text" / f"{doc_id}.txt" if pdf_path.is_file() and text_path.is_file() and page_path.is_file(): return record, digest(pdf_path.read_bytes()), pdf_path.stat().st_size, \ digest(text_path.read_bytes()), "cached", json.loads( gzip.decompress(page_path.read_bytes()).decode("utf-8"))["details"] sess = session() body = request(BASE + f"/Home/Details/{doc_id}", sess=sess) details = parse_details(body, doc_id) if not details["pdf_path_url"]: raise ValueError(f"no PdfContent link on details page: {doc_id}") page_path.write_bytes(gzip.compress(json.dumps( {"doc_id": doc_id, "details": details}, ensure_ascii=False).encode("utf-8"))) payload = request(details["pdf_path_url"], binary=True, sess=sess) if not payload.startswith(b"%PDF"): raise ValueError("not a PDF: " + str(doc_id)) pdf_path.write_bytes(payload) from pypdf import PdfReader reader = PdfReader(io.BytesIO(payload)) text = "\n".join(page.extract_text() or "" for page in reader.pages) text_path.write_text(text, encoding="utf-8") return record, digest(payload), len(payload), digest(text.encode("utf-8")), \ str(len(reader.pages)), details with ThreadPoolExecutor(max_workers=workers) as pool: futures = {pool.submit(fetch, doc_id): doc_id for doc_id in selection["selected_ids"]} for index, future in enumerate(as_completed(futures), 1): doc_id = futures[future] record = manifest[doc_id] try: record, pdf_sha, pdf_bytes, text_sha, pages, details = future.result() results.append({**record, "details": details, "pdf_sha256": pdf_sha, "pdf_bytes": pdf_bytes, "text_sha256": text_sha, "pdf_pages": pages, "pdf_path": f"raw_pdf/{doc_id}.pdf", "text_path": f"raw_text/{doc_id}.txt"}) except Exception as error: results.append({**record, "error": f"{type(error).__name__}: {error}"}) if index % 100 == 0: print(f" {index}/{len(selection['selected_ids'])}", flush=True) results.sort(key=lambda record: record["doc_id"]) acquisition = { "observed_at": now(), "target": selection["selected"], "acquired": sum("pdf_sha256" in record for record in results), "failed": [record["doc_id"] for record in results if "error" in record], "selected": results, } save(out / "acquisition.json", acquisition) print(json.dumps({key: acquisition[key] for key in ("target", "acquired", "failed")}, ensure_ascii=False, indent=2)) def normalize(text): import unicodedata text = unicodedata.normalize("NFKC", text or "").replace("­", "").replace("​", "") text = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]", "", text) lines = [re.sub(r"[ \t   ]+", " ", line).strip() for line in text.splitlines()] # drop repeated running-head signature lines and bare page numbers seen_sygn = 0 kept = [] for line in lines: if SYGN_RE.match(line): seen_sygn += 1 if seen_sygn > 1: continue if PAGE_NUM_RE.match(line): continue kept.append(line) text = "\n".join(kept) text = re.sub(r"(?<=\w)-\n(?=[a-ząćęłńóśźż])", "", text) text = re.sub(r"(? limit: return set(sorted(hashes)[:limit]) return hashes DF_FRACTION = 0.02 # shingles in >2% of docs are boilerplate (KIO formula openings) def shingle_document_frequencies(sketches): df = Counter() for sketch in sketches: df.update(sketch) return df def filter_sketch(sketch, df, max_df): """Drop high document-frequency shingles (boilerplate) from a sketch.""" return {h for h in sketch if df[h] <= max_df} class NearDuplicateIndex: def __init__(self): self.postings = {} self.records = [] self.comparisons = 0 @staticmethod def prefix(sketch): return sorted(sketch)[:len(sketch) - (9 * len(sketch) + 9) // 10 + 1] def find(self, sketch): candidates = set() for value in self.prefix(sketch): candidates.update(self.postings.get(value, ())) for position in sorted(candidates): row_id, other = self.records[position] if 10 * min(len(sketch), len(other)) < 9 * max(len(sketch), len(other)): continue self.comparisons += 1 intersection = len(sketch & other) score = intersection / max(len(sketch) + len(other) - intersection, 1) if score >= 0.90: return row_id, score return None, 0.0 def add(self, row_id, sketch): position = len(self.records) self.records.append((row_id, sketch)) for value in self.prefix(sketch): self.postings.setdefault(value, []).append(position) def language_vote(identifier, text): chunks = [text[:30_000], text[max(0, len(text) // 2 - 15_000):len(text) // 2 + 15_000], text[-30_000:]] classified = {chunk: identifier.classify(chunk) for chunk in dict.fromkeys(chunks) if chunk.strip()} votes = [classified[chunk] for chunk in chunks if chunk in classified] languages = Counter(language for language, _ in votes) return (languages.most_common(1)[0][0] if languages else "unknown", votes) def audit_target(out): info = request_json(f"https://huggingface.co/api/datasets/{TARGET}") revision = info["sha"] tree = request_json(f"https://huggingface.co/api/datasets/{TARGET}/tree/{revision}?recursive=true&expand=false") discussions = request_json(f"https://huggingface.co/api/datasets/{TARGET}/discussions?status=open&p=0") paths = sorted(item.get("path", "") for item in tree) open_rows = [{"num": item.get("num"), "title": item.get("title"), "status": item.get("status"), "author": item.get("author", {}).get("name")} for item in discussions.get("discussions", [])] terms = ("uzp", "kio", "orzeczenia_uzp", "zamowienia_publiczne") matches = [path for path in paths if any(term in path.casefold() for term in terms)] discussion_matches = [row for row in open_rows if any(term in (row.get("title") or "").casefold() for term in terms)] report = { "target": TARGET, "revision": revision, "last_modified": info.get("lastModified"), "tree_paths": len(paths), "source_path_matches": matches, "open_discussions": open_rows, "matching_open_discussions": discussion_matches, "source_absent": not matches and not discussion_matches, "observed_at": now(), } save(out / "target_audit.json", report) print(json.dumps({"revision": revision, "source_absent": report["source_absent"], "tree_matches": matches, "discussion_matches": discussion_matches}, ensure_ascii=False, indent=2)) def audit_overlap(out): """Compare our signatures/ids against the shipped SAOS shard (closest legal corpus).""" import pyarrow.parquet as pq from huggingface_hub import HfApi, HfFileSystem revision = HfApi().dataset_info(TARGET).sha remote = f"datasets/{TARGET}@{revision}/data/saos/saos.parquet" try: with HfFileSystem().open(remote, "rb") as handle: table = pq.read_table(handle, columns=["id", "attribution"]) saos_rows = table.to_pylist() except Exception as error: saos_rows = [] print("saos shard unavailable:", error) saos_sigs = set() for row in saos_rows: attribution = row.get("attribution") or "" for sig in re.findall(r"[IVXLCDM]*\s*[A-Z][a-zA-Z]*\s*\d+/\d+", attribution): saos_sigs.add(sig.strip().casefold()) manifest = read_lines(out / "source_manifest.jsonl") results = [] for record in manifest: sig = (record.get("signature") or "").strip() if sig and sig.casefold() in saos_sigs: results.append({"doc_id": record["doc_id"], "signature": sig, "kind": record["kind"]}) report = { "target": f"{TARGET}:data/saos", "target_revision": revision, "method": "case-normalized signature match against SAOS attribution strings", "saos_rows": len(saos_rows), "candidate_records": len(manifest), "signature_collisions": len(results), "text_overlap": "not tested; target-wide text dedup remains an integration gate", "observed_at": now(), "colliding_ids": [r["doc_id"] for r in results], "collisions": results[:500], } save(out / "overlap_audit.json", report) print(json.dumps({key: report[key] for key in ("target_revision", "saos_rows", "candidate_records", "signature_collisions")}, 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 acquisition = load(out / "acquisition.json") selection = load(out / "selection.json") 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 = [], [], [] exact_seen = {} near = NearDuplicateIndex() # pass 1: document frequencies of shingles, to drop boilerplate-heavy # formulas (identical opening lines in ~every KIO ruling) from sketches. df_sketches = [] for record in acquisition["selected"]: if "error" in record: continue raw = (out / record["text_path"]).read_text(encoding="utf-8") df_sketches.append((record["doc_id"], shingle_sketch(normalize(raw)))) df = shingle_document_frequencies(sketch for _, sketch in df_sketches) max_df = max(1, int(len(df_sketches) * DF_FRACTION)) del df_sketches print(f"df pass done: {len(df)} distinct shingles, max_df={max_df}", flush=True) pii = Counter() added = acquisition["observed_at"][:10] for record in acquisition["selected"]: row_id = f"{SOURCE}_{record['doc_id']}" if "error" in record: decisions.append({"id": row_id, "selected": False, "reason": "acquisition_failed", "error": record["error"]}) continue pdf_path = out / record["pdf_path"] text_path = out / record["text_path"] if digest(pdf_path.read_bytes()) != record["pdf_sha256"]: raise ValueError("PDF checksum mismatch: " + str(record["doc_id"])) raw = text_path.read_text(encoding="utf-8") text = normalize(raw) replacement_count = text.count("\ufffd") letters = len(re.findall(r"[A-Za-zĄĆĘŁŃÓŚŹŻąćęłńóśźż]", text)) language, votes = language_vote(identifier, text) reason = "" if len(text) < MIN_TEXT_CHARS: reason = "too_little_extractable_text" elif letters / max(len(text), 1) < 0.55: reason = "low_letter_ratio" elif replacement_count > 100 or replacement_count / max(len(text), 1) > 0.002: reason = "excessive_replacement_characters" elif language != "pl": reason = "non_polish_text" text = text.replace("\ufffd", "[UNREADABLE_GLYPH]") text, counts = redact_pii(text) pii.update(counts) if not reason and len(text) < MIN_TEXT_CHARS: reason = "too_little_text_after_redaction" exact_key = digest(" ".join(text.casefold().split()).encode("utf-8")) duplicate_of, duplicate_score = None, 0.0 if not reason and exact_key in exact_seen: reason, duplicate_of, duplicate_score = "normalized_duplicate", exact_seen[exact_key], 1.0 if not reason: sketch = filter_sketch(shingle_sketch(text), df, max_df) if sketch: duplicate_of, duplicate_score = near.find(sketch) if duplicate_of: reason = "near_duplicate" decision = { "id": row_id, "selected": not bool(reason), "reason": reason or "include", "characters": len(text), "letter_ratio": letters / max(len(text), 1), "replacement_characters": replacement_count, "language": language, "language_votes": [{"language": lang, "confidence": float(score)} for lang, score in votes], } if duplicate_of: decision.update({"duplicate_of": duplicate_of, "jaccard": duplicate_score}) decisions.append(decision) if reason: continue exact_seen[exact_key] = row_id near.add(row_id, sketch) details = record.get("details") or {} organ = record.get("organ") or details.get("organ") or "Unknown" created = iso_date(record.get("issued") or details.get("issued", "")) row = { "id": row_id, "text": text, "source": SOURCE, "added": added, "created": created, "token_count": len(encoder.encode_ordinary(text)), "license": LICENSE_LABEL, "author": organ, } rows.append(row) attribution.append({ "id": row_id, "doc_id": record["doc_id"], "kind": record["kind"], "organ": organ, "doc_type": record.get("doc_type") or details.get("doc_type", ""), "signature": record.get("signature") or details.get("signature", ""), "issued": record.get("issued") or details.get("issued", ""), "chairman": details.get("chairman", ""), "purchaser": details.get("purchaser", ""), "provisions": details.get("provisions", ""), "landing_url": f"{BASE}/Home/Details/{record['doc_id']}", "pdf_url": details.get("pdf_path_url", ""), "pdf_sha256": record["pdf_sha256"], "pdf_bytes": record["pdf_bytes"], "license": LICENSE_LABEL, "license_spdx": LICENSE_SPDX, "legal_basis": LEGAL_BASIS, "text_sha256": digest(text.encode("utf-8")), "transformations": ["per-document PDF via /Home/PdfContent", "pypdf text extraction", "repeated signature running-head and page-number removal", "Unicode/whitespace normalization", "line-wrap repair", "email/labelled-phone/IP/labelled-national-ID/account-candidate pattern redaction"], }) root = out / "hf_repo" (root / "data").mkdir(parents=True, exist_ok=True) (root / "artifacts").mkdir(parents=True, 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) write_lines(root / "artifacts/source_manifest.jsonl", read_lines(out / "source_manifest.jsonl")) sample = sorted(rows, key=lambda row: digest(("sample:" + row["id"]).encode("utf-8")))[:12] write_lines(root / "artifacts/sample.jsonl", sample) save(root / "artifacts/selection.json", selection) save(root / "artifacts/acquisition.json", acquisition) overlap = load(out / "overlap_audit.json") if (out / "overlap_audit.json").exists() else None target_audit = load(out / "target_audit.json") if (out / "target_audit.json").exists() else None if overlap: save(root / "artifacts/overlap_audit.json", overlap) if target_audit: save(root / "artifacts/target_audit.json", target_audit) stats = { "reported_totals": selection["reported_totals"], "enumerated": selection["enumerated"], "per_kind": selection["per_kind"], "acquired": acquisition["acquired"], "failed": len(acquisition["failed"]), "kept": len(rows), "rejected": len(decisions) - len(rows), "rejection_reasons": dict(Counter(d["reason"] for d in decisions if not d["selected"])), "tokens": sum(row["token_count"] for row in rows), "characters": sum(len(row["text"]) for row in rows), "license_counts": dict(Counter(row["license"] for row in rows)), "sample_count": len(sample), "added": added, } save(root / "artifacts/stats.json", stats) qa = { "scope": "all rulings enumerated via /Home/GetResults on orzeczenia.uzp.gov.pl (KIO/SO/SA/SN in public procurement matters)", "license_gate": "official documents excluded from copyright under Polish Copyright Act art. 4(2); no per-record license field exists", "language_gate": "three-window langid vote (pl/en/de/uk/ru)", "pii_pattern_matches": dict(pii), "exact_dedup": True, "near_dedup": "deterministic prefix-indexed capped 5-word-shingle Jaccard >= 0.90 within source; high document-frequency shingles (>2% of docs, i.e. KIO opening-formula boilerplate) excluded from sketches", "near_dedup_comparisons": near.comparisons, "saos_overlap": overlap or "pending", "cross_source_text_dedup": "pending target integration", "limitations": [ "pypdf extraction may retain layout artifacts; tables may be flattened", "pattern checks are not comprehensive de-identification; natural-person names of parties and adjudicators remain part of the official record", "official-document status does not cover third-party material quoted inside rulings", "sequential IDs contain gaps; enumeration follows the server-side result list, not the ID range", ], } save(root / "artifacts/qa.json", qa) protocol_id = "protocol:uzp-orzeczenia-v1" run = { "id": "run:" + digest({"script": digest(Path(__file__).read_bytes()), "selection": selection, "acquisition": digest(acquisition)}), "protocol": protocol_id, "started_at": selection["observed_at"], "finished_at": now(), "success": True, "actor": "actor:devin", "stats": stats, } save(root / "artifacts/run.json", run) excluded = {"README.md", "NOTICE.md", "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 excluded and not path.relative_to(root).as_posix().startswith("src/")} save(root / "artifacts/checksums.json", checks) source_version = "version:source:" + digest({"manifest": selection["source_manifest_sha256"]}) dataset_version = "version:dataset:" + digest(checks) selection_evidence = "evidence:selection:" + digest(selection) acquisition_evidence = "evidence:acquisition:" + digest(acquisition) qa_evidence = "evidence:qa:" + digest(qa) evidence = [ {"id": selection_evidence, "observation_type": "source_inventory_and_selection", "artifact": "artifacts/selection.json", "content_address": digest(selection), "produced_by": run["id"]}, {"id": acquisition_evidence, "observation_type": "pdf_acquisition_and_extraction", "artifact": "artifacts/acquisition.json", "content_address": digest(acquisition), "produced_by": run["id"]}, {"id": qa_evidence, "observation_type": "source_qa", "artifact": "artifacts/qa.json", "content_address": digest(qa), "produced_by": run["id"]}, ] overlap_evidence = None if overlap: overlap_evidence = "evidence:overlap:" + digest(overlap) evidence.append({"id": overlap_evidence, "observation_type": "metadata_overlap_audit", "artifact": "artifacts/overlap_audit.json", "content_address": digest(overlap), "produced_by": run["id"]}) target_evidence = None if target_audit: target_evidence = "evidence:target:" + digest(target_audit) evidence.append({"id": target_evidence, "observation_type": "target_registry_audit", "artifact": "artifacts/target_audit.json", "content_address": digest(target_audit), "produced_by": run["id"]}) ontology = { "schema": "slayer-research-ontology-profile-v1", "objects": [{"id": "object:source:uzp-orzeczenia", "type": "Source"}, {"id": "object:dataset:uzp-orzeczenia-pl", "type": "Dataset"}], "versions": [{"id": source_version, "object": "object:source:uzp-orzeczenia", "content_address": source_version.rsplit(":", 1)[-1]}, {"id": dataset_version, "object": "object:dataset:uzp-orzeczenia-pl", "content_address": dataset_version.rsplit(":", 1)[-1]}], "protocols": [{"id": protocol_id, "procedure": "enumerate /Home/GetResults per kind; fetch /Home/Details metadata and /Home/PdfContent PDF; pypdf extraction; running-head/page-number removal; normalization; PII patterns; exact and near dedup"}], "runs": [run], "evidence": evidence, "claims": [ {"id": "claim:enumeration-complete", "statement": f"The result-list enumeration observed {selection['enumerated']} documents across kinds {selection['per_kind']} matching server-reported totals {selection['reported_totals']}.", "supported_by": [selection_evidence], "falsification_condition": "The preserved manifest does not reproduce the counts or the server totals differ."}, {"id": "claim:official-documents", "statement": "Retained records are official rulings of KIO, district courts, administrative courts and the Supreme Court in public procurement matters, excluded from copyright under Polish Copyright Act art. 4(2).", "supported_by": [selection_evidence, qa_evidence], "falsification_condition": "A retained record is shown to be a non-official or non-ruling document."}, {"id": "claim:slice-retention", "statement": f"The slice retained {stats['kept']} records after text QA and within-source deduplication.", "supported_by": [acquisition_evidence, qa_evidence], "falsification_condition": "The decisions, Parquet rows, or checksums do not reproduce the retention count."}, {"id": "claim:training-value-untested", "statement": "Net corpus novelty and training benefit remain untested hypotheses.", "supported_by": [qa_evidence] + ([overlap_evidence] if overlap_evidence else []), "falsification_condition": "Target-wide text deduplication and controlled ablations establish those properties."}, ], "actors": [{"id": "actor:piotrsty", "type": "Contributor"}, {"id": "actor:uzp", "type": "Organization"}, {"id": "actor:devin", "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": f"hf:dataset:{TARGET}@{target_audit['revision']}"}] if target_audit else []), "pending": ["formal legal review of art. 4(2) application", "cross-source text deduplication", "benchmark contamination check", "third-party quoted material review", "controlled training ablation"], } save(root / "artifacts/ontology.json", ontology) card = f"""--- license: other language: - pl task_categories: - text-generation configs: - config_name: default data_files: - split: train path: data/train-00000-of-00001.parquet --- # UZP Orzeczenia - Polish public-procurement rulings (KIO/SO/SA/SN) Polish-language rulings from the official decision search service of the Public Procurement Office (https://orzeczenia.uzp.gov.pl/): the National Appeals Chamber (KIO), district courts (SO), administrative courts (SA) and the Supreme Court (SN) in public procurement matters. - Enumerated documents: {stats['enumerated']:,} (per kind: {stats['per_kind']}) - Acquired PDFs: {stats['acquired']:,} (failed: {stats['failed']}) - Retained after text QA and within-source deduplication: {stats['kept']:,} - Characters: {stats['characters']:,} - Tokens: {stats['tokens']:,} (`cl100k_base` proxy) - License label: `{LICENSE_LABEL}` ## Provenance and rights Rulings are official documents excluded from copyright under Polish Copyright Act art. 4(2) (LicenseRef-Polish-Official-Documents). No Creative Commons grant is asserted. Each row links to its `/Home/Details` landing URL, PDF URL and checksum; `artifacts/attribution.jsonl` carries organ, document type, signature, issue date, chairman, purchaser and key provisions per record. ## Processing and limitations Text was extracted from the service PDFs with pypdf, then normalized: repeated signature running-heads and page numbers removed, Unicode/whitespace normalization, line-wrap repair, and limited email/phone/IP/identifier/account pattern redaction. Language is checked independently across three text windows; exact and deterministic near deduplication run within the source. Pattern checks are not comprehensive de-identification: names of parties, adjudicators and quoted natural persons remain part of the official record. PDF-derived text may retain layout artifacts and flattened tables. ## Review artifacts See `artifacts/sample.jsonl`, `attribution.jsonl`, `decisions.jsonl`, `source_manifest.jsonl`, `overlap_audit.json`, `stats.json`, `qa.json`, `checksums.json`, `run.json` and `ontology.json`. """ (root / "README.md").write_text(card, encoding="utf-8") (root / "NOTICE.md").write_text( "# Attribution and legal basis\n\n" "Source: UZP decision search service, https://orzeczenia.uzp.gov.pl/ " "(Urzad Zamowien Publicznych / Public Procurement Office).\n\n" "Records are official rulings (KIO, district courts, administrative courts, Supreme Court) in public " "procurement matters. Working basis: Polish Copyright Act art. 4(2) excludes official documents from " "copyright; no per-record license field exists on the service. Formal legal review has not been performed. " "Consult `artifacts/attribution.jsonl` for per-record provenance (organ, signature, issue date, URLs, checksums).\n\n" "Preparation: Piotr Styla with Devin (Cognition). Changes: service-PDF text extraction, running-head and " "page-number removal, Unicode/whitespace normalization, line-wrap repair, limited email/phone/IP/" "identifier/account pattern redaction, language/quality filtering and within-source deduplication. " "Names of parties and adjudicators remain as part of the official record. No endorsement by UZP, KIO " "or the courts is implied.\n", encoding="utf-8", ) print(json.dumps(stats, ensure_ascii=False, indent=2)) def verify(out): import pyarrow.parquet as pq import tiktoken root = out / "hf_repo" table = pq.read_table(root / "data/train-00000-of-00001.parquet") rows = table.to_pylist() stats = load(root / "artifacts/stats.json") 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 sum(item["selected"] for item in decisions) == len(rows) encoder = tiktoken.get_encoding("cl100k_base") assert sum(row["token_count"] for row in rows) == stats["tokens"] for row in rows: assert len(encoder.encode_ordinary(row["text"])) == row["token_count"] assert all(row["source"] == SOURCE and row["license"] == LICENSE_LABEL for row in rows) assert all(EMAIL_RE.search(row["text"]) is None for row in rows) assert all(len(row["text"]) >= MIN_TEXT_CHARS 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) # reconstruct every retained text from the extracted source for att in attribution: doc_id = att["doc_id"] raw = (out / "raw_text" / f"{doc_id}.txt").read_text(encoding="utf-8") text = normalize(raw).replace("\ufffd", "[UNREADABLE_GLYPH]") text, _ = redact_pii(text) assert text == by_id[att["id"]]["text"], f"text mismatch: {doc_id}" assert digest(text.encode("utf-8")) == att["text_sha256"] ontology = load(root / "artifacts/ontology.json") evidence = {item["id"] for item in ontology["evidence"]} assert all(item["falsification_condition"] and set(item["supported_by"]) <= evidence for item in ontology["claims"]) checks = load(root / "artifacts/checksums.json") assert all((root / path).is_file() and digest((root / path).read_bytes()) == checksum for path, checksum in checks.items()) for item in ontology["evidence"]: artifact = root / item["artifact"] assert artifact.is_file() and digest(load(artifact)) == item["content_address"] # residual PII pattern scan residual = { name: sum(bool(pattern.search(row["text"])) for row in rows) for name, pattern in {"email": EMAIL_RE, "labelled_phone": PHONE_RE, "ipv4": IPV4_RE, "ipv6": IPV6_RE}.items() } report = {"verified": True, "residual_patterns": residual, **stats} save(out / "validation_report.json", report) print(json.dumps(report, ensure_ascii=False, indent=2)) def main(): parser = argparse.ArgumentParser() parser.add_argument("--output", type=Path, required=True) parser.add_argument("--workers", type=int, default=8) parser.add_argument("command", choices=["discover", "acquire", "audit_target", "audit_overlap", "build", "verify"]) args = parser.parse_args() if args.command == "discover": discover(args.output, args.workers) elif args.command == "acquire": acquire(args.output, args.workers) elif args.command == "audit_target": audit_target(args.output) elif args.command == "audit_overlap": audit_overlap(args.output) elif args.command == "build": build(args.output) else: verify(args.output) if __name__ == "__main__": main()