Upload folder using huggingface_hub

README.md

@@ -0,0 +1,40 @@
+---
+license: cc0-1.0
+pretty_name: Common Crawl document-digest bloom filter
+tags:
+- bloom-filter
+- file-hashes
+---
+
+# Common Crawl document-digest bloom filter
+
+Membership filter over payload sha1 digests of **document-type
+captures** (PDF ~74%, DOC/XLS/PPT/EPUB and similar) from one Common
+Crawl crawl's URL index — the ~1% of CC that isn't HTML. CC digests
+are SHA-1 of the (possibly truncated pre-2025) WARC payload; for
+static documents this equals the file's raw sha1.
+
+- **30,951,194 sha1 keys** (UPPERCASE hex), p = 1e-4, 71 MiB
+- Source: CC-MAIN index `content_digest` column, filtered by MIME
+  (crawl data © Common Crawl, generously public; this digest
+  compilation CC0)
+- One crawl only — a document must have been live and crawled that
+  month to appear; more crawls widen coverage
+
+## Rebuild
+
+`cc_extract_job.py` in this repo streams one crawl's CDXJ index
+(~1 h locally, $0), `cc_digests_to_hex.py` converts the base32
+digests to hex, `./dcso_bloom_build.py cc.sha1.bloom sha1` builds
+the filter.
+
+## Format
+
+DCSO bloom filter format (`github.com/DCSO/bloom`), the same format
+CIRCL publishes hashlookup in: 48-byte little-endian u64 header
+(version, n, p, k, m, N) followed by the bit array. Keys are hex
+digest strings — **UPPERCASE for sha1, lowercase for sha256** (the
+hashlookup convention). Any DCSO-compatible reader works.
+
+Membership answers are probabilistic: p = 1e-4 false-positive rate,
+no false negatives. Confirm anything important against the source.

