| |
| """Build the text-only Polish Common Voice contribution for DynaWord. |
| |
| The source Parquet embeds audio. This builder uses DuckDB column projection over |
| HTTP and never materializes the audio column or direct contributor metadata. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import collections |
| import datetime as dt |
| import hashlib |
| import importlib.metadata |
| import json |
| import pathlib |
| import platform |
| import re |
| import shutil |
| import sys |
| import unicodedata |
| from typing import Any |
|
|
|
|
| SOURCE_NAME = "common_voice_pl" |
| MIRROR_REPOSITORY = "Peacockery/common-voice-scripted-speech-26" |
| MIRROR_REVISION = "b4d8b94d43831475de59a455345acf6945cfd66e" |
| UPSTREAM_DATASET_ID = "cmqinmu2a00winq07gyrtri0q" |
| UPSTREAM_VERSION = "26.0" |
| UPSTREAM_RELEASE_DATE = "2026-06-12" |
| UPSTREAM_URL = f"https://mozilladatacollective.com/datasets/{UPSTREAM_DATASET_ID}" |
| SOURCE_PARQUET_PATH = ( |
| "data/validated/" |
| "common_voice_scripted_speech_26_0__pl__cmqinmu2a00winq07gyrtri0q.parquet" |
| ) |
| SOURCE_PARQUET_URL = ( |
| f"https://huggingface.co/datasets/{MIRROR_REPOSITORY}/resolve/" |
| f"{MIRROR_REVISION}/{SOURCE_PARQUET_PATH}" |
| ) |
| SOURCE_PARQUET_SHA256 = "abd846a0411d04cf88920161100625e9cbe64a111d17474ac49375f490dafb3a" |
| SOURCE_PARQUET_SIZE = 4_481_707_510 |
| TARGET_REPOSITORY = "SlayerLab/polish-dynaword" |
| OWN_REPOSITORY = "PiotrSty/common-voice-pl-text" |
| SOURCE_LICENSE = "CC0-1.0" |
| AUTHOR = "Mozilla Common Voice contributors" |
| EXPECTED_FIELDS = ( |
| "id", "text", "source", "added", "created", "token_count", "license", "author" |
| ) |
| COMMIT_PATTERN = re.compile(r"^[0-9a-f]{40}$") |
| URL_RE = re.compile(r"(?i)\b(?:https?://|www\.)\S+") |
| EMAIL_RE = re.compile(r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b") |
| PESEL_RE = re.compile(r"(?<!\d)\d{11}(?!\d)") |
| PHONE_RE = re.compile(r"(?<!\d)(?:\+?48[ .-]?)?(?:\d[ .-]?){9}(?!\d)") |
| CONTROL_RE = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]") |
| HTML_RE = re.compile(r"<[^>]{1,120}>") |
| REPEATED_RE = re.compile(r"(.)\1{7,}", re.IGNORECASE) |
|
|
|
|
| class BuildError(ValueError): |
| pass |
|
|
|
|
| def sha256_file(path: pathlib.Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for chunk in iter(lambda: stream.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def canonical_sha256(value: Any) -> str: |
| payload = json.dumps( |
| value, ensure_ascii=False, sort_keys=True, separators=(",", ":") |
| ).encode("utf-8") |
| return hashlib.sha256(payload).hexdigest() |
|
|
|
|
| def write_json(path: pathlib.Path, payload: Any) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text( |
| json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True) + "\n", |
| encoding="utf-8", |
| ) |
|
|
|
|
| def normalize_text(value: str) -> str: |
| value = unicodedata.normalize("NFKC", value or "") |
| value = value.replace("\u00a0", " ").replace("\u200b", "") |
| return " ".join(value.split()).strip() |
|
|
|
|
| def dedup_key(text: str) -> str: |
| folded = unicodedata.normalize("NFKC", text).casefold() |
| folded = "".join(" " if unicodedata.category(ch).startswith("P") else ch for ch in folded) |
| return " ".join(folded.split()) |
|
|
|
|
| def quality_rejection(text: str) -> str | None: |
| if len(text) < 12: |
| return "too_short" |
| if len(text) > 500: |
| return "too_long" |
| if CONTROL_RE.search(text): |
| return "control_character" |
| if HTML_RE.search(text): |
| return "html" |
| if URL_RE.search(text): |
| return "url" |
| if EMAIL_RE.search(text): |
| return "email" |
| if PESEL_RE.search(text): |
| return "pesel_like" |
| if PHONE_RE.search(text): |
| return "phone_like" |
| if REPEATED_RE.search(text): |
| return "repeated_character" |
| letters = sum(ch.isalpha() for ch in text) |
| if letters < 6 or letters / max(1, len(text)) < 0.45: |
| return "low_letter_ratio" |
| return None |
|
|
|
|
| def stable_id(key: str) -> str: |
| return f"{SOURCE_NAME}_{hashlib.sha256(key.encode('utf-8')).hexdigest()}" |
|
|
|
|
| def source_registry_entry() -> str: |
| return f''' "{SOURCE_NAME}": {{ |
| "file_key": "{SOURCE_NAME}", |
| "pretty": "Mozilla Common Voice Polish validated sentences (v26.0)", |
| "license": "{SOURCE_LICENSE}", |
| "license_spdx": "{SOURCE_LICENSE}", |
| "traceable": "Mozilla Data Collective distributes Common Voice Scripted " |
| "Speech 26.0 under CC0-1.0; this text-only projection retains " |
| "only sentences associated with validated recordings.", |
| "upstream": "{UPSTREAM_URL}", |
| "provenance": "Official Mozilla dataset {UPSTREAM_DATASET_ID}, accessed " |
| "through the pinned row-normalized HF mirror " |
| "{MIRROR_REPOSITORY}@{MIRROR_REVISION}.", |
| "domain": "spoken/scripted contemporary sentences", |
| "created": "{UPSTREAM_RELEASE_DATE}, {UPSTREAM_RELEASE_DATE}", |
| "is_ocr": False, |
| "custom_datasheet": True, |
| }}, |
| ''' |
|
|
|
|
| def update_registry(registry: str) -> str: |
| if re.search(rf'^\s{{4}}["\']{SOURCE_NAME}["\']\s*:', registry, re.MULTILINE): |
| required = ( |
| f'"file_key": "{SOURCE_NAME}"', |
| f'"license_spdx": "{SOURCE_LICENSE}"', |
| f'"upstream": "{UPSTREAM_URL}"', |
| ) |
| if not all(value in registry for value in required): |
| raise BuildError(f"existing {SOURCE_NAME} registry entry differs from the contract") |
| return registry |
| marker = ' "global_voices": {' |
| if registry.count(marker) != 1: |
| raise BuildError("cannot locate global_voices registry entry") |
| return registry.replace(marker, source_registry_entry() + marker, 1) |
|
|
|
|
| def source_rows() -> list[dict[str, Any]]: |
| import duckdb |
|
|
| query = """ |
| SELECT |
| sentence_id, sentence, sentence_domain, source_dataset_id, |
| collection, locale, language, license, license_url, |
| duration_ms, up_votes, down_votes |
| FROM read_parquet(?) |
| ORDER BY sentence_id, sentence |
| """ |
| connection = duckdb.connect() |
| try: |
| table = connection.execute(query, [SOURCE_PARQUET_URL]).to_arrow_table() |
| finally: |
| connection.close() |
| return table.to_pylist() |
|
|
|
|
| def aggregate(rows: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], dict[str, Any]]: |
| groups: dict[str, dict[str, Any]] = {} |
| sentence_ids: set[str] = set() |
| rejected: collections.Counter[str] = collections.Counter() |
| contract: collections.Counter[str] = collections.Counter() |
|
|
| for row in rows: |
| if row.get("locale") != "pl" or row.get("language") != "Polish": |
| contract["unexpected_language"] += 1 |
| continue |
| if row.get("source_dataset_id") != UPSTREAM_DATASET_ID: |
| contract["unexpected_dataset_id"] += 1 |
| continue |
| if str(row.get("license") or "").upper() != SOURCE_LICENSE: |
| contract["unexpected_license"] += 1 |
| continue |
| text = normalize_text(str(row.get("sentence") or "")) |
| reason = quality_rejection(text) |
| if reason: |
| rejected[reason] += 1 |
| continue |
| key = dedup_key(text) |
| if not key: |
| rejected["empty_dedup_key"] += 1 |
| continue |
| sentence_id = str(row.get("sentence_id") or "").strip() |
| if not sentence_id: |
| rejected["missing_sentence_id"] += 1 |
| continue |
| sentence_ids.add(sentence_id) |
| current = groups.get(key) |
| candidate = { |
| "key": key, |
| "text": text, |
| "sentence_id": sentence_id, |
| "sentence_ids": {sentence_id}, |
| "clip_count": 1, |
| "duration_ms": int(row.get("duration_ms") or 0), |
| "up_votes": int(row.get("up_votes") or 0), |
| "down_votes": int(row.get("down_votes") or 0), |
| "sentence_domain": str(row.get("sentence_domain") or "").strip(), |
| "collection": str(row.get("collection") or "").strip(), |
| "license_url": str(row.get("license_url") or "").strip(), |
| } |
| if current is None: |
| groups[key] = candidate |
| continue |
| current["clip_count"] += 1 |
| current["duration_ms"] += candidate["duration_ms"] |
| current["up_votes"] = max(current["up_votes"], candidate["up_votes"]) |
| current["down_votes"] = max(current["down_votes"], candidate["down_votes"]) |
| current["sentence_ids"].add(sentence_id) |
| if (sentence_id, text) < (current["sentence_id"], current["text"]): |
| current["sentence_id"] = sentence_id |
| current["text"] = text |
| if not current["sentence_domain"] and candidate["sentence_domain"]: |
| current["sentence_domain"] = candidate["sentence_domain"] |
|
|
| if contract: |
| raise BuildError(f"source contract violations: {dict(contract)}") |
| result = sorted(groups.values(), key=lambda item: (item["key"], item["sentence_id"])) |
| for item in result: |
| item["sentence_id_count"] = len(item.pop("sentence_ids")) |
| diagnostics = { |
| "source_rows": len(rows), |
| "accepted_source_sentence_ids": len(sentence_ids), |
| "rejected_source_rows": sum(rejected.values()), |
| "drop_by_reason_source_rows": dict(sorted(rejected.items())), |
| "normalized_unique_sentences": len(result), |
| "collapsed_accepted_rows": len(rows) - sum(rejected.values()) - len(result), |
| } |
| return result, diagnostics |
|
|
|
|
| def datasheet(stats: dict[str, Any]) -> str: |
| return f"""# Common Voice Polish text v26.0 |
| |
| Text-only projection of Polish sentences associated with validated recordings |
| in Mozilla Common Voice Scripted Speech 26.0. |
| |
| ## Source and scope |
| |
| - Official upstream: {UPSTREAM_URL} |
| - Upstream dataset ID: `{UPSTREAM_DATASET_ID}` |
| - Upstream release: `{UPSTREAM_VERSION}` ({UPSTREAM_RELEASE_DATE}) |
| - Pinned access mirror: `{MIRROR_REPOSITORY}@{MIRROR_REVISION}` |
| - Selected split: `validated` |
| - Language: Polish (`pl`) |
| - License: `{SOURCE_LICENSE}` |
| - Records: {stats['kept']:,} |
| - Tokens: {stats['tokens']:,} (`cl100k_base` proxy) |
| |
| Audio, `client_id`, age, gender, accent, file paths and other direct contributor |
| metadata are not selected. Repeated recordings of the same normalized sentence |
| are represented once; aggregate clip count and duration are retained only in the |
| attribution sidecar. |
| |
| ## Processing |
| |
| 1. Read only selected metadata columns from the pinned Parquet with DuckDB. |
| 2. Require the expected Polish locale, upstream dataset ID and CC0 license. |
| 3. Normalize Unicode and whitespace. |
| 4. Exclude malformed text and simple URL, email, telephone and PESEL-like matches. |
| 5. Collapse case/punctuation-equivalent text within this source. |
| 6. Compute deterministic IDs and `cl100k_base` token counts. |
| |
| This source has not yet been cross-deduplicated against every released DynaWord |
| source. The target integration should run the corpus-wide exact and near-duplicate |
| protocol before a training release. Short isolated sentences should also receive |
| a source cap in training-mix experiments. |
| """ |
|
|
|
|
| def dataset_card(stats: dict[str, Any], payload_revision: str) -> str: |
| return f"""--- |
| license: cc0-1.0 |
| language: |
| - pl |
| task_categories: |
| - text-generation |
| size_categories: |
| - 10K<n<100K |
| pretty_name: Common Voice Polish validated text v26.0 |
| --- |
| |
| # Common Voice Polish validated text v26.0 |
| |
| Versioned text-only research snapshot prepared for Polish DynaWord. It contains |
| {stats['kept']:,} unique Polish sentences associated with validated Common Voice |
| recordings and {stats['tokens']:,} `cl100k_base` proxy tokens. |
| |
| The dataset is derived from [Mozilla Common Voice Scripted Speech 26.0]({UPSTREAM_URL}) |
| through the pinned mirror `{MIRROR_REPOSITORY}@{MIRROR_REVISION}`. The source is |
| distributed under `CC0-1.0`. |
| |
| ## Files |
| |
| - `data/train-00000-of-00001.parquet`: DynaWord-compatible text rows. |
| - `data/common_voice_pl.attribution.jsonl`: non-identifying sentence lineage. |
| - `data/common_voice_pl.sample.jsonl`: deterministic 20-row sample. |
| - `artifacts/common_voice_pl.stats.json`: counts and filter diagnostics. |
| - `artifacts/common_voice_pl.license-evidence.json`: licensing evidence. |
| - `artifacts/common_voice_pl_ontology_manifest.json`: Slayer ontology graph. |
| - `src/fetch_common_voice_pl.py`: deterministic rebuild protocol. |
| |
| The immutable payload revision recorded by the ontology manifest is |
| `{payload_revision}`. Corpus-wide DynaWord deduplication remains an integration |
| step; no claim of cross-source novelty is made here. |
| """ |
|
|
|
|
| def contract_test() -> str: |
| return f'''"""Contract checks for the {SOURCE_NAME} contribution.""" |
| |
| import hashlib |
| import json |
| from pathlib import Path |
| |
| import pyarrow.parquet as pq |
| |
| |
| ROOT = Path(__file__).resolve().parents[1] |
| DATA = ROOT / "data" / "{SOURCE_NAME}" |
| MANIFEST = ROOT / "artifacts" / "{SOURCE_NAME}_ontology_manifest.json" |
| |
| |
| def sha256_file(path): |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for chunk in iter(lambda: stream.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
| |
| |
| def test_schema_and_counts(): |
| parquet = DATA / "{SOURCE_NAME}.parquet" |
| stats = json.loads((DATA / "{SOURCE_NAME}.stats.json").read_text(encoding="utf-8")) |
| table = pq.read_table(parquet) |
| assert table.column_names == {list(EXPECTED_FIELDS)!r} |
| assert table.num_rows == stats["kept"] |
| assert len(set(table.column("id").to_pylist())) == table.num_rows |
| assert len(set(table.column("text").to_pylist())) == table.num_rows |
| assert set(table.column("source").to_pylist()) == {{"{SOURCE_NAME}"}} |
| assert set(table.column("license").to_pylist()) == {{"{SOURCE_LICENSE}"}} |
| |
| |
| def test_privacy_and_sidecars(): |
| stats = json.loads((DATA / "{SOURCE_NAME}.stats.json").read_text(encoding="utf-8")) |
| sidecar = DATA / "{SOURCE_NAME}.attribution.jsonl" |
| sample = DATA / "{SOURCE_NAME}.sample.jsonl" |
| lines = [json.loads(line) for line in sidecar.read_text(encoding="utf-8").splitlines()] |
| assert len(lines) == stats["kept"] |
| assert len(sample.read_text(encoding="utf-8").splitlines()) == min(20, stats["kept"]) |
| forbidden = {{"client_id", "age", "gender", "accents", "path", "audio"}} |
| assert all(not (forbidden & set(item)) for item in lines) |
| |
| |
| def test_manifest_and_checksums(): |
| manifest = json.loads(MANIFEST.read_text(encoding="utf-8")) |
| required = {{"object", "version", "protocol", "run", "relations", "evidence", "claims", "claim_evidence", "actors", "attestations"}} |
| assert required <= set(manifest) |
| assert manifest["ontology_version"] == "slayer.ai/research-ontology/v0.1" |
| assert manifest["version"]["payload_uri"].startswith("hf://datasets/{OWN_REPOSITORY}@") |
| evidence = {{item["observation_type"]: item["payload"] for item in manifest["evidence"]}} |
| checksums = evidence["artifact_checksums"] |
| expected = {{ |
| "parquet_sha256": DATA / "{SOURCE_NAME}.parquet", |
| "attribution_sha256": DATA / "{SOURCE_NAME}.attribution.jsonl", |
| "stats_sha256": DATA / "{SOURCE_NAME}.stats.json", |
| "license_evidence_sha256": DATA / "{SOURCE_NAME}.license-evidence.json", |
| "sample_sha256": DATA / "{SOURCE_NAME}.sample.jsonl", |
| }} |
| if "language_audit_sha256" in checksums: |
| expected["language_audit_sha256"] = ROOT / "artifacts" / "{SOURCE_NAME}_language_audit.json" |
| assert {{key: sha256_file(path) for key, path in expected.items()}} == checksums |
| ''' |
|
|
|
|
| def build_manifest( |
| stats: dict[str, Any], artifact_digests: dict[str, str], payload_revision: str, |
| target_revision: str, run_id: str, run_at: str, script_sha256: str, |
| language_audit: dict[str, Any] | None, |
| ) -> dict[str, Any]: |
| object_id = f"slayer://object/dataset-source/{SOURCE_NAME}" |
| version_digest = canonical_sha256({ |
| "source_revision": MIRROR_REVISION, |
| "upstream_dataset_id": UPSTREAM_DATASET_ID, |
| "artifacts": artifact_digests, |
| }) |
| version_id = f"slayer://version/dataset-source/{SOURCE_NAME}@sha256:{version_digest}" |
| protocol_id = f"slayer://object/protocol/{SOURCE_NAME}-text-projection" |
| protocol_spec = { |
| "entrypoint": "python src/fetch_common_voice_pl.py", |
| "source_path": "src/fetch_common_voice_pl.py", |
| "selection": { |
| "locale": "pl", "language": "Polish", "split": "validated", |
| "columns_excluded": ["audio", "client_id", "age", "gender", "accents", "variant", "path"], |
| }, |
| "normalization": "Unicode NFKC and whitespace collapse", |
| "deduplication": "casefolded punctuation-insensitive exact key within source", |
| "quality_filters": ["length", "control characters", "HTML", "URL", "email", "phone-like", "PESEL-like", "letter ratio"], |
| "tokenizer": "cl100k_base", |
| } |
| protocol_digest = canonical_sha256({"script_sha256": script_sha256, "spec": protocol_spec}) |
| protocol_version_id = f"slayer://version/protocol/{SOURCE_NAME}-text-projection@sha256:{protocol_digest}" |
|
|
| def evidence(kind: str, payload: Any) -> dict[str, Any]: |
| digest = canonical_sha256({"run": run_id, "subject": version_id, "kind": kind, "payload": payload}) |
| return { |
| "id": f"slayer://evidence/{SOURCE_NAME}/{kind}@sha256:{digest}", |
| "run_id": run_id, "subject_version": version_id, |
| "observation_type": kind, "payload": payload, "observed_at": run_at, |
| } |
|
|
| evidence_items = [ |
| evidence("dataset_record_counts", stats), |
| evidence("artifact_checksums", artifact_digests), |
| evidence("license_metadata", { |
| "license": SOURCE_LICENSE, "official_dataset": UPSTREAM_URL, |
| "mirror_revision": MIRROR_REVISION, |
| "source_parquet_sha256": SOURCE_PARQUET_SHA256, |
| "source_parquet_size": SOURCE_PARQUET_SIZE, |
| "artifact": f"data/{SOURCE_NAME}/{SOURCE_NAME}.license-evidence.json", |
| }), |
| evidence("direct_metadata_exclusion", { |
| "selected_direct_identifiers": 0, |
| "excluded_columns": protocol_spec["selection"]["columns_excluded"], |
| "text_filter_drop_counts": stats["drop_by_reason_source_rows"], |
| }), |
| evidence("target_registry_check", { |
| "target": f"hf://datasets/{TARGET_REPOSITORY}@{target_revision}", |
| "source_key_absent_before_contribution": True, |
| "cross_source_exact_dedup_completed": False, |
| "cross_source_near_dedup_completed": False, |
| }), |
| evidence("schema_validation", {"schema": list(EXPECTED_FIELDS), "records": stats["kept"], "valid": True}), |
| ] |
| if language_audit is not None: |
| evidence_items.append(evidence("language_audit", { |
| "artifact": f"artifacts/{SOURCE_NAME}_language_audit.json", |
| "sha256": artifact_digests["language_audit_sha256"], |
| "sample_rows": language_audit["sample_rows"], |
| "polish_share": language_audit["polish_share"], |
| "interpretation_limit": language_audit["interpretation_limit"], |
| })) |
| by_type = {item["observation_type"]: item["id"] for item in evidence_items} |
|
|
| def claim(statement: str, falsification: str, supports: list[str]) -> dict[str, Any]: |
| digest = canonical_sha256({"scope": version_id, "statement": statement, "falsification": falsification}) |
| return { |
| "id": f"slayer://claim/{SOURCE_NAME}@sha256:{digest}", |
| "scope": version_id, "statement": statement, "asserted_by": "hf:PiotrSty", |
| "supported_by": supports, "falsification_condition": falsification, |
| } |
|
|
| claims = [ |
| claim( |
| "The artifact contains one retained row per within-source normalized sentence after the recorded filters.", |
| "A retained normalized key occurs more than once or an accepted key is absent without a recorded rejection.", |
| [by_type["dataset_record_counts"], by_type["schema_validation"]], |
| ), |
| claim( |
| "The pinned source records and official dataset page identify the selected material as CC0-1.0.", |
| "The pinned records or official dataset terms identify a conflicting license.", |
| [by_type["license_metadata"]], |
| ), |
| claim( |
| "No source client identifier, demographic field, path or audio payload is included in the published projection.", |
| "A forbidden direct-source metadata field is present in the Parquet or attribution sidecar.", |
| [by_type["direct_metadata_exclusion"], by_type["schema_validation"]], |
| ), |
| claim( |
| "The source key was absent from the pinned DynaWord registry before this contribution; corpus-wide novelty is not asserted.", |
| "The source key exists in the pinned pre-contribution registry or this contribution asserts completed cross-source deduplication.", |
| [by_type["target_registry_check"]], |
| ), |
| ] |
| claim_links = [ |
| {"claim_id": item["id"], "evidence_id": evidence_id, "relation": "SUPPORTS", "introduced_by_run": run_id} |
| for item in claims for evidence_id in item["supported_by"] |
| ] |
| source_version = f"hf://datasets/{MIRROR_REPOSITORY}@{MIRROR_REVISION}" |
| upstream_version = f"mdc://dataset/{UPSTREAM_DATASET_ID}@{UPSTREAM_VERSION}" |
| target_version = f"hf://datasets/{TARGET_REPOSITORY}@{target_revision}" |
|
|
| def attestation(kind: str, value: Any, supports: list[str]) -> dict[str, Any]: |
| payload = { |
| "type": kind, "value": value, "actor_id": "hf:PiotrSty", |
| "subject_version": version_id, "supported_by": supports, |
| } |
| digest = canonical_sha256(payload) |
| return { |
| "id": f"slayer://attestation/{SOURCE_NAME}/{kind}@sha256:{digest}", |
| **payload, "created_at": run_at, |
| } |
|
|
| return { |
| "schema_version": "slayer.ai/dataset-source-contribution/v1", |
| "ontology_version": "slayer.ai/research-ontology/v0.1", |
| "object": {"id": object_id, "kind": "dataset_source", "name": SOURCE_NAME, "metadata": {"language": "pl", "domain": "spoken/scripted", "provider": "Mozilla Data Collective"}}, |
| "version": { |
| "id": version_id, "object_id": object_id, "digest": f"sha256:{version_digest}", |
| "schema_version": "slayer.ai/dataset-source/v1", |
| "payload_uri": f"hf://datasets/{OWN_REPOSITORY}@{payload_revision}/data/train-00000-of-00001.parquet", |
| "created_at": run_at, "created_by": "hf:PiotrSty", |
| }, |
| "protocol": { |
| "id": protocol_id, "kind": "dataset_filtering", "name": f"{SOURCE_NAME}-text-projection", |
| "version": { |
| "id": protocol_version_id, "object_id": protocol_id, |
| "digest": f"sha256:{protocol_digest}", "code_sha256": script_sha256, |
| "schema_version": "slayer.ai/protocol/v1", |
| "payload_uri": f"hf://datasets/{OWN_REPOSITORY}@{payload_revision}/src/fetch_common_voice_pl.py", |
| "created_at": run_at, "created_by": "hf:PiotrSty", |
| }, |
| "specification": protocol_spec, |
| }, |
| "run": { |
| "id": run_id, "protocol_version_id": protocol_version_id, "actor_id": "hf:PiotrSty", |
| "git_commit": payload_revision, "started_at": run_at, "finished_at": run_at, |
| "config": protocol_spec, |
| "environment": { |
| "python": sys.version, "platform": platform.platform(), "machine": platform.machine(), |
| "packages": {name: importlib.metadata.version(name) for name in ("duckdb", "pyarrow", "tiktoken")}, |
| "determinism": {"sampling": "hash-ranked sample only", "seed": "sha256(sample:id)"}, |
| }, |
| "inputs": [ |
| {"role": "official_upstream", "version_id": upstream_version}, |
| {"role": "access_mirror", "version_id": source_version}, |
| {"role": "target_base", "version_id": target_version}, |
| ], |
| "outputs": [{"role": "dataset_source", "version_id": version_id}], |
| }, |
| "relations": [ |
| {"source_version_id": version_id, "predicate": "DERIVED_FROM", "target_version_id": source_version, "introduced_by_run": run_id}, |
| {"source_version_id": source_version, "predicate": "MIRRORS", "target_version_id": upstream_version, "introduced_by_run": run_id}, |
| {"source_version_id": version_id, "predicate": "FILTERED_BY", "target_version_id": protocol_version_id, "introduced_by_run": run_id}, |
| {"source_version_id": version_id, "predicate": "COMPATIBLE_WITH", "target_version_id": target_version, "introduced_by_run": run_id}, |
| ], |
| "evidence": evidence_items, |
| "claims": claims, |
| "claim_evidence": claim_links, |
| "actors": [ |
| {"id": "hf:PiotrSty", "kind": "human", "identity": "Piotr Styła", "identifiers": {"hugging_face": "PiotrSty", "github": "PiotrStyla"}}, |
| {"id": "org:mozilla-data-collective", "kind": "organization", "identity": "Mozilla Data Collective", "identifiers": {"dataset_id": UPSTREAM_DATASET_ID}}, |
| {"id": "agent:codex", "kind": "agent", "identity": "OpenAI Codex", "identifiers": {}}, |
| ], |
| "attestations": [ |
| attestation("schema_valid", True, [by_type["schema_validation"], by_type["artifact_checksums"]]), |
| attestation("license_status", "documented_cc0_1_0", [by_type["license_metadata"]]), |
| attestation("cross_source_deduplication", "pending_target_integration", [by_type["target_registry_check"]]), |
| ], |
| } |
|
|
|
|
| def build(args: argparse.Namespace) -> dict[str, Any]: |
| if not COMMIT_PATTERN.fullmatch(args.target_revision): |
| raise BuildError("target revision must be a 40-character commit") |
| if not COMMIT_PATTERN.fullmatch(args.payload_revision): |
| raise BuildError("payload revision must be a 40-character commit") |
| if not args.target_registry.is_file(): |
| raise BuildError("target sources.py is missing") |
| registry = args.target_registry.read_text(encoding="utf-8") |
| if re.search(rf'^\s{{4}}["\']{SOURCE_NAME}["\']\s*:', registry, re.MULTILINE): |
| raise BuildError(f"{SOURCE_NAME} already exists in the pinned target registry") |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| import tiktoken |
|
|
| source = source_rows() |
| retained, diagnostics = aggregate(source) |
| encoder = tiktoken.get_encoding("cl100k_base") |
| schema = pa.schema([ |
| ("id", pa.string()), ("text", pa.string()), ("source", pa.string()), |
| ("added", pa.string()), ("created", pa.string()), ("token_count", pa.int64()), |
| ("license", pa.string()), ("author", pa.string()), |
| ]) |
| rows: list[dict[str, Any]] = [] |
| sidecars: list[dict[str, Any]] = [] |
| domains: collections.Counter[str] = collections.Counter() |
| for item in retained: |
| identifier = stable_id(item["key"]) |
| token_count = len(encoder.encode_ordinary(item["text"])) |
| rows.append({ |
| "id": identifier, "text": item["text"], "source": SOURCE_NAME, |
| "added": args.added_date, "created": UPSTREAM_RELEASE_DATE, |
| "token_count": token_count, "license": SOURCE_LICENSE, "author": AUTHOR, |
| }) |
| domain = item["sentence_domain"] or "unspecified" |
| domains[domain] += 1 |
| sidecars.append({ |
| "id": identifier, "sentence_id": item["sentence_id"], |
| "sentence_id_count": item["sentence_id_count"], "clip_count": item["clip_count"], |
| "total_duration_ms": item["duration_ms"], "up_votes": item["up_votes"], |
| "down_votes": item["down_votes"], "sentence_domain": domain, |
| "source_dataset_id": UPSTREAM_DATASET_ID, "upstream_version": UPSTREAM_VERSION, |
| "mirror_repository": MIRROR_REPOSITORY, "mirror_revision": MIRROR_REVISION, |
| "license": SOURCE_LICENSE, |
| }) |
|
|
| if not rows: |
| raise BuildError("all source rows were filtered") |
| stats = { |
| **diagnostics, |
| "kept": len(rows), "chars": sum(len(row["text"]) for row in rows), |
| "whitespace_words": sum(len(row["text"].split()) for row in rows), |
| "tokens": sum(row["token_count"] for row in rows), |
| "source": SOURCE_NAME, "license": SOURCE_LICENSE, |
| "licenses": {SOURCE_LICENSE: len(rows)}, "authors_with_value": len(rows), |
| "added": args.added_date, "created_min": UPSTREAM_RELEASE_DATE, |
| "created_max": UPSTREAM_RELEASE_DATE, "by_sentence_domain": dict(sorted(domains.items())), |
| "source_repository": MIRROR_REPOSITORY, "source_revision": MIRROR_REVISION, |
| "source_parquet_path": SOURCE_PARQUET_PATH, |
| "source_parquet_sha256": SOURCE_PARQUET_SHA256, |
| "source_parquet_size": SOURCE_PARQUET_SIZE, |
| "upstream_dataset_id": UPSTREAM_DATASET_ID, "upstream_version": UPSTREAM_VERSION, |
| "target_base_revision": args.target_revision, |
| "cross_source_exact_dedup_completed": False, |
| "cross_source_near_dedup_completed": False, |
| "stats_recomputed_from_output_rows": True, |
| } |
| run_at = args.run_at |
| run_id = f"common-voice-pl-v26-{run_at.replace(':', '').replace('-', '')}" |
| script_path = pathlib.Path(__file__).resolve() |
| script_sha256 = sha256_file(script_path) |
|
|
| hf_root = args.output / "hf_repo" |
| pr_root = args.output / "dynaword_pr" |
| for directory in (hf_root / "data", hf_root / "artifacts", hf_root / "src", pr_root / "data" / SOURCE_NAME, pr_root / "artifacts", pr_root / "src"): |
| directory.mkdir(parents=True, exist_ok=True) |
|
|
| hf_parquet = hf_root / "data" / "train-00000-of-00001.parquet" |
| pq.write_table(pa.Table.from_pylist(rows, schema=schema), hf_parquet, compression="zstd", row_group_size=4096) |
| pr_parquet = pr_root / "data" / SOURCE_NAME / f"{SOURCE_NAME}.parquet" |
| shutil.copy2(hf_parquet, pr_parquet) |
|
|
| sidecar_text = "".join(json.dumps(item, ensure_ascii=False, sort_keys=True) + "\n" for item in sidecars) |
| sample_rows = sorted(rows, key=lambda row: hashlib.sha256(("sample:" + row["id"]).encode()).hexdigest())[:20] |
| sample_text = "".join(json.dumps(item, ensure_ascii=False, sort_keys=True) + "\n" for item in sample_rows) |
| for root, data_dir in ((hf_root, hf_root / "data"), (pr_root, pr_root / "data" / SOURCE_NAME)): |
| (data_dir / f"{SOURCE_NAME}.attribution.jsonl").write_text(sidecar_text, encoding="utf-8") |
| (data_dir / f"{SOURCE_NAME}.sample.jsonl").write_text(sample_text, encoding="utf-8") |
| write_json(data_dir / f"{SOURCE_NAME}.stats.json", stats) |
| write_json(data_dir / f"{SOURCE_NAME}.license-evidence.json", { |
| "status": "documented-open-cc0", |
| "license": SOURCE_LICENSE, |
| "official_dataset": UPSTREAM_URL, |
| "official_dataset_id": UPSTREAM_DATASET_ID, |
| "upstream_release": UPSTREAM_VERSION, |
| "upstream_release_date": UPSTREAM_RELEASE_DATE, |
| "pinned_access_mirror": f"hf://datasets/{MIRROR_REPOSITORY}@{MIRROR_REVISION}/{SOURCE_PARQUET_PATH}", |
| "source_parquet_sha256": SOURCE_PARQUET_SHA256, |
| "source_parquet_size": SOURCE_PARQUET_SIZE, |
| "spdx": "https://spdx.org/licenses/CC0-1.0.html", |
| "creative_commons": "https://creativecommons.org/publicdomain/zero/1.0/", |
| "finding": "The official dataset page and pinned mirror identify the release as CC0-1.0.", |
| "review_scope": "dataset-level license metadata; not independent legal advice", |
| }) |
| (data_dir / f"{SOURCE_NAME}.md").write_text(datasheet(stats), encoding="utf-8") |
| (data_dir / "NOTICE.md").write_text( |
| "# Attribution and provenance\n\nSource: Mozilla Data Collective, Common Voice " |
| f"Scripted Speech {UPSTREAM_VERSION} - Polish (`{UPSTREAM_DATASET_ID}`). " |
| f"License: `{SOURCE_LICENSE}`. Text-only preparation: Piotr Styla.\n", |
| encoding="utf-8", |
| ) |
|
|
| artifact_digests = { |
| "parquet_sha256": sha256_file(pr_parquet), |
| "attribution_sha256": sha256_file(pr_root / "data" / SOURCE_NAME / f"{SOURCE_NAME}.attribution.jsonl"), |
| "stats_sha256": sha256_file(pr_root / "data" / SOURCE_NAME / f"{SOURCE_NAME}.stats.json"), |
| "license_evidence_sha256": sha256_file(pr_root / "data" / SOURCE_NAME / f"{SOURCE_NAME}.license-evidence.json"), |
| "sample_sha256": sha256_file(pr_root / "data" / SOURCE_NAME / f"{SOURCE_NAME}.sample.jsonl"), |
| } |
| language_audit = None |
| if args.language_audit: |
| language_audit = json.loads(args.language_audit.read_text(encoding="utf-8")) |
| for root in (hf_root, pr_root): |
| shutil.copy2(args.language_audit, root / "artifacts" / f"{SOURCE_NAME}_language_audit.json") |
| artifact_digests["language_audit_sha256"] = sha256_file(args.language_audit) |
| manifest = build_manifest( |
| stats, artifact_digests, args.payload_revision, args.target_revision, |
| run_id, run_at, script_sha256, language_audit, |
| ) |
| for root in (hf_root, pr_root): |
| write_json(root / "artifacts" / f"{SOURCE_NAME}_ontology_manifest.json", manifest) |
| shutil.copy2(script_path, root / "src" / "fetch_common_voice_pl.py") |
| (hf_root / "README.md").write_text(dataset_card(stats, args.payload_revision), encoding="utf-8") |
| (pr_root / "src" / "sources.py").write_text(update_registry(registry), encoding="utf-8") |
| (pr_root / "src" / "test_common_voice_pl_contract.py").write_text(contract_test(), encoding="utf-8") |
| write_json(args.output / "build_summary.json", {"stats": stats, "artifact_digests": artifact_digests, "payload_revision": args.payload_revision}) |
| return stats |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--target-registry", type=pathlib.Path, required=True) |
| parser.add_argument("--target-revision", required=True) |
| parser.add_argument("--payload-revision", required=True) |
| parser.add_argument("--output", type=pathlib.Path, required=True) |
| parser.add_argument("--language-audit", type=pathlib.Path) |
| parser.add_argument("--added-date", default="2026-09-05") |
| parser.add_argument("--run-at", default="2026-09-05T12:00:00Z") |
| args = parser.parse_args() |
| stats = build(args) |
| print(json.dumps(stats, ensure_ascii=False, indent=2, sort_keys=True)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
