feat(data): add biblioteka_nauki source (42,071 docs, per-document license + attribution)

data/biblioteka_nauki/biblioteka_nauki.md

@@ -0,0 +1,60 @@
+# biblioteka_nauki
+
+Biblioteka Nauki — Polish open-access scholarly corpus (scientific articles, books, chapters)
+
+## Dataset description
+- **Source (upstream):** https://bibliotekanauki.pl (operated by ICM, University of Warsaw — Centrum Otwartej Nauki)
+- **Domain:** academic (scientific articles, books, chapters)
+- **Language:** Polish (pl)
+- **License:** per-document — CC BY 4.0 28,335 · CC BY-SA 4.0 13,733 · Public Domain 3
+- **Created (range):** per-document publication year, from each item's bibliotekanauki.pl metadata
+- **Added:** 2026-06-27
+
+## Licensing — traceable basis
+The SpeakLeash blob carries no per-document license field, and ~53% of the upstream collection is
+all-rights-reserved, so a per-item gate was mandatory. Each item's license was recovered from the
+bibliotekanauki.pl API (`bibliotekanauki.pl/api/{type}/<id>` → `license.iconId`). Only openly-licensed
+items are kept; all-rights-reserved and unknown items are gated out. Recovery yielded 43,576 clean ids.
+
+| license | documents |
+|---|---:|
+| CC BY 4.0 | 28,335 |
+| CC BY-SA 4.0 | 13,733 |
+| Public Domain | 3 |
+
+The per-document license is carried in the parquet `license` column.
+
+## Attribution
+Per-document attribution (author · year · title · publisher) was re-fetched 1:1 from
+bibliotekanauki.pl (43,576 / 43,576 ok) and is carried in the parquet `attribution` column,
+satisfying the CC BY / CC BY-SA attribution requirement that applies to every document here.
+
+## Provenance
+Pulled from SpeakLeash's public redistribution (`speakleash-ds-pub`, key `biblioteka_nauki_pl_corpus`)
+of the upstream source above. SpeakLeash credited as intermediate aggregator; upstream license and
+attribution recovered per document and preserved.
+
+## Statistics
+| documents | characters | tokens (tiktoken proxy) |
+|---:|---:|---:|
+| 42,071 | 1,748,333,935 | 673,488,831 |
+
+## Filters applied (build_dynaword.py)
+Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
+- drop documents < 200 chars: **0**
+- drop non-Polish (diacritic ratio): **925**
+- exact cross-source dedup (sha1): **180**
+- OCR alpha-ratio < 0.70 (OCR source): **400**
+- read 43,576 → kept 42,071
+
+Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
+Llama-3 count is computed at release.
+
+## Limitations
+- **Mixed license.** Roughly one third of the documents are CC BY-SA 4.0 (share-alike); the exact
+  per-document license is in the `license` column. Downstream redistribution must respect share-alike
+  for those documents.
+- **OCR / extraction noise.** Text is extracted from publisher PDFs; some layout and hyphenation
+  artefacts remain after the alpha-ratio filter.
+- **Per-document dates.** `created` is the publication year from upstream metadata; finer-grained
+  dates are not available.

data/biblioteka_nauki/biblioteka_nauki.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc93cdd5ca3e6576a1da0aa294df1308e879b8516ac30911289e430c69a07b26
+size 1076638904

data/biblioteka_nauki/biblioteka_nauki.stats.json

@@ -0,0 +1,12 @@
+{
+  "read": 43576,
+  "kept": 42071,
+  "drop_short": 0,
+  "drop_lang": 925,
+  "drop_dup": 180,
+  "drop_ocr": 400,
+  "chars": 1748333935,
+  "tokens": 673488831,
+  "secs": 484.1,
+  "license": "CC-BY-4.0 / CC-BY-SA-4.0"
+}