cc_digests_to_hex.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["duckdb>=1.0"]
+# ///
+"""Convert a digests.parquet (base32 sha1, Common Crawl convention) to
+uppercase-hex lines on stdout, ready for `hdx filters build cc sha1`.
+
+    uv run tools/cc_digests_to_hex.py cc-out/CC-MAIN-2026-30/digests.parquet \
+        > ~/.cache/hashdex/extracts/cc.sha1.hex
+"""
+
+import base64
+import sys
+
+import duckdb
+
+
+def main():
+    if len(sys.argv) != 2:
+        sys.exit(__doc__)
+    con = duckdb.connect()
+    cur = con.execute(
+        "SELECT digest_b32 FROM read_parquet(?)", [sys.argv[1]]
+    )
+    out = sys.stdout
+    bad = 0
+    while batch := cur.fetchmany(100_000):
+        lines = []
+        for (b32,) in batch:
+            try:
+                raw = base64.b32decode(b32)
+            except Exception:
+                bad += 1
+                continue
+            if len(raw) != 20:
+                bad += 1
+                continue
+            lines.append(raw.hex().upper())
+        out.write("\n".join(lines) + "\n")
+    if bad:
+        print(f"skipped {bad} undecodable digests", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

cc_extract_job.py

@@ -0,0 +1,156 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["duckdb>=1.0", "huggingface_hub>=0.30"]
+# ///
+"""Extract non-HTML content digests + inverted index from one Common Crawl
+columnar index, and (optionally) upload the result to a Hugging Face dataset.
+
+Designed to run on HF Jobs (in-AWS, fat pipe to data.commoncrawl.org):
+
+    hf jobs uv run --flavor cpu-upgrade --timeout 4h -s HF_TOKEN \
+        tools/cc_extract_job.py -- --crawl CC-MAIN-2026-30 --repo <user>/hashdex-cc
+
+or locally for a smoke test (a couple of ~600 MB index files):
+
+    uv run tools/cc_extract_job.py --crawl CC-MAIN-2026-30 --limit 2 --no-upload
+
+Outputs, per crawl:
+  index-*.parquet   digest_b32-sorted (digest, url, fetch_time, mime,
+                    warc_filename/offset/length) for every kept capture
+  digests.parquet   distinct digest_b32 (sha1 of payload, base32)
+
+Kept = fetch_status 200, mime_detected not HTML/XHTML, not truncated.
+The digest is CC's WARC-Payload-Digest: sha1 over the transfer payload.
+For identity-served binaries (PDF and friends) that equals sha1 of the
+file bytes; gzip-content-encoded responses do NOT match local files.
+"""
+
+import argparse
+import gzip
+import io
+import json
+import os
+import sys
+import time
+import urllib.request
+
+USER_AGENT = "hashdex-cc/0.1 (hash index research)"
+CC_BASE = "https://data.commoncrawl.org"
+
+
+def fetch_warc_index_paths(crawl: str) -> list[str]:
+    url = f"{CC_BASE}/crawl-data/{crawl}/cc-index-table.paths.gz"
+    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
+    with urllib.request.urlopen(req, timeout=120) as resp:
+        paths = gzip.decompress(resp.read()).decode().splitlines()
+    warc = [p for p in paths if "/subset=warc/" in p]
+    if not warc:
+        sys.exit(f"no subset=warc files listed for {crawl}")
+    return warc
+
+
+def run_extract(con, files: list[str], out_dir: str) -> dict:
+    file_list = ", ".join(f"'{CC_BASE}/{p}'" for p in files)
+    os.makedirs(out_dir, exist_ok=True)
+    t0 = time.time()
+    con.execute(f"""
+        COPY (
+            SELECT content_digest AS digest_b32,
+                   url,
+                   fetch_time,
+                   content_mime_detected AS mime,
+                   warc_filename,
+                   warc_record_offset,
+                   warc_record_length
+            FROM read_parquet([{file_list}])
+            WHERE fetch_status = 200
+              AND content_digest IS NOT NULL
+              AND content_truncated IS NULL
+              AND content_mime_detected IS NOT NULL
+              AND content_mime_detected NOT LIKE 'text/html%'
+              AND content_mime_detected NOT LIKE 'application/xhtml%'
+            ORDER BY digest_b32
+        ) TO '{out_dir}/index.parquet'
+        (FORMAT PARQUET, COMPRESSION ZSTD, ROW_GROUP_SIZE 262144,
+         FILE_SIZE_BYTES '1900MB', FILENAME_PATTERN 'index-{{i}}',
+         OVERWRITE_OR_IGNORE)
+    """)
+    scan_s = time.time() - t0
+    con.execute(f"""
+        COPY (
+            SELECT DISTINCT digest_b32
+            FROM '{out_dir}/index.parquet/*.parquet'
+            ORDER BY digest_b32
+        ) TO '{out_dir}/digests.parquet'
+        (FORMAT PARQUET, COMPRESSION ZSTD)
+    """)
+    rows, distinct = con.execute(f"""
+        SELECT (SELECT count(*) FROM '{out_dir}/index.parquet/*.parquet'),
+               (SELECT count(*) FROM '{out_dir}/digests.parquet')
+    """).fetchone()
+    return {"rows_kept": rows, "distinct_digests": distinct,
+            "scan_seconds": round(scan_s, 1), "files_scanned": len(files)}
+
+
+def upload(repo: str, crawl: str, out_dir: str, stats: dict):
+    from huggingface_hub import HfApi
+
+    api = HfApi()
+    api.create_repo(repo, repo_type="dataset", exist_ok=True)
+    with open(os.path.join(out_dir, "stats.json"), "w") as f:
+        json.dump(stats, f, indent=2)
+    api.upload_folder(
+        repo_id=repo,
+        repo_type="dataset",
+        folder_path=out_dir,
+        path_in_repo=f"crawls/{crawl}",
+        commit_message=f"{crawl}: {stats['distinct_digests']} distinct digests",
+    )
+    print(f"uploaded to https://huggingface.co/datasets/{repo}/tree/main/crawls/{crawl}")
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--crawl", required=True, help="e.g. CC-MAIN-2026-30")
+    ap.add_argument("--repo", help="HF dataset repo to upload to, e.g. user/hashdex-cc")
+    ap.add_argument("--limit", type=int, help="only scan first N index files (smoke test)")
+    ap.add_argument("--out", default="cc-out", help="local output directory")
+    ap.add_argument("--no-upload", action="store_true")
+    ap.add_argument("--threads", type=int, default=0, help="duckdb threads (0 = auto)")
+    ap.add_argument("--memory", default="8GB",
+                    help="duckdb memory_limit; spill goes to <out>/.duckdb-tmp")
+    args = ap.parse_args()
+
+    import duckdb
+
+    files = fetch_warc_index_paths(args.crawl)
+    print(f"{args.crawl}: {len(files)} subset=warc index files", flush=True)
+    if args.limit:
+        files = files[: args.limit]
+        print(f"limited to {len(files)} files", flush=True)
+
+    con = duckdb.connect(config={"custom_user_agent": USER_AGENT})
+    con.execute("INSTALL httpfs; LOAD httpfs")
+    con.execute("SET http_keep_alive=true")
+    con.execute("SET http_retries=6")
+    con.execute("SET preserve_insertion_order=false")
+    con.execute(f"SET memory_limit='{args.memory}'")
+    tmp = os.path.join(args.out, ".duckdb-tmp")
+    os.makedirs(tmp, exist_ok=True)
+    con.execute(f"SET temp_directory='{tmp}'")
+    if args.threads:
+        con.execute(f"SET threads={args.threads}")
+
+    out_dir = os.path.join(args.out, args.crawl)
+    stats = run_extract(con, files, out_dir)
+    print(json.dumps(stats, indent=2), flush=True)
+
+    if args.no_upload:
+        return
+    if not args.repo:
+        sys.exit("--repo required unless --no-upload")
+    upload(args.repo, args.crawl, out_dir, stats)
+
+
+if __name__ == "__main__":
+    main()

dcso_bloom_build.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Build a DCSO-format bloom filter from files of hex digest lines.
+
+Standalone, zero dependencies — everything needed to reproduce the
+.bloom files in this dataset from the digest lists / harvest scripts
+alongside it.
+
+Format (github.com/DCSO/bloom, the format CIRCL hashlookup uses):
+48-byte header of little-endian u64s (version=1, n capacity, p as f64
+bits, k, m, N inserted) followed by ceil(m/64) u64 words of bit array.
+Keys are hex digest STRINGS: UPPERCASE for sha1 (the hashlookup
+convention), lowercase for everything else.
+
+Membership hashing (Go semantics preserved from the reference
+implementation): h = FNV-1 64(key) mod M with M = 2^64 - 87, then k
+rounds of h = (h * g mod 2^64) mod M with g = 18446744073709550147,
+setting bit h mod m each round.
+
+Usage:
+  dcso_bloom_build.py OUT.bloom SCHEME HEXFILE... [--fpp 0.0001]
+  (SCHEME in md5|sha1|sha256 — sets required line length + key case)
+"""
+import math
+import struct
+import sys
+
+MOD = 2**64 - 87
+G = 18446744073709550147
+MASK = 2**64 - 1
+
+HEX_LEN = {"md5": 32, "sha1": 40, "sha256": 64}
+
+
+def fnv1_64(data: bytes) -> int:
+    h = 0xCBF29CE484222325
+    for b in data:
+        h = (h * 0x100000001B3) & MASK
+        h ^= b
+    return h
+
+
+def main() -> None:
+    args = [a for a in sys.argv[1:] if not a.startswith("--")]
+    fpp = 0.0001
+    for a in sys.argv[1:]:
+        if a.startswith("--fpp"):
+            fpp = float(a.split("=", 1)[1] if "=" in a else sys.argv[sys.argv.index(a) + 1])
+    if len(args) < 3 or args[1] not in HEX_LEN:
+        sys.exit(__doc__)
+    out, scheme, inputs = args[0], args[1], args[2:]
+    hex_len = HEX_LEN[scheme]
+    upper = scheme == "sha1"
+
+    n = 0
+    for path in inputs:
+        with open(path) as f:
+            for line in f:
+                t = line.strip()
+                if not t:
+                    continue
+                if len(t) != hex_len or not all(c in "0123456789abcdefABCDEF" for c in t):
+                    sys.exit(f"{path}: line {t!r} is not a {hex_len}-char hex digest")
+                n += 1
+    if n == 0:
+        sys.exit("no digests found in input")
+
+    ln2 = math.log(2)
+    m = math.ceil(n * -math.log(fpp) / (ln2 * ln2))
+    k = max(1, round((m / n) * ln2))
+    words = bytearray((m + 63) // 64 * 8)
+    print(f"building {out}: {n} keys, p={fpp}, {len(words) >> 20} MiB", file=sys.stderr)
+
+    done = 0
+    for path in inputs:
+        with open(path) as f:
+            for line in f:
+                t = line.strip()
+                if not t:
+                    continue
+                key = (t.upper() if upper else t.lower()).encode()
+                h = fnv1_64(key) % MOD
+                for _ in range(k):
+                    h = (h * G & MASK) % MOD
+                    bit = h % m
+                    words[bit >> 6 << 3 | (bit >> 3) & 7] |= 1 << (bit & 7)
+                done += 1
+                if done % 50_000_000 == 0:
+                    print(f"  … {done}/{n}", file=sys.stderr)
+
+    with open(out, "wb") as f:
+        f.write(struct.pack("<6Q", 1, n, struct.unpack("<Q", struct.pack("<d", fpp))[0], k, m, n))
+        f.write(words)
+    print(f"wrote {out}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()