| |
| """Derive articles.jsonl from the Constitution 2.0 Core. Standard library only. |
| |
| python3 build_articles.py # verify the committed articles.jsonl |
| python3 build_articles.py --write # regenerate it |
| |
| The dataset rows are DERIVED. The canonical artifact is the Core markdown, byte for |
| byte, at ./constitution-v2.0-core.md. This script exists so that the |
| derivation is reproducible by a stranger rather than trusted: regenerate, and the |
| bytes must be identical to what is committed. |
| |
| Three refusals, each of which has bitten this corpus before: |
| |
| 1. The Core is hash-checked BEFORE parsing. Parsing an unverified source and then |
| reporting the result would attest to whatever happened to be on disk. |
| 2. Exactly 47 articles or the build fails. A silently short corpus is worse than no |
| corpus, because it looks complete. |
| 3. Every emitted `text` must be a byte-exact substring of the Core. A `####` |
| sub-heading is NOT an article boundary -- treating it as one truncated Article 36 |
| to nothing in an earlier build of a different tool, and the check below is what |
| would have caught it. |
| """ |
| import argparse |
| import hashlib |
| import json |
| import os |
| import re |
| import sys |
|
|
| HERE = os.path.dirname(os.path.abspath(__file__)) |
| CORE = os.path.join(HERE, "constitution-v2.0-core.md") |
| OUT = os.path.join(HERE, "data", "articles.jsonl") |
|
|
| CORE_SHA256 = "7e6d12e1025a46cc3a860d6147d79e2362c4d88cb727ce9423854b5008be4c82" |
| EXPECTED_ARTICLES = 47 |
|
|
| |
| |
| ARTICLE_OPEN = re.compile(r"^### +Article +([0-9]+[A-Z]?) *: *(.*)$") |
| BOUNDARY = re.compile(r"^#{1,3}(?!#)\s+\S") |
| PART = re.compile(r"^## +(PART [IVX]+: .*)$") |
|
|
|
|
| def parse(core_text): |
| lines = core_text.split("\n") |
| part = None |
| articles = [] |
| i = 0 |
| while i < len(lines): |
| part_match = PART.match(lines[i]) |
| if part_match: |
| part = part_match.group(1).strip() |
| open_match = ARTICLE_OPEN.match(lines[i]) |
| if not open_match: |
| i += 1 |
| continue |
| start = i |
| j = i + 1 |
| while j < len(lines) and not BOUNDARY.match(lines[j]): |
| j += 1 |
| block = "\n".join(lines[start:j]).rstrip("\n") |
| heading = lines[start] |
| body = "\n".join(lines[start + 1:j]).strip("\n") |
| title = open_match.group(2).strip() |
| spine = "[SPINE" in heading |
| articles.append({ |
| "article_id": open_match.group(1), |
| "title": re.sub(r"\s*\[SPINE.*?\]\s*$", "", title).strip(), |
| "heading": heading, |
| "part": part, |
| "spine": spine, |
| "text": block, |
| "body": body, |
| }) |
| i = j |
| return articles |
|
|
|
|
| def build(): |
| with open(CORE, "rb") as handle: |
| raw = handle.read() |
| actual = hashlib.sha256(raw).hexdigest() |
| if actual != CORE_SHA256: |
| raise SystemExit( |
| "REFUSED: the Core does not match its pinned digest.\n" |
| " expected %s\n actual %s\n" |
| "Parsing an unverified source would attest to whatever is on disk." |
| % (CORE_SHA256, actual)) |
| core_text = raw.decode("utf-8") |
|
|
| articles = parse(core_text) |
| if len(articles) != EXPECTED_ARTICLES: |
| raise SystemExit("REFUSED: found %d articles, expected %d. A short corpus that " |
| "looks complete is worse than no corpus." |
| % (len(articles), EXPECTED_ARTICLES)) |
|
|
| ids = [a["article_id"] for a in articles] |
| if len(set(ids)) != len(ids): |
| raise SystemExit("REFUSED: duplicate article ids: %s" % ids) |
|
|
| for a in articles: |
| for field in ("heading", "text", "body"): |
| if a[field] and a[field] not in core_text: |
| raise SystemExit( |
| "REFUSED: article %s field %r is not a byte-exact substring of the " |
| "Core. The dataset must quote, never paraphrase." |
| % (a["article_id"], field)) |
|
|
| for a in articles: |
| a["source_url"] = "https://article11.ai/constitution-v2.0-core.md" |
| a["source_sha256"] = CORE_SHA256 |
| a["license"] = "CC0-1.0" |
|
|
| lines = [json.dumps(a, ensure_ascii=False, sort_keys=True) for a in articles] |
| return ("\n".join(lines) + "\n").encode("utf-8"), articles |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--write", action="store_true", |
| help="regenerate data/articles.jsonl") |
| args = parser.parse_args() |
|
|
| payload, articles = build() |
| digest = hashlib.sha256(payload).hexdigest() |
| spine = sum(1 for a in articles if a["spine"]) |
|
|
| if args.write: |
| os.makedirs(os.path.dirname(OUT), exist_ok=True) |
| with open(OUT, "wb") as handle: |
| handle.write(payload) |
| print("wrote %s" % OUT) |
| else: |
| if not os.path.exists(OUT): |
| print("data/articles.jsonl is absent; run with --write") |
| return 1 |
| with open(OUT, "rb") as handle: |
| committed = handle.read() |
| if committed != payload: |
| print("MISMATCH: the committed articles.jsonl is not what this script " |
| "derives from the Core.") |
| print(" committed %s" % hashlib.sha256(committed).hexdigest()) |
| print(" derived %s" % digest) |
| return 1 |
| print("committed articles.jsonl matches a fresh derivation") |
|
|
| print(" articles : %d" % len(articles)) |
| print(" spine articles: %d" % spine) |
| print(" bytes : %d" % len(payload)) |
| print(" sha256 : %s" % digest) |
| print(" every field verified as a byte-exact substring of the Core") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