data/biblioteka_nauki/recover_attribution.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""Targeted attribution pass for the CLEAN (CC-BY/CC-BY-SA/PD) Biblioteka Nauki ids ONLY.
+The first recovery pass stored the license correctly but parsed the wrong attribution fields.
+CC-BY/CC-BY-SA legally REQUIRE attribution, so re-fetch just the ~43.6k clean ids and extract:
+  authors = contributors[role=AUTHOR] firstName+lastName ; year = dates[PUBLISHED].date.year ;
+  title = mainTitle.text ; publisher = publishingCompanyInfo.name
+
+  licenses.jsonl -> attribution.jsonl  {type,id,license,authors,year,title,publisher}
+Resumable, threaded, polite. ~43.6k calls.
+"""
+import json, os, random, sys, threading, time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import requests
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+LIC = os.path.join(HERE, "licenses.jsonl")
+OUT = os.path.join(HERE, "attribution.jsonl")
+PROG = os.path.join(HERE, "attribution_progress.txt")
+CLEAN = {"cc-by", "cc-by-sa", "cc0", "public-domain"}
+WORKERS = 8
+UA = ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
+      "(KHTML, like Gecko) Chrome/124 Safari/537.36")
+HEADERS = {"User-Agent": UA, "Accept": "application/json", "Referer": "https://bibliotekanauki.pl/"}
+_local = threading.local()
+_wlock = threading.Lock()
+
+
+def session():
+    s = getattr(_local, "s", None)
+    if s is None:
+        s = requests.Session()
+        s.headers.update(HEADERS)
+        s.mount("https://", requests.adapters.HTTPAdapter(pool_connections=4, pool_maxsize=4))
+        _local.s = s
+    return s
+
+
+def parse(d):
+    authors = []
+    for c in (d.get("contributors") or []):
+        if c.get("role") == "AUTHOR":
+            nm = f"{c.get('firstName','') or ''} {c.get('lastName','') or ''}".strip()
+            if nm:
+                authors.append(nm)
+    year = None
+    dates = d.get("dates") or []
+    for dt in dates:
+        if dt.get("type") == "PUBLISHED":
+            year = (dt.get("date") or {}).get("year")
+            break
+    if not year and dates:
+        year = (dates[0].get("date") or {}).get("year")
+    title = (d.get("mainTitle") or {}).get("text")
+    pub = (d.get("publishingCompanyInfo") or {}).get("name")
+    return authors[:20], (str(year) if year else None), title, pub
+
+
+def fetch(item):
+    typ, _id, lic = item
+    url = f"https://bibliotekanauki.pl/api/{typ}/{_id}"
+    for attempt in range(4):
+        try:
+            r = session().get(url, timeout=25)
+            if r.status_code == 200:
+                a, y, t, p = parse(r.json())
+                return {"type": typ, "id": _id, "license": lic,
+                        "authors": a, "year": y, "title": t, "publisher": p, "status": "ok"}
+            if r.status_code in (403, 404, 410):
+                return {"type": typ, "id": _id, "license": lic, "status": f"http{r.status_code}"}
+            time.sleep((2 ** attempt) + random.random())
+        except Exception as e:
+            if attempt == 3:
+                return {"type": typ, "id": _id, "license": lic, "status": f"err:{type(e).__name__}"}
+            time.sleep((2 ** attempt) + random.random())
+    return {"type": typ, "id": _id, "license": lic, "status": "err:retries"}
+
+
+def main():
+    best = {}
+    for l in open(LIC, encoding="utf-8"):
+        try:
+            r = json.loads(l)
+        except Exception:
+            continue
+        best[(r["type"], r["id"])] = r
+    clean = [(t, i, r["iconId"]) for (t, i), r in best.items()
+             if r.get("status") == "ok" and r.get("iconId") in CLEAN]
+    done = set()
+    if os.path.exists(OUT):
+        for l in open(OUT, encoding="utf-8"):
+            try:
+                r = json.loads(l)
+                done.add((r["type"], r["id"]))
+            except Exception:
+                pass
+    todo = [c for c in clean if (c[0], c[1]) not in done]
+    print(f"clean={len(clean)} done={len(done)} todo={len(todo)} workers={WORKERS}", flush=True)
+
+    out = open(OUT, "a", encoding="utf-8")
+    n = len(done)
+    t0 = time.time()
+    counts = {}
+    with ThreadPoolExecutor(max_workers=WORKERS) as ex:
+        futs = [ex.submit(fetch, c) for c in todo]
+        for fut in as_completed(futs):
+            res = fut.result()
+            with _wlock:
+                out.write(json.dumps(res, ensure_ascii=False) + "\n")
+            n += 1
+            counts[res.get("status")] = counts.get(res.get("status"), 0) + 1
+            time.sleep(random.uniform(0.02, 0.10))
+            if n % 500 == 0:
+                out.flush()
+                rate = (n - len(done)) / max(time.time() - t0, 1)
+                eta = (len(clean) - n) / max(rate, 0.1) / 60
+                msg = f"{n}/{len(clean)} {rate:.1f}/s ETA {eta:.0f}m " + \
+                      " ".join(f"{k}={v}" for k, v in sorted(counts.items()))
+                print(msg, flush=True)
+                open(PROG, "w").write(msg + "\n")
+    out.flush(); out.close()
+    print(f"DONE attribution: {n}/{len(clean)} counts={counts}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

data/biblioteka_nauki/recover_licenses.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""Pass 2: recover the per-item license for every Biblioteka Nauki doc via the public API.
+  index.jsonl  ->  GET bibliotekanauki.pl/api/{type}/{id}  ->  licenses.jsonl
+
+Resumable (skips ids already in licenses.jsonl), polite (modest concurrency + jitter + backoff),
+keep-alive sessions, and a circuit-breaker if the host starts blocking us.
+
+Output line: {type,id, iconId, cc(bool), restricted(bool), authors, year, source, status}
+  status: "ok" | "http404" | "http403" | "err:<Type>"
+"""
+import json, os, random, sys, threading, time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import requests
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+INDEX = os.path.join(HERE, "index.jsonl")
+OUT = os.path.join(HERE, "licenses.jsonl")
+PROG = os.path.join(HERE, "recover_progress.txt")
+
+WORKERS = 8
+TIMEOUT = 25
+MAX_RETRY = 4
+UA = ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
+      "(KHTML, like Gecko) Chrome/124 Safari/537.36")
+HEADERS = {"User-Agent": UA, "Accept": "application/json", "Referer": "https://bibliotekanauki.pl/"}
+
+_local = threading.local()
+_write_lock = threading.Lock()
+_recent = []            # rolling window of recent statuses for the circuit breaker
+_recent_lock = threading.Lock()
+_stop = threading.Event()
+
+
+def session():
+    s = getattr(_local, "s", None)
+    if s is None:
+        s = requests.Session()
+        s.headers.update(HEADERS)
+        a = requests.adapters.HTTPAdapter(pool_connections=4, pool_maxsize=4)
+        s.mount("https://", a)
+        _local.s = s
+    return s
+
+
+def load_done():
+    done = set()
+    if os.path.exists(OUT):
+        with open(OUT, encoding="utf-8") as f:
+            for line in f:
+                try:
+                    r = json.loads(line)
+                    done.add((r["type"], r["id"]))
+                except Exception:
+                    pass
+    return done
+
+
+def fetch(item):
+    if _stop.is_set():
+        return None
+    typ, _id = item["type"], item["id"]
+    url = f"https://bibliotekanauki.pl/api/{typ}/{_id}"
+    for attempt in range(MAX_RETRY):
+        try:
+            r = session().get(url, timeout=TIMEOUT)
+            if r.status_code == 200:
+                d = r.json()
+                lic = d.get("license") or {}
+                authors = []
+                for c in (d.get("contributors") or []):
+                    nm = (c.get("name") or "").strip()
+                    if nm:
+                        authors.append(nm)
+                year = None
+                for dt in (d.get("dates") or []):
+                    y = str(dt.get("year") or dt.get("value") or "")[:4]
+                    if y.isdigit():
+                        year = y
+                        break
+                insts = d.get("publicationInstitutions") or d.get("journal") or None
+                if isinstance(insts, list):
+                    insts = "; ".join(x.get("name", "") if isinstance(x, dict) else str(x) for x in insts) or None
+                return {
+                    "type": typ, "id": _id,
+                    "iconId": lic.get("iconId"),
+                    "cc": bool(lic.get("creativeCommons")),
+                    "restricted": bool(d.get("restricted")),
+                    "authors": authors[:12],
+                    "year": year,
+                    "source": insts,
+                    "status": "ok",
+                }
+            if r.status_code in (403,):
+                return {"type": typ, "id": _id, "status": "http403"}
+            if r.status_code in (404, 410):
+                return {"type": typ, "id": _id, "status": "http404"}
+            # 429 / 5xx -> backoff & retry
+            time.sleep((2 ** attempt) + random.random())
+        except Exception as e:
+            if attempt == MAX_RETRY - 1:
+                return {"type": typ, "id": _id, "status": f"err:{type(e).__name__}"}
+            time.sleep((2 ** attempt) + random.random())
+    return {"type": typ, "id": _id, "status": "err:retries"}
+
+
+def note(status):
+    with _recent_lock:
+        _recent.append(status)
+        if len(_recent) > 200:
+            _recent.pop(0)
+        # circuit breaker: >60% 403 over a full window => host is blocking us
+        if len(_recent) == 200 and sum(1 for s in _recent if s == "http403") > 120:
+            _stop.set()
+
+
+def main():
+    if not os.path.exists(INDEX):
+        sys.exit(f"missing {INDEX} — run build_index.py first")
+    items = []
+    with open(INDEX, encoding="utf-8") as f:
+        for line in f:
+            try:
+                r = json.loads(line)
+                items.append({"type": r["type"], "id": r["id"]})
+            except Exception:
+                pass
+    done = load_done()
+    todo = [it for it in items if (it["type"], it["id"]) not in done]
+    total = len(items)
+    print(f"index={total}  done={len(done)}  todo={len(todo)}  workers={WORKERS}", flush=True)
+
+    n = len(done)
+    t0 = time.time()
+    out = open(OUT, "a", encoding="utf-8")
+    counts = {}
+    try:
+        with ThreadPoolExecutor(max_workers=WORKERS) as ex:
+            futs = [ex.submit(fetch, it) for it in todo]
+            for fut in as_completed(futs):
+                res = fut.result()
+                if res is None:
+                    continue
+                with _write_lock:
+                    out.write(json.dumps(res, ensure_ascii=False) + "\n")
+                n += 1
+                st = res.get("status", "?")
+                counts[st] = counts.get(st, 0) + 1
+                note(st)
+                # politeness jitter (per completed task; with 8 workers ~ a few hundred req/min)
+                time.sleep(random.uniform(0.02, 0.12))
+                if n % 500 == 0:
+                    out.flush()
+                    rate = (n - len(done)) / max(time.time() - t0, 1)
+                    eta = (total - n) / max(rate, 0.1) / 60
+                    msg = (f"{n}/{total}  {rate:.1f}/s  ETA {eta:.0f}m  "
+                           + " ".join(f"{k}={v}" for k, v in sorted(counts.items())))
+                    print(msg, flush=True)
+                    with open(PROG, "w") as p:
+                        p.write(msg + "\n")
+                if _stop.is_set():
+                    print("!! circuit breaker tripped (sustained 403) — stopping. Re-run later to resume.", flush=True)
+                    break
+    finally:
+        out.flush()
+        out.close()
+    print(f"FINISHED pass: wrote {n}/{total}. counts={counts}", flush=True)
+    print("Next: build_parquet.py to assemble the CC-BY/SA subset.", flush=True)
+
+
+if __name__ == "__main__":
+    main()