Create namibia laws: 86 laws / 180 articles

MANIFEST.md

@@ -0,0 +1,9 @@
+# MANIFEST
+
+- generated_at: 2026-09-04T21:18:40Z
+- laws: 86
+- articles: 180
+- files:
+  - data/laws.parquet: 1708647 bytes
+  - data/articles.parquet: 1070576 bytes
+  - README.md: 2103 bytes

README.md

@@ -0,0 +1,64 @@
+---
+pretty_name: Laws of Namibia
+license: other
+license_name: na-parliament-bon
+language:
+- en
+task_categories:
+- text-retrieval
+tags:
+- legal
+- law
+- namibia
+- official-texts
+size_categories:
+- n<1K
+configs:
+- config_name: laws
+  data_files: data/laws.parquet
+  default: true
+- config_name: articles
+  data_files: data/articles.parquet
+---
+
+# Laws of Namibia
+
+Research snapshot of official legislation collected from **laws.parliament.na Bills / Bank of Namibia / parliament.na**.
+
+**Not legal advice.** Official gazettes / government portals prevail over this corpus.
+
+## Snapshot
+
+| Field | Value |
+| --- | --- |
+| Snapshot date | 2026-09-04 |
+| Coverage | catalog-backed incomplete |
+| Source | laws.parliament.na Bills / Bank of Namibia / parliament.na |
+| Collector | `scrapers/collect_na.py` |
+| Laws / instruments | 86 |
+| Articles | 180 |
+| Language | en |
+| Jurisdiction | Namibia |
+| License | `na-parliament-bon` |
+
+## Contents
+
+- `data/laws.parquet` — one row per instrument (id, title, full text, dates, status, identifiers, article count, source URL).
+- `data/articles.parquet` — one row per article/section (`law_id`, article number, title, text, source URL).
+- `scrapers/collect_na.py` — research collector used to build this snapshot.
+- `scrapers/common.py` — shared collector helpers.
+- `scrapers/world_lib.py` — shared fetch (live official URL, Wayback fallback).
+- `scrapers/archive_fallbacks.py` — Wayback / Common Crawl CDX helpers.
+
+## License / reuse
+
+Official government / gazette texts; reuse per public-sector terms of the
+source portal. This packaging, metadata, and collector script are provided
+for research.
+
+This dataset is **not** an official consolidation and is **not legal advice**.
+The official source prevails.
+
+## Notes
+
+Namibia Parliament Bill Tracking (laws.parliament.na embedded PDFs) + parliament.na wp-content Act/Bill PDFs + Bank of Namibia statutory Act/Regulation/Determination PDFs. laws.parliament.na/cms_documents via CDX+Wayback. Skipped lac.org.na and namiblii.org. gov.na/moj.gov.na/mfpe.gov.na unreachable (SSL/DNS). Not legal advice.

data/articles.parquet

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

data/laws.parquet

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

scrapers/archive_fallbacks.py

@@ -0,0 +1,626 @@
+#!/usr/bin/env python3
+"""Public Wayback CDX + Common Crawl CDX/WARC fetch (ipfs_datasets_py fallback intent).
+
+Does not import the full ipfs_datasets_py package. Matches:
+  search_wayback_machine / get_wayback_content (wayback_machine_engine.py)
+  Common Crawl CDX at https://index.commoncrawl.org/
+  archive.is newest lookup
+Brave Search is skipped when no API key is present.
+"""
+from __future__ import annotations
+
+import gzip
+import io
+import json
+import logging
+import os
+import re
+import time
+from typing import Any, Optional
+from urllib.parse import quote, urljoin, urlparse
+
+import requests
+from requests.adapters import HTTPAdapter
+
+log = logging.getLogger("archive_fallbacks")
+
+WAYBACK_CDX = "http://web.archive.org/cdx/search/cdx"
+WAYBACK_WEB = "http://web.archive.org/web"
+CC_COLLINFO = "https://index.commoncrawl.org/collinfo.json"
+CC_DATA = "https://data.commoncrawl.org"
+ARCHIVE_IS_NEWEST = "https://archive.is/newest/"
+ARCHIVE_PH_NEWEST = "https://archive.ph/newest/"
+
+UA = (
+    "legal-corpora-collector/1.0 "
+    "(research archive of official national gazettes; polite; "
+    "contact via local operator)"
+)
+
+CHALLENGE_RE = re.compile(
+    r"just\s+a\s+moment|cf-browser-verification|cloudflare|enable\s+javascript|"
+    r"you\s+need\s+to\s+enable\s+javascript|tspd_|bobcmn|attention\s+required|"
+    r"checking\s+your\s+browser|please\s+wait\s+while\s+we\s+verify|"
+    r"request\s+rejected|access\s+denied",
+    re.I,
+)
+SPA_SHELL_RE = re.compile(
+    r"<app-root[\s>]|ng-version=|outsystems-ui|data-block=\"MainContent\"|"
+    r"id=\"outsystems\"|window\.__INITIAL_STATE__\s*=\s*\{\s*\}",
+    re.I,
+)
+
+_session: Optional[requests.Session] = None
+_cc_indexes: Optional[list[str]] = None
+_cc_dead: set[str] = set()
+_last_wayback = 0.0
+_last_cc = 0.0
+
+
+def session() -> requests.Session:
+    global _session
+    if _session is None:
+        s = requests.Session()
+        s.headers.update({"User-Agent": UA, "Accept": "*/*"})
+        ad = HTTPAdapter(pool_connections=8, pool_maxsize=8, max_retries=0)
+        s.mount("https://", ad)
+        s.mount("http://", ad)
+        _session = s
+    return _session
+
+
+def _sleep_wayback(delay: float = 1.0) -> None:
+    global _last_wayback
+    now = time.time()
+    wait = delay - (now - _last_wayback)
+    if wait > 0:
+        time.sleep(wait)
+    _last_wayback = time.time()
+
+
+def _sleep_cc(delay: float = 0.35) -> None:
+    global _last_cc
+    now = time.time()
+    wait = delay - (now - _last_cc)
+    if wait > 0:
+        time.sleep(wait)
+    _last_cc = time.time()
+
+
+def has_brave_key() -> bool:
+    return bool(
+        (os.environ.get("BRAVE_API_KEY") or os.environ.get("BRAVE_SEARCH_API_KEY") or "").strip()
+    )
+
+
+def is_challenge(html: str, status: int = 200) -> bool:
+    if status in (401, 403, 429, 503):
+        return True
+    if not html:
+        return False
+    head = html[:8000]
+    if CHALLENGE_RE.search(head):
+        return True
+    if SPA_SHELL_RE.search(head) and len(html) < 8000:
+        return True
+    return False
+
+
+def is_spa_shell(html: str, text: str) -> bool:
+    if not html:
+        return False
+    if SPA_SHELL_RE.search(html[:12000]) and len(text or "") < 400:
+        return True
+    return False
+
+
+# --- Wayback ---
+
+CDX_PAGE = 200  # large single-shot limits (2000+) 504 on web.archive.org
+
+
+def _parse_cdx_json(data: Any, mime_prefix: Optional[str] = None) -> tuple[list[dict], Optional[str]]:
+    """Parse Wayback CDX JSON, including showResumeKey trailer."""
+    if not isinstance(data, list) or len(data) <= 1:
+        return [], None
+    resume = None
+    rows = data
+    # Trailer: ..., [], ["resumeKey"]
+    if len(data) >= 3 and data[-2] == [] and isinstance(data[-1], list) and data[-1]:
+        resume = str(data[-1][0]) if data[-1][0] else None
+        rows = data[:-2]
+    headers = rows[0] if rows else []
+    out: list[dict] = []
+    for row in rows[1:]:
+        if not row:
+            continue
+        rec = dict(zip(headers, row)) if headers and isinstance(headers[0], str) else {}
+        if not rec and isinstance(row, list) and len(row) >= 5:
+            rec = {
+                "urlkey": row[0],
+                "timestamp": row[1],
+                "original": row[2],
+                "mimetype": row[3],
+                "statuscode": row[4],
+                "digest": row[5] if len(row) > 5 else "",
+                "length": row[6] if len(row) > 6 else "0",
+            }
+        orig = rec.get("original") or rec.get("url") or ""
+        ts = rec.get("timestamp") or ""
+        mime = rec.get("mimetype") or ""
+        if mime_prefix and mime and not mime.lower().startswith(mime_prefix.lower()) and mime not in (
+            "application/pdf",
+            "application/xml",
+            "text/xml",
+            "application/xhtml+xml",
+            "text/html",
+            "application/json",
+        ):
+            continue
+        if not orig or not ts:
+            continue
+        rec["wayback_url"] = f"{WAYBACK_WEB}/{ts}id_/{orig}"
+        rec["source"] = "wayback"
+        out.append(rec)
+    return out, resume
+
+
+def _wayback_cdx_page(
+    url: str,
+    *,
+    limit: int,
+    collapse: str,
+    filter_status: str,
+    from_date: Optional[str],
+    to_date: Optional[str],
+    match_type: Optional[str],
+    extra_filters: Optional[list[str]],
+    resume_key: Optional[str],
+    mime_prefix: Optional[str],
+    page_size: int,
+) -> tuple[list[dict], Optional[str]]:
+    items: list[tuple[str, Any]] = [
+        ("url", url),
+        ("output", "json"),
+        ("fl", "urlkey,timestamp,original,mimetype,statuscode,digest,length"),
+        ("limit", int(page_size)),
+        ("showResumeKey", "true"),
+    ]
+    if collapse:
+        items.append(("collapse", collapse))
+    if from_date:
+        items.append(("from", from_date))
+    if to_date:
+        items.append(("to", to_date))
+    if match_type:
+        items.append(("matchType", match_type))
+    if filter_status:
+        items.append(("filter", f"statuscode:{filter_status}"))
+    for flt in extra_filters or []:
+        items.append(("filter", flt))
+    if resume_key:
+        items.append(("resumeKey", resume_key))
+    _sleep_wayback(1.0)
+    last_err = None
+    for attempt, psz in enumerate((page_size, 120, 80), 1):
+        if attempt > 1:
+            items = [(k, psz if k == "limit" else v) for k, v in items]
+            _sleep_wayback(1.5)
+        try:
+            r = session().get(WAYBACK_CDX, params=items, timeout=(20, 90))
+        except requests.RequestException as exc:
+            last_err = exc
+            log.warning("wayback cdx fail %s: %s", url, exc)
+            continue
+        if r.status_code in (502, 503, 504) or not r.content:
+            last_err = f"http_{r.status_code}"
+            log.info("wayback cdx HTTP %s for %s (page_size=%s)", r.status_code, url, psz)
+            continue
+        if r.status_code != 200:
+            log.info("wayback cdx HTTP %s for %s", r.status_code, url)
+            return [], None
+        try:
+            data = r.json()
+        except Exception:
+            return [], None
+        return _parse_cdx_json(data, mime_prefix=mime_prefix)
+    log.info("wayback cdx gave up %s last=%s", url, last_err)
+    return [], None
+
+
+def search_wayback_machine(
+    url: str,
+    *,
+    from_date: Optional[str] = None,
+    to_date: Optional[str] = None,
+    limit: int = 100,
+    collapse: str = "urlkey",
+    filter_status: str = "200",
+    match_type: Optional[str] = None,
+    mime_prefix: Optional[str] = None,
+    extra_filters: Optional[list[str]] = None,
+) -> list[dict]:
+    """CDX search with resumeKey pagination (single-shot limit>=2000 504s)."""
+    target = max(1, int(limit))
+    page_size = CDX_PAGE if target > CDX_PAGE else target
+    out: list[dict] = []
+    seen = set()
+    resume: Optional[str] = None
+    empty = 0
+    while len(out) < target:
+        need = min(page_size, target - len(out))
+        batch, resume = _wayback_cdx_page(
+            url,
+            limit=need,
+            collapse=collapse,
+            filter_status=filter_status,
+            from_date=from_date,
+            to_date=to_date,
+            match_type=match_type,
+            extra_filters=extra_filters,
+            resume_key=resume,
+            mime_prefix=mime_prefix,
+            page_size=need,
+        )
+        added = 0
+        for rec in batch:
+            key = (rec.get("original"), rec.get("timestamp"), rec.get("digest"))
+            if key in seen:
+                continue
+            seen.add(key)
+            out.append(rec)
+            added += 1
+        if added == 0:
+            empty += 1
+            if empty >= 2 or not resume:
+                break
+        else:
+            empty = 0
+        if not resume:
+            break
+        log.info("wayback cdx %s page n=%s total=%s/%s", url, added, len(out), target)
+    return out[:target]
+
+
+def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
+    """Fetch a snapshot; id_ modifier skips Wayback chrome. No CDX search."""
+    if timestamp:
+        wb = f"{WAYBACK_WEB}/{timestamp}id_/{url}"
+    else:
+        wb = f"{WAYBACK_WEB}/2id_/{url}"
+    r = None
+    last_err = None
+    for attempt in range(1, 5):
+        _sleep_wayback(1.2 if attempt == 1 else min(20.0, 2.5 * attempt))
+        try:
+            r = session().get(wb, timeout=(20, 90), allow_redirects=True)
+        except requests.RequestException as exc:
+            last_err = str(exc)
+            log.info("wayback replay fail %s: %s", url, exc)
+            continue
+        if r.status_code in (403, 429, 503, 502, 504) and attempt < 4:
+            log.info("wayback replay HTTP %s %s attempt=%s", r.status_code, url, attempt)
+            continue
+        break
+    if r is None:
+        return {"status": "error", "error": last_err or "no_response", "url": url}
+    cap_ts = timestamp or ""
+    m = re.search(r"/web/(\d{14})", r.url or "")
+    if m:
+        cap_ts = m.group(1)
+    ctype = r.headers.get("content-type") or ""
+    body = r.content or b""
+    text = ""
+    if "html" in ctype or "xml" in ctype or "text/" in ctype or not ctype:
+        enc = r.encoding or "utf-8"
+        try:
+            text = body.decode(enc, "replace")
+        except Exception:
+            text = body.decode("utf-8", "replace")
+    if r.status_code != 200 or not body:
+        return {
+            "status": "error",
+            "error": f"http_{r.status_code}",
+            "http_status": r.status_code,
+            "wayback_url": r.url,
+            "original_url": url,
+        }
+    if text and is_challenge(text, r.status_code):
+        return {
+            "status": "error",
+            "error": "challenge_or_shell",
+            "http_status": r.status_code,
+            "wayback_url": r.url,
+            "original_url": url,
+            "content": text[:2000],
+        }
+    return {
+        "status": "success",
+        "content": body,
+        "text": text,
+        "content_type": ctype,
+        "wayback_url": r.url,
+        "capture_timestamp": cap_ts,
+        "original_url": url,
+        "http_status": r.status_code,
+        "method": "wayback",
+    }
+
+
+# --- Common Crawl ---
+
+def cc_indexes(n: int = 6) -> list[str]:
+    global _cc_indexes
+    if _cc_indexes is None:
+        try:
+            r = session().get(CC_COLLINFO, timeout=30)
+            cols = r.json() if r.status_code == 200 else []
+            ids = []
+            for c in cols:
+                cid = c.get("id") or ""
+                cdx = c.get("cdx-api") or c.get("cdx_api") or ""
+                if cid:
+                    ids.append(cdx or f"https://index.commoncrawl.org/{cid}-index")
+            # collinfo is newest-first. Do not drop crawls that 404 a
+            # specific URL (that means "no captures", not a dead index).
+            _cc_indexes = ids or [
+                "https://index.commoncrawl.org/CC-MAIN-2025-18-index",
+                "https://index.commoncrawl.org/CC-MAIN-2024-33-index",
+            ]
+        except Exception as exc:
+            log.warning("cc collinfo: %s", exc)
+            _cc_indexes = [
+                "https://index.commoncrawl.org/CC-MAIN-2026-34-index",
+                "https://index.commoncrawl.org/CC-MAIN-2026-30-index",
+                "https://index.commoncrawl.org/CC-MAIN-2026-25-index",
+                "https://index.commoncrawl.org/CC-MAIN-2024-33-index",
+            ]
+    return _cc_indexes[:n]
+
+
+def search_common_crawl(url: str, *, limit: int = 80, indexes: Optional[list[str]] = None) -> list[dict]:
+    """Query public CC CDX (https://index.commoncrawl.org/).
+
+    Do not send filter=status:200 — on some shards that returns a false
+    404 "No Captures found". Filter status client-side instead.
+    HTTP 404 with that message means no hits in this crawl, not a dead index.
+    """
+    out = []
+    seen = set()
+    empty = 0
+    for idx in (indexes or cc_indexes(12)):
+        if idx in _cc_dead:
+            continue
+        params = {
+            "url": url,
+            "output": "json",
+            "limit": str(limit),
+        }
+        _sleep_cc(0.3)
+        try:
+            r = session().get(idx, params=params, timeout=(12, 25))
+        except requests.RequestException as exc:
+            log.info("cc cdx %s fail %s", idx, exc)
+            continue
+        if r.status_code == 404:
+            msg = (r.text or "")[:80]
+            log.info("cc cdx no-captures %s %s", idx.split("/")[-1], msg)
+            empty += 1
+            if empty >= 8 and not out:
+                continue
+            continue
+        if r.status_code in (410,):
+            _cc_dead.add(idx)
+            log.info("cc cdx dead HTTP %s %s", r.status_code, idx.split("/")[-1])
+            continue
+        if r.status_code != 200 or not r.content:
+            log.info("cc cdx HTTP %s %s", r.status_code, idx.split("/")[-1])
+            continue
+        for line in r.text.splitlines():
+            line = line.strip()
+            if not line or line[0] not in "{[":
+                continue
+            try:
+                rec = json.loads(line)
+            except Exception:
+                continue
+            orig = rec.get("url") or rec.get("original") or ""
+            st = str(rec.get("status") or rec.get("statuscode") or "200")
+            if st and st not in ("200", "201", "206"):
+                continue
+            key = (orig, rec.get("filename"), rec.get("offset"))
+            if not orig or key in seen:
+                continue
+            seen.add(key)
+            rec["original"] = orig
+            rec["source"] = "common_crawl"
+            rec["cc_index"] = idx
+            out.append(rec)
+        if out:
+            log.info("cc cdx %s hits=%s", idx.split("/")[-1], len(out))
+        if len(out) >= limit or out:
+            break
+    return out[:limit]
+
+
+def _parse_warc_http(raw: bytes) -> tuple[int, str, bytes]:
+    data = raw
+    if data[:2] == b"\x1f\x8b":
+        try:
+            data = gzip.decompress(data)
+        except Exception:
+            try:
+                data = gzip.GzipFile(fileobj=io.BytesIO(data)).read()
+            except Exception:
+                pass
+    # WARC record: headers, then HTTP payload
+    split = data.split(b"\r\n\r\n", 1)
+    if len(split) < 2:
+        return 0, "", data
+    warc_headers, rest = split
+    if rest.startswith(b"HTTP/") or rest.startswith(b"http/"):
+        http_split = rest.split(b"\r\n\r\n", 1)
+        http_head = http_split[0].decode("latin-1", "replace")
+        body = http_split[1] if len(http_split) > 1 else b""
+        m = re.search(r"HTTP/\d\.\d\s+(\d{3})", http_head)
+        status = int(m.group(1)) if m else 0
+        cm = re.search(r"Content-Type:\s*([^\r\n]+)", http_head, re.I)
+        ctype = cm.group(1).strip() if cm else ""
+        return status, ctype, body
+    return 0, "", rest
+
+
+def fetch_common_crawl_warc(rec: dict, max_bytes: int = 4_000_000) -> dict:
+    fn = rec.get("filename") or rec.get("warc_filename") or ""
+    try:
+        off = int(rec.get("offset") or rec.get("warc_offset") or 0)
+        ln = int(rec.get("length") or rec.get("warc_length") or 0)
+    except Exception:
+        return {"status": "error", "error": "bad_pointer"}
+    if not fn or ln <= 0:
+        return {"status": "error", "error": "missing_pointer"}
+    ln = min(ln, max_bytes)
+    url = fn if str(fn).startswith("http") else f"{CC_DATA}/{fn.lstrip('/')}"
+    _sleep_cc(0.25)
+    try:
+        r = session().get(
+            url,
+            headers={"Range": f"bytes={off}-{off + ln - 1}"},
+            timeout=(20, 90),
+        )
+    except requests.RequestException as exc:
+        return {"status": "error", "error": str(exc)}
+    if r.status_code not in (200, 206) or not r.content:
+        return {"status": "error", "error": f"http_{r.status_code}"}
+    status, ctype, body = _parse_warc_http(r.content)
+    text = ""
+    if body and (
+        "html" in (ctype or "")
+        or "xml" in (ctype or "")
+        or "text/" in (ctype or "")
+        or not ctype
+    ):
+        text = body.decode("utf-8", "replace")
+    orig = rec.get("original") or rec.get("url") or ""
+    if text and is_challenge(text, status or 200):
+        return {"status": "error", "error": "challenge_or_shell", "original_url": orig}
+    return {
+        "status": "success",
+        "content": body,
+        "text": text,
+        "content_type": ctype,
+        "original_url": orig,
+        "http_status": status or 200,
+        "method": "common_crawl",
+        "cc_record": {
+            "filename": fn,
+            "offset": off,
+            "length": ln,
+            "timestamp": rec.get("timestamp"),
+        },
+    }
+
+
+# --- archive.is ---
+
+def get_archive_is_content(url: str) -> dict:
+    for base in (ARCHIVE_IS_NEWEST, ARCHIVE_PH_NEWEST):
+        try:
+            r = session().get(base + url, timeout=(8, 15), allow_redirects=True)
+        except requests.RequestException as exc:
+            log.info("archive.is %s", exc)
+            continue
+        if r.status_code != 200 or not r.content:
+            continue
+        if "archive." not in (r.url or ""):
+            continue
+        text = r.text or ""
+        if is_challenge(text, r.status_code):
+            continue
+        return {
+            "status": "success",
+            "content": r.content,
+            "text": text,
+            "content_type": r.headers.get("content-type") or "text/html",
+            "archive_url": r.url,
+            "original_url": url,
+            "http_status": r.status_code,
+            "method": "archive_is",
+        }
+    return {"status": "error", "error": "no_archive_is_snapshot", "original_url": url}
+
+
+# --- Direct HTTP last ---
+
+def get_http(url: str) -> dict:
+    try:
+        r = session().get(url, timeout=(20, 60), allow_redirects=True)
+    except requests.RequestException as exc:
+        return {"status": "error", "error": str(exc), "original_url": url}
+    text = ""
+    ctype = r.headers.get("content-type") or ""
+    body = r.content or b""
+    if body and ("html" in ctype or "xml" in ctype or "text/" in ctype or not ctype):
+        text = body.decode(r.encoding or "utf-8", "replace")
+    if r.status_code != 200 or not body:
+        return {"status": "error", "error": f"http_{r.status_code}", "http_status": r.status_code}
+    if text and is_challenge(text, r.status_code):
+        return {"status": "error", "error": "challenge_or_shell", "http_status": r.status_code}
+    return {
+        "status": "success",
+        "content": body,
+        "text": text,
+        "content_type": ctype,
+        "original_url": url,
+        "http_status": r.status_code,
+        "method": "http",
+        "final_url": r.url,
+    }
+
+
+def fetch_with_fallbacks(
+    url: str,
+    *,
+    cc_record: Optional[dict] = None,
+    wayback_ts: Optional[str] = None,
+    try_archive_is: bool = False,
+    try_http: bool = True,
+    try_cc: bool = True,
+) -> dict:
+    """Prefer archives: CC WARC -> Wayback replay -> archive.is -> direct HTTP.
+
+    Brave Search skipped (no API key in this environment).
+    Playwright is attempted by the caller when this returns a SPA shell.
+    Does not run Wayback CDX search; Wayback is replay only.
+    """
+    errors = []
+    cc_recs: list[dict] = []
+    if cc_record and (cc_record.get("filename") or cc_record.get("warc_filename")):
+        cc_recs = [cc_record]
+    elif try_cc:
+        try:
+            cc_recs = search_common_crawl(url, limit=4)
+        except Exception as exc:
+            errors.append(f"common_crawl:{exc}")
+            cc_recs = []
+    for rec in cc_recs:
+        res = fetch_common_crawl_warc(rec)
+        if res.get("status") == "success" and (res.get("text") or res.get("content")):
+            return res
+        errors.append(f"common_crawl:{res.get('error')}")
+    if wayback_ts or url:
+        res = get_wayback_content(url, timestamp=wayback_ts)
+        if res.get("status") == "success" and (res.get("text") or res.get("content")):
+            return res
+        errors.append(f"wayback:{res.get('error')}")
+    if try_archive_is:
+        res = get_archive_is_content(url)
+        if res.get("status") == "success":
+            return res
+        errors.append(f"archive_is:{res.get('error')}")
+    if try_http:
+        res = get_http(url)
+        if res.get("status") == "success":
+            return res
+        errors.append(f"http:{res.get('error')}")
+    return {"status": "error", "error": "; ".join(errors) or "all_failed", "original_url": url}

scrapers/collect_na.py

@@ -0,0 +1,659 @@
+#!/usr/bin/env python3
+"""Namibia: official Bills / Acts / Gazette instruments from Parliament + BoN.
+
+Primary: laws.parliament.na (Online Bill Tracking — embedded official Bill PDFs),
+www.parliament.na (wp-content Bill / Act PDFs + wp-json media), Bank of Namibia
+(bon.com.na Regulations / Determinations / Act getattachment PDFs).
+
+Skips: lac.org.na (entirely), namiblii.org, SAFLII, gazettes.africa, speeches,
+motivations, contributions, tenders, minutes, notices of award.
+
+Live official URL first; Wayback of the same official URL on failure.
+OCR=1 enables pdftoppm+tesseract for image-only official PDFs. No WAF bypass.
+
+Gaps (recorded): www.gov.na SSL EOF from collector host; moj.gov.na timeout;
+mfpe.gov.na DNS fail; laws.parliament.na/cms_documents live often 404 → Wayback; full Government Gazette series not mirrored on parliament.na.
+"""
+from __future__ import annotations
+
+import base64
+import logging
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+from urllib.parse import unquote, urljoin, urlparse
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import existing_ids, log_failure, utcnow, write_summary
+from world_lib import cdx_urls, env_int, fetch_official, fetch_official_prefer_pdf, live_get, save_instrument, setup_log, slug_id
+
+CC, COUNTRY, LANG = "na", "Namibia", "en"
+SOURCE_TYPE = "namibia_official_parliament_bon"
+LICENSE = (
+    "Laws / Bills / Gazette instruments of Namibia as published on official "
+    "Parliament portals (parliament.na / laws.parliament.na) and Bank of Namibia "
+    "(bon.com.na) statutory hosts. Authentic Government Gazette / Parliament text "
+    "prevails. Not legal advice."
+)
+UA = "legal-corpora-collector/1.0 (research; source=https://www.parliament.na/)"
+ART = re.compile(
+    r"(?im)^\s*((?:Section|Sec\.|Article|Art\.|Regulation|Reg\.)\s+\d+[A-Za-z]?\.?)\b"
+)
+log = logging.getLogger("na")
+
+BLOCK_HOST = re.compile(
+    r"(lac\.org\.na|namiblii\.org|saflii\.org|gazettes\.africa|"
+    r"africanlii\.org|commonlii\.org|ulii\.org)",
+    re.I,
+)
+SKIP_NAME = re.compile(
+    r"(contribution|motivation|response|speech|report[_\-\s]|NOTICE[_\-\s]?OF|"
+    r"minutes|tender|award|vacancy|advert|newsletter|workshop|consultative|"
+    r"stakeholder|explanatory[_\-\s]?memorandum|budget[_\-\s]?statement|"
+    r"vote\d|sofa|upholstery|procurement[_\-\s]?notice|selection[_\-\s]?for|"
+    r"cancellation[_\-\s]?of[_\-\s]?a[_\-\s]?bid|facilitator|travel[_\-\s]?management|"
+    r"supply[_\-\s]?and[_\-\s]?delivery|service[_\-\s]?level[_\-\s]?agreement|"
+    r"strategy[_\-\s]?advert|mefmi[_\-\s]?advertisement)",
+    re.I,
+)
+LAWISH_NAME = re.compile(
+    r"("
+    r"\bbill\b|_bill_|-bill-|bill\.pdf|"
+    r"\bact\b|_act_|-act-|act\.pdf|"
+    r"gazette|regulation|regulations|determination|"
+    r"constitution|statutory[_\-\s]?instrument|"
+    r"\bb\.?\s*\d+|amendment"
+    r")",
+    re.I,
+)
+LAW_MARK = re.compile(
+    r"(BE IT ENACTED|AN ACT\b|A BILL\b|BILL\b|Short title|"
+    r"This Act may be cited|GOVERNMENT GAZETTE|REPUBLIC OF NAMIBIA|"
+    r"ARRANGEMENT OF SECTIONS|NATIONAL ASSEMBLY|PROMULGATION OF ACT|"
+    r"No\.\s*\d+\s+of\s+20\d{2}|\[B\.\s*\d+)",
+    re.I,
+)
+
+CDX_PREFIXES = [
+    "laws.parliament.na/cms_documents/",
+    "www.parliament.na/wp-content/uploads/",
+    "parliament.na/wp-content/uploads/",
+    "www.bon.com.na/CMSTemplates/Bon/Files/",
+    "bon.com.na/CMSTemplates/Bon/Files/",
+]
+
+LIVE_SEEDS = [
+    "https://www.parliament.na/bills/",
+    "https://www.parliament.na/acts-of-parliament/",
+    "https://laws.parliament.na/Bill-register",
+    "https://www.bon.com.na/Regulations.aspx",
+    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks.aspx",
+    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Determinations.aspx",
+    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Regulations.aspx",
+]
+
+BON_SEED_PAGES = [
+    "https://www.bon.com.na/Regulations.aspx",
+    "https://www.bon.com.na/Regulations/Bank-of-Namibia-Act-2020.aspx",
+    "https://www.bon.com.na/Regulations/Banking-Institutions-Act-2023.aspx",
+    "https://www.bon.com.na/Regulations/Virtual-Assets-Act-2023.aspx",
+    "https://www.bon.com.na/Regulations/Financial-Intelligence-Act-2012.aspx",
+    "https://www.bon.com.na/Regulations/Namibia-Deposit-Guarantee-Act-2018.aspx",
+    "https://www.bon.com.na/Regulations/Payment-System-Management-Act-2003.aspx",
+    "https://www.bon.com.na/Regulations/Payment-System-Management-Amendment-Act-2023.aspx",
+    "https://www.bon.com.na/Regulations/Currencies-and-Exchanges-Act-1933.aspx",
+    "https://www.bon.com.na/Regulations/Prevention-of-Counterfeiting-of-Currency-Act-1965.aspx",
+    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Determinations.aspx",
+    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Regulations.aspx",
+    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Other-Bylaws.aspx",
+    "https://www.bon.com.na/Bank/National-Payment-System/Legal-Framework.aspx",
+    "https://www.bon.com.na/Bank/Financial-Stability/Determinations-Regulations-and-Guidance-Notes.aspx",
+]
+
+
+def _norm(url: str) -> str:
+    u = (url or "").split("#")[0]
+    u = u.replace("http://", "https://")
+    u = re.sub(r":80/", "/", u)
+    u = re.sub(r"https://parliament\.na/", "https://www.parliament.na/", u)
+    u = re.sub(r"https://bon\.com\.na/", "https://www.bon.com.na/", u)
+    # Drop tracking query junk; keep empty for getattachment
+    parts = urlparse(u)
+    path = parts.path or ""
+    if " " in unquote(path) or "%" in path:
+        from urllib.parse import quote
+
+        path = quote(unquote(path), safe="/%")
+    return parts._replace(path=path, query="", params="", fragment="").geturl().rstrip("?")
+
+
+def _ident_from_url(url: str) -> str:
+    path = unquote(urlparse(url.split("?")[0]).path)
+    name = Path(path).name
+    if name.lower() in ("", ".aspx", ".aspx/") or name.lower() == ".aspx":
+        # BoN getattachment/<uuid>/.aspx
+        m = re.search(r"getattachment/([0-9a-f-]{36})", url, re.I)
+        if m:
+            name = f"bon-{m.group(1)[:12]}"
+        else:
+            name = Path(path.rstrip("/")).name or "na-doc"
+    if name.lower().endswith(".pdf"):
+        name = name[:-4]
+    if name.lower().endswith(".aspx"):
+        name = name[:-5]
+    name = re.sub(r"\s+", " ", name).strip()
+    return re.sub(r"[^\w.\-]+", "-", name)[:160] or "na-doc"
+
+
+def _host_ok(url: str) -> bool:
+    if not url or not url.startswith("http"):
+        return False
+    if BLOCK_HOST.search(url):
+        return False
+    host = (urlparse(url).hostname or "").lower()
+    ok = (
+        "parliament.na",
+        "bon.com.na",
+        "gov.na",
+        "moj.gov.na",
+        "mfpe.gov.na",
+        "opm.gov.na",
+    )
+    return any(host == s or host.endswith("." + s) for s in ok)
+
+
+def _is_law_url(url: str) -> bool:
+    u = _norm(url)
+    if not _host_ok(u):
+        return False
+    low = unquote(u).lower()
+    if SKIP_NAME.search(low):
+        return False
+    # Historic laws.parliament.na statute book (live often 404 → Wayback)
+    if "laws.parliament.na" in low and "/cms_documents/" in low and ".pdf" in low:
+        return True
+    # BoN getattachment — accepted when discovered from Act/Determination pages
+    if "parliament.gov.na" in low and "/acts_documents/" in low and ".pdf" in low:
+        return True
+    if "bon.com.na" in low and "/getattachment/" in low:
+        return True
+    if "bon.com.na" in low and "/cmstemplates/bon/files/" in low and ".pdf" in low:
+        return True
+    if ".pdf" not in low:
+        return False
+    name = unquote(urlparse(u.split("?")[0]).path).split("/")[-1]
+    if SKIP_NAME.search(name):
+        return False
+    if LAWISH_NAME.search(name) or LAWISH_NAME.search(low):
+        return True
+    return False
+
+
+def _title_from_text(text: str, fallback: str) -> str:
+    lines = [ln.strip() for ln in (text or "").splitlines() if ln.strip()]
+    for ln in lines[:60]:
+        if re.search(r"\b(ACT|BILL|REGULATIONS?|GAZETTE|DETERMINATION)\b", ln) and 8 <= len(ln) <= 180:
+            if not re.match(r"^(TITLE|PREVIOUS|NEXT|CONTENTS|EXPLANATORY)\b", ln, re.I):
+                return ln[:240]
+    for ln in lines:
+        if len(ln) >= 12 and not ln.lower().startswith("just a moment"):
+            return ln[:240]
+    return fallback[:240]
+
+
+def _looks_like_law(text: str) -> bool:
+    if not text or len(text) < 200:
+        return False
+    head = text[:10000]
+    if LAW_MARK.search(head):
+        return True
+    secs = len(re.findall(r"(?im)^\s*Section\s+\d+", text[:25000]))
+    return secs >= 5
+
+
+def _add(items: list, seen: set, url: str, ident: str | None = None) -> None:
+    url = _norm(url)
+    if not url or url in seen or not _is_law_url(url):
+        return
+    seen.add(url)
+    items.append((ident or _ident_from_url(url), url))
+
+
+def pdf_ocr_text(raw: bytes, *, max_pages: int = 30, dpi: int = 160) -> str:
+    """OCR scanned / image-only official PDFs via pdftoppm + tesseract (eng)."""
+    if not raw or raw[:4] != b"%PDF":
+        return ""
+    max_pages = env_int("OCR_MAX_PAGES", max_pages)
+    try:
+        with tempfile.TemporaryDirectory() as d:
+            pdf = Path(d) / "in.pdf"
+            pdf.write_bytes(raw)
+            subprocess.run(
+                [
+                    "pdftoppm",
+                    "-png",
+                    "-r",
+                    str(dpi),
+                    "-f",
+                    "1",
+                    "-l",
+                    str(max_pages),
+                    str(pdf),
+                    str(Path(d) / "p"),
+                ],
+                check=False,
+                capture_output=True,
+                timeout=300,
+            )
+            pages = sorted(Path(d).glob("p*.png"))
+            chunks = []
+            for page in pages:
+                proc = subprocess.run(
+                    ["tesseract", str(page), "stdout", "-l", "eng", "--psm", "6"],
+                    capture_output=True,
+                    timeout=180,
+                )
+                if proc.stdout:
+                    chunks.append(proc.stdout.decode("utf-8", "replace"))
+            return "\n".join(chunks).strip()
+    except Exception as exc:
+        log.info("ocr fail: %s", exc)
+        return ""
+
+
+def fetch_na(url: str) -> dict:
+    """Live (+Wayback of same official URL); OCR when OCR=1 for image-only PDFs."""
+    got = fetch_official_prefer_pdf(url, ua=UA, verify=False, min_text=180)
+    if got.get("status") == "success":
+        return got
+    if os.environ.get("OCR", "0") != "1":
+        return got
+    err = got.get("error") or ""
+    body = got.get("content") if isinstance(got.get("content"), (bytes, bytearray)) else b""
+    if not body or body[:4] != b"%PDF":
+        try:
+            r = live_get(url, ua=UA, verify=False, timeout=(15, 90), retries=2)
+            body = r.content or b""
+        except Exception:
+            body = b""
+        if (not body or body[:4] != b"%PDF") and "wayback" not in err:
+            try:
+                import archive_fallbacks as af
+
+                w = af.get_wayback_content(url)
+                if w.get("status") == "success":
+                    body = w.get("content") or b""
+                    if isinstance(body, str):
+                        body = body.encode("latin-1", "replace")
+            except Exception:
+                pass
+    if body and body[:4] == b"%PDF":
+        text = pdf_ocr_text(bytes(body))
+        if len(text) >= 180:
+            got.update(
+                status="success",
+                text=text,
+                content=bytes(body),
+                method=(got.get("method") or "http") + "+ocr",
+                error="",
+            )
+            return got
+        got["error"] = (err or "") + ";ocr_short_or_failed"
+    return got
+
+
+def _decode_data_pdf(html: str) -> bytes:
+    m = re.search(r"data:application/pdf;base64,([A-Za-z0-9+/=\s&#x0-9a-fA-F;]+)", html or "")
+    if not m:
+        return b""
+    b64 = m.group(1)
+    b64 = (
+        b64.replace("&#x2B;", "+")
+        .replace("&#x2F;", "/")
+        .replace("&#x3D;", "=")
+        .replace("&amp;", "&")
+        .replace("&#43;", "+")
+    )
+    b64 = re.sub(r"\s+", "", b64)
+    # strip residual HTML entities
+    b64 = re.sub(r"&#x[0-9a-fA-F]+;", "", b64)
+    b64 = re.sub(r"&#\d+;", "", b64)
+    try:
+        raw = base64.b64decode(b64, validate=False)
+    except Exception:
+        return b""
+    return raw if raw[:4] == b"%PDF" else b""
+
+
+def _harvest_html(url: str) -> list[str]:
+    out = []
+    try:
+        r = live_get(url, ua=UA, verify=False, timeout=(20, 50))
+    except Exception as exc:
+        log.info("seed fail %s: %s", url[:90], exc)
+        return out
+    text = r.text or ""
+    for href in re.findall(r'href=["\']([^"\']+)["\']', text, re.I):
+        full = urljoin(url, href)
+        if ".pdf" in full.lower() or "/getattachment/" in full.lower():
+            out.append(full)
+    for m in re.findall(r'(https?://[^"\'\s>]+\.pdf)', text, re.I):
+        out.append(m)
+    return out
+
+
+def _laws_parliament_bills() -> list[tuple[str, str, str]]:
+    """Return (ident, synthetic_source_url, detail_url) for Bill Tracking PDFs.
+
+    Instruments are stored against the Public/Bills/Details/<uuid> official URL;
+    PDF bytes are embedded as data:application/pdf;base64 on that page.
+    """
+    items, seen = [], set()
+    register = "https://laws.parliament.na/Bill-register"
+    try:
+        r = live_get(register, ua=UA, verify=False, timeout=(25, 70))
+    except Exception as exc:
+        log.info("bill register fail: %s", exc)
+        return items
+    ids = sorted(set(re.findall(r"/Public/Bills/Details/([0-9a-f-]{36})", r.text or "", re.I)))
+    log.info("laws.parliament.na bill ids %s", len(ids))
+    cap = env_int("BILL_DETAILS", 120)
+    for bid in ids[:cap]:
+        detail = f"https://laws.parliament.na/Public/Bills/Details/{bid}"
+        if detail in seen:
+            continue
+        seen.add(detail)
+        # Title from register table if present
+        m = re.search(
+            rf'href=["\']/Public/Bills/Details/{bid}["\'][^>]*>([^<]{{3,120}})',
+            r.text or "",
+            re.I,
+        )
+        label = (m.group(1).strip() if m else "") or f"bill-{bid[:8]}"
+        ident = re.sub(r"[^\w.\-]+", "-", label)[:120] or f"bill-{bid[:8]}"
+        items.append((ident, detail, detail))
+    return items
+
+
+def _fetch_embedded_bill(detail_url: str) -> dict:
+    out = {
+        "status": "error",
+        "text": "",
+        "content": b"",
+        "source_url": detail_url,
+        "method": "",
+        "error": "",
+    }
+    try:
+        r = live_get(detail_url, ua=UA, verify=False, timeout=(30, 120), retries=2)
+    except Exception as exc:
+        out["error"] = f"live:{exc}"
+        return out
+    html = r.text or ""
+    title_m = re.search(r'<h2[^>]*class="[^"]*page-title[^"]*"[^>]*>([^<]+)', html, re.I)
+    page_title = (title_m.group(1).strip() if title_m else "")
+    raw = _decode_data_pdf(html)
+    if not raw:
+        out["error"] = "no_embedded_pdf"
+        return out
+    # text extract
+    from world_lib import pdf_to_text
+
+    text = pdf_to_text(raw)
+    method = "embedded_pdf"
+    if len(text) < 180 and os.environ.get("OCR", "0") == "1":
+        ocr = pdf_ocr_text(raw)
+        if len(ocr) > len(text):
+            text, method = ocr, "embedded_pdf+ocr"
+    if len(text) < 180:
+        out.update(error="pdf_extract_failed", content=raw)
+        return out
+    out.update(
+        status="success",
+        text=text,
+        content=raw,
+        method=method,
+        source_url=detail_url,
+        page_title=page_title,
+    )
+    return out
+
+
+def _wp_json_media() -> list[tuple[str, str]]:
+    items, seen = [], set()
+    try:
+        import requests
+        from requests.packages.urllib3.exceptions import InsecureRequestWarning
+
+        requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+    except Exception:
+        return items
+    for page in range(1, env_int("WP_MEDIA_PAGES", 8) + 1):
+        url = (
+            "https://www.parliament.na/wp-json/wp/v2/media"
+            f"?per_page=100&page={page}&mime_type=application/pdf"
+        )
+        try:
+            r = requests.get(url, timeout=(20, 50), headers={"User-Agent": UA}, verify=False)
+        except Exception as exc:
+            log.info("wp media fail page %s: %s", page, exc)
+            break
+        if r.status_code != 200:
+            break
+        data = r.json() if r.content else []
+        if not data:
+            break
+        for it in data:
+            su = it.get("source_url") or ""
+            if not su or su in seen:
+                continue
+            if not _is_law_url(su):
+                continue
+            seen.add(su)
+            items.append((_ident_from_url(su), su))
+    log.info("wp-json lawish pdfs %s", len(items))
+    return items
+
+
+def _bon_attachments() -> list[tuple[str, str]]:
+    items, seen = [], set()
+    pages = list(BON_SEED_PAGES)
+    # Expand Regulations.aspx child Act pages
+    try:
+        r = live_get("https://www.bon.com.na/Regulations.aspx", ua=UA, verify=False, timeout=(20, 50))
+        for href in re.findall(r'href=["\']([^"\']+)["\']', r.text or "", re.I):
+            full = urljoin("https://www.bon.com.na/Regulations.aspx", href)
+            if re.search(r"/Regulations/[^\"']+(Act|Regulation|Determination)", full, re.I):
+                if full not in pages:
+                    pages.append(full)
+    except Exception as exc:
+        log.info("bon regulations index fail: %s", exc)
+
+    for page in pages[: env_int("BON_PAGES", 40)]:
+        try:
+            r = live_get(page, ua=UA, verify=False, timeout=(20, 50))
+        except Exception as exc:
+            log.info("bon page fail %s: %s", page[:80], exc)
+            continue
+        # Prefer labelled Act/Determination attachments near lawish anchor text
+        html = r.text or ""
+        for href in re.findall(r'href=["\']([^"\']*getattachment[^"\']*)["\']', html, re.I):
+            full = _norm(urljoin(page, href))
+            if full in seen:
+                continue
+            # Skip obvious image/css attachments by fetching later; filter by nearby text
+            seen.add(full)
+            # ident from surrounding context if possible
+            slug = Path(urlparse(page).path).name.replace(".aspx", "")
+            m = re.search(r"getattachment/([0-9a-f-]{36})", full, re.I)
+            uuid = m.group(1)[:12] if m else "att"
+            ident = f"{slug}-{uuid}"[:140]
+            items.append((ident, full))
+    log.info("bon attachments %s", len(items))
+    return items
+
+
+def discover():
+    items, seen = [], set()
+
+    # 1) Live seed harvest (parliament + BoN HTML)
+    for su in LIVE_SEEDS:
+        for href in _harvest_html(su):
+            _add(items, seen, href)
+
+    # 2) Parliament wp-json media (Bill/Act PDFs)
+    for ident, url in _wp_json_media():
+        _add(items, seen, url, ident)
+
+    # 3) BoN Act / Determination / Regulation attachments
+    for ident, url in _bon_attachments():
+        # BoN getattachment always allowed when harvested from Act pages
+        url = _norm(url)
+        if not url or url in seen or not _host_ok(url):
+            continue
+        if BLOCK_HOST.search(url):
+            continue
+        seen.add(url)
+        items.append((ident, url))
+
+    # 4) CDX of official hosts
+    limit = env_int("CDX_LIMIT", 500)
+    for prefix in CDX_PREFIXES:
+        for h in cdx_urls(prefix, limit=limit, match_type="prefix", extra_filters=["mimetype:application/pdf"]):
+            orig = (h.get("original") or "").replace("http://", "https://")
+            _add(items, seen, orig)
+        if len(items) >= env_int("CATALOG_CAP", 500):
+            break
+
+    log.info("catalog pdf/attach %s", len(items))
+    return items
+
+
+def main():
+    setup_log(CC)
+    t0 = utcnow()
+    max_new = env_int("MAX_NEW", 80)
+    max_seconds = env_int("MAX_SECONDS", 3600)
+    t_start = time.time()
+    done = existing_ids(CC)
+    ok = skip = fail = 0
+
+    # A) Embedded Bill PDFs from laws.parliament.na (priority — official Bill Tracking)
+    for ident, source_url, detail in _laws_parliament_bills():
+        if max_new and ok >= max_new:
+            break
+        if time.time() - t_start > max_seconds:
+            break
+        rid = slug_id(CC, ident)
+        if rid in done:
+            skip += 1
+            continue
+        got = _fetch_embedded_bill(detail)
+        text = got.get("text") or ""
+        if got.get("status") != "success":
+            fail += 1
+            log_failure(CC, {"identifier": ident, "source_url": source_url, "reason": got.get("error")})
+            continue
+        if not _looks_like_law(text):
+            fail += 1
+            log_failure(CC, {"identifier": ident, "source_url": source_url, "reason": "not_law_like"})
+            continue
+        title = got.get("page_title") or _title_from_text(text, ident)
+        if save_instrument(
+            cc=CC,
+            country=COUNTRY,
+            language=LANG,
+            ident=ident,
+            title=title,
+            text=text,
+            source_url=source_url,
+            source_type=SOURCE_TYPE,
+            license_text=LICENSE,
+            collector="collect_na.py",
+            article_re=ART,
+            extra_meta={"fetch_method": got.get("method"), "portal": "laws.parliament.na"},
+        ):
+            ok += 1
+            done.add(rid)
+            log.info("ok bill %s chars=%s method=%s", ident[:70], len(text), got.get("method"))
+        else:
+            fail += 1
+
+    # B) Direct PDF / BoN attachment catalog
+    for ident, url in discover():
+        if max_new and ok >= max_new:
+            break
+        if time.time() - t_start > max_seconds:
+            break
+        rid = slug_id(CC, ident)
+        if rid in done:
+            skip += 1
+            continue
+        got = fetch_na(url)
+        text = got.get("text") or ""
+        if got.get("status") != "success":
+            fail += 1
+            log_failure(CC, {"identifier": ident, "source_url": url, "reason": got.get("error")})
+            continue
+        if not _looks_like_law(text):
+            fail += 1
+            log_failure(CC, {"identifier": ident, "source_url": url, "reason": "not_law_like"})
+            continue
+        title = _title_from_text(text, ident)
+        if save_instrument(
+            cc=CC,
+            country=COUNTRY,
+            language=LANG,
+            ident=ident,
+            title=title,
+            text=text,
+            source_url=url,
+            source_type=SOURCE_TYPE,
+            license_text=LICENSE,
+            collector="collect_na.py",
+            article_re=ART,
+            extra_meta={"fetch_method": got.get("method")},
+        ):
+            ok += 1
+            done.add(rid)
+            log.info("ok %s chars=%s method=%s", ident[:70], len(text), got.get("method"))
+        else:
+            fail += 1
+
+    write_summary(
+        CC,
+        country=COUNTRY,
+        source="Namibia Parliament (parliament.na / laws.parliament.na) + Bank of Namibia",
+        source_urls=[
+            "https://www.parliament.na/",
+            "https://laws.parliament.na/",
+            "https://laws.parliament.na/Bill-register",
+            "https://www.bon.com.na/Regulations.aspx",
+            "https://www.gov.na/",
+        ],
+        license_text=LICENSE,
+        discovered=ok + skip + fail,
+        fetched=ok,
+        skipped=skip,
+        failed=fail,
+        coverage=(
+            "catalog-backed incomplete; lac.org.na skipped by policy; "
+            "gov.na/moj.gov.na/mfpe.gov.na unreachable or SSL-fail from collector host; "
+            "full Government Gazette series not on parliament.na"
+        ),
+        notes=(
+            "Official Bills from laws.parliament.na Bill Tracking (embedded PDFs) and "
+            "parliament.na wp-content; BoN Act/Determination/Regulation getattachment PDFs. "
+            "Skipped lac.org.na / NamibLII / SAFLII. OCR when OCR=1. Not legal advice."
+        ),
+        last_run=t0,
+    )
+    log.info("done ok=%s skip=%s fail=%s", ok, skip, fail)
+
+
+if __name__ == "__main__":
+    main()

scrapers/common.py

@@ -0,0 +1,508 @@
+#!/usr/bin/env python3
+"""Shared helpers for national legislation collectors."""
+from __future__ import annotations
+
+import hashlib
+import html
+import json
+import os
+import re
+import tempfile
+import threading
+import time
+import traceback
+from collections import Counter
+from datetime import datetime, timezone, timedelta
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Any, Iterable, Optional
+from xml.etree import ElementTree as ET
+
+import requests
+from requests.adapters import HTTPAdapter
+
+ROOT = Path("/workspace/legal-corpora")
+SCHEMA_PATH = ROOT / "_templates" / "collection_record.schema.json"
+PT = timezone(timedelta(hours=-7))
+DEFAULT_UA = (
+    "legal-corpora-collector/1.0 "
+    "(research archive of official national gazettes; polite; "
+    "no commercial scraping; contact via local operator)"
+)
+INDEX_FIELDS = (
+    "id", "path", "title", "identifier", "eli", "source_url", "source_type",
+    "jurisdiction", "language", "law_status", "date", "retrieved_at",
+    "article_count", "bytes",
+)
+
+_tls = threading.local()
+_index_lock = threading.Lock()
+_fail_lock = threading.Lock()
+_schema = None
+_schema_lock = threading.Lock()
+
+
+def utcnow() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def pt_from_iso(iso: str) -> str:
+    try:
+        dt = datetime.fromisoformat(iso.replace("Z", "+00:00"))
+    except Exception:
+        return iso
+    return dt.astimezone(PT).strftime("%Y-%m-%d %H:%M:%S PT")
+
+
+def localtag(tag: str) -> str:
+    return tag.rsplit("}", 1)[-1]
+
+
+def slug_id(cc: str, official: str) -> str:
+    s = (official or "").strip()
+    s = s.replace("https://", "").replace("http://", "")
+    s = re.sub(r"[/\\]+", "__", s)
+    s = re.sub(r"\s+", "_", s)
+    s = re.sub(r"[^a-zA-Z0-9._-]+", "-", s)
+    s = s.strip("-._")
+    if not s:
+        s = "unknown"
+    s = s.lower()
+    if not s.startswith(cc.lower() + "-"):
+        s = f"{cc.lower()}-{s}"
+    if s[0] not in "abcdefghijklmnopqrstuvwxyz0123456789":
+        s = "x" + s
+    return s[:180]
+
+
+def atomic_write(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(text)
+        os.replace(tmp, path)
+    except Exception:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+
+
+def sha256_text(s: str) -> str:
+    return hashlib.sha256(s.encode("utf-8", "replace")).hexdigest()
+
+
+def get_session(ua: str = DEFAULT_UA, pool: int = 8) -> requests.Session:
+    s = getattr(_tls, "session", None)
+    if s is None or getattr(_tls, "ua", None) != ua:
+        s = requests.Session()
+        s.headers.update({
+            "User-Agent": ua,
+            "Accept": "application/json, application/xml, text/xml, text/html, */*",
+            "Accept-Language": "en,*;q=0.8",
+        })
+        ad = HTTPAdapter(pool_connections=pool, pool_maxsize=pool, max_retries=0)
+        s.mount("https://", ad)
+        s.mount("http://", ad)
+        _tls.session = s
+        _tls.ua = ua
+    return s
+
+
+def http_get(
+    url: str,
+    *,
+    ua: str = DEFAULT_UA,
+    timeout: tuple = (20, 90),
+    retries: int = 5,
+    sleep: float = 0.35,
+    headers: Optional[dict] = None,
+    params: Optional[dict] = None,
+    allow_empty: bool = False,
+) -> requests.Response:
+    last = None
+    hdrs = headers or {}
+    for attempt in range(1, retries + 1):
+        try:
+            if sleep:
+                time.sleep(sleep)
+            resp = get_session(ua).get(url, timeout=timeout, headers=hdrs, params=params)
+            if resp.status_code in (429, 500, 502, 503, 504) and attempt < retries:
+                time.sleep(min(30, 2 ** attempt))
+                last = resp
+                continue
+            if resp.status_code == 200 and (allow_empty or resp.content):
+                return resp
+            if resp.status_code in (404, 410, 403, 401):
+                return resp
+            last = resp
+            if attempt < retries:
+                time.sleep(min(20, 1.5 * attempt))
+                continue
+            return resp
+        except requests.RequestException as exc:
+            last = exc
+            time.sleep(min(20, 1.5 * attempt))
+    if isinstance(last, requests.Response):
+        return last
+    raise RuntimeError(f"GET failed {url}: {last}")
+
+
+class _HTMLText(HTMLParser):
+    SKIP = {"script", "style", "noscript", "svg", "nav", "footer", "header"}
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: list[str] = []
+        self.skip = 0
+        self._block = {
+            "p", "div", "br", "tr", "li", "h1", "h2", "h3", "h4", "h5", "h6",
+            "article", "section", "blockquote", "pre", "td", "th", "dt", "dd",
+        }
+
+    def handle_starttag(self, tag, attrs):
+        if tag in self.SKIP:
+            self.skip += 1
+        if tag in {"br", "p", "tr", "div", "li", "h1", "h2", "h3"} and self.skip == 0:
+            self.parts.append("\n")
+
+    def handle_endtag(self, tag):
+        if tag in self.SKIP and self.skip:
+            self.skip -= 1
+        if tag in self._block and self.skip == 0:
+            self.parts.append("\n")
+
+    def handle_data(self, data):
+        if self.skip == 0:
+            self.parts.append(data)
+
+
+def html_to_text(raw: str) -> str:
+    if not raw:
+        return ""
+    p = _HTMLText()
+    try:
+        p.feed(raw)
+        p.close()
+    except Exception:
+        raw = re.sub(r"(?is)<script.*?>.*?</script>", " ", raw)
+        raw = re.sub(r"(?is)<style.*?>.*?</style>", " ", raw)
+        raw = re.sub(r"(?is)<[^>]+>", " ", raw)
+        return re.sub(r"[ \t]+\n", "\n", html.unescape(raw)).strip()
+    text = "".join(p.parts)
+    text = html.unescape(text)
+    text = text.replace("\xa0", " ")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n[ \t]+", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def xml_to_text(raw: str, skip_tags: Optional[set[str]] = None) -> str:
+    skip_tags = skip_tags or {
+        "meta", "identification", "references", "classification",
+        "workflow", "analysis", "proprietary", "presentation",
+    }
+    try:
+        root = ET.fromstring(raw)
+    except ET.ParseError:
+        return html_to_text(raw)
+    parts: list[str] = []
+
+    def walk(el: ET.Element) -> None:
+        tag = localtag(el.tag).lower()
+        if tag in skip_tags:
+            return
+        if el.text and el.text.strip():
+            parts.append(el.text.strip())
+        for child in list(el):
+            walk(child)
+            if child.tail and child.tail.strip():
+                parts.append(child.tail.strip())
+        if tag in {"p", "article", "chapter", "section", "alinea", "paragraph", "item"}:
+            parts.append("\n")
+
+    walk(root)
+    text = " ".join(parts)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r" *\n *", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+ARTICLE_SPLIT = re.compile(
+    r"(?im)^\s*((?:art(?:icle|ikel|\.)|§|článek|článok|član|artikkel|articolo|"
+    r"artigo|artículo|artykuł|art\.\s*|str\.\s*|para(?:graph)?\.?|szakasz|"
+    r"άρθρο|Άρθρο|ΑΡΘΡΟ)\s+"
+    r"[\dIVXLCDMΑ-Ω]+[a-zA-ZΑ-Ωa-z]?)\b"
+)
+
+
+
+def split_articles(text: str, law_id: str, source_url: str, date: Optional[str] = None) -> list[dict]:
+    if not text or len(text) < 40:
+        return []
+    matches = list(ARTICLE_SPLIT.finditer(text))
+    if len(matches) < 2:
+        return []
+    docs = []
+    for i, m in enumerate(matches):
+        start = m.start()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        chunk = text[start:end].strip()
+        num = re.sub(r"\s+", " ", m.group(1)).strip()
+        aid = re.sub(r"[^a-z0-9]+", "-", num.lower()).strip("-")
+        heading = chunk.split("\n", 1)[0][:200]
+        docs.append({
+            "id": f"{law_id}-{aid}"[:180],
+            "title": heading,
+            "text": chunk,
+            "date_filed": date,
+            "document_number": num,
+            "source_url": source_url,
+            "record_type": "article",
+            "article_number": num,
+            "law_identifier": law_id,
+            "metadata": {"text_extraction": {"source": "official", "backend": "collector"}},
+        })
+        if len(docs) >= 4000:
+            break
+    return docs
+
+
+def load_schema():
+    global _schema
+    with _schema_lock:
+        if _schema is None:
+            with SCHEMA_PATH.open(encoding="utf-8") as f:
+                _schema = json.load(f)
+        return _schema
+
+
+def validate_record(record: dict) -> Optional[str]:
+    try:
+        import jsonschema
+        jsonschema.Draft202012Validator(load_schema()).validate(record)
+        return None
+    except Exception as exc:
+        return str(exc)
+
+
+def existing_ids(cc: str) -> set[str]:
+    d = ROOT / cc / "instruments"
+    if not d.exists():
+        return set()
+    return {p.stem for p in d.glob("*.json")}
+
+
+def write_instrument(cc: str, record: dict) -> Path:
+    ident = record["id"]
+    dest = ROOT / cc / "instruments" / f"{ident}.json"
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    body = json.dumps(record, ensure_ascii=False, indent=2) + "\n"
+    atomic_write(dest, body)
+    index_line = {k: record.get(k) for k in INDEX_FIELDS if k != "path" and k != "bytes" and k != "article_count"}
+    index_line["path"] = f"instruments/{ident}.json"
+    index_line["article_count"] = record.get("article_count") or len(record.get("documents") or [])
+    index_line["bytes"] = dest.stat().st_size
+    index_line["id"] = ident
+    with _index_lock:
+        with (ROOT / cc / "index.jsonl").open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(index_line, ensure_ascii=False) + "\n")
+    return dest
+
+
+def log_failure(cc: str, payload: dict) -> None:
+    path = ROOT / cc / "failures.jsonl"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = dict(payload)
+    payload.setdefault("retrieved_at", utcnow())
+    with _fail_lock:
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+
+def append_catalog(cc: str, row: dict) -> None:
+    path = ROOT / cc / "raw" / "catalog.jsonl"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with _index_lock:
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def law_status_hist(cc: str) -> Counter:
+    c: Counter = Counter()
+    d = ROOT / cc / "instruments"
+    if not d.exists():
+        return c
+    for p in d.glob("*.json"):
+        try:
+            rec = json.loads(p.read_text(encoding="utf-8"))
+            c[rec.get("law_status") or "unknown"] += 1
+        except Exception:
+            c["unknown"] += 1
+    return c
+
+
+def corpus_bytes(cc: str) -> int:
+    d = ROOT / cc / "instruments"
+    if not d.exists():
+        return 0
+    return sum(p.stat().st_size for p in d.glob("*.json"))
+
+
+def count_jsonl(path: Path) -> int:
+    if not path.exists():
+        return 0
+    n = 0
+    with path.open(encoding="utf-8") as f:
+        for _ in f:
+            n += 1
+    return n
+
+
+def write_summary(
+    cc: str,
+    *,
+    country: str,
+    source: str,
+    source_urls: Iterable[str],
+    license_text: str,
+    discovered: int,
+    fetched: int,
+    skipped: int,
+    failed: int,
+    coverage: str,
+    notes: str,
+    last_run: Optional[str] = None,
+    extra: Optional[str] = None,
+) -> None:
+    last_run = last_run or utcnow()
+    instr = ROOT / cc / "instruments"
+    n_json = len(list(instr.glob("*.json"))) if instr.exists() else 0
+    n_index = count_jsonl(ROOT / cc / "index.jsonl")
+    hist = law_status_hist(cc)
+    nbytes = corpus_bytes(cc)
+    lines = [
+        f"# {country} legislation corpus",
+        "",
+        f"- jurisdiction: {cc.upper()}",
+        f"- source: {source}",
+        f"- last_run_retrieved_at: {last_run} (PT: {pt_from_iso(last_run)})",
+        f"- instruments_json: {n_json}",
+        f"- index_jsonl_lines: {n_index}",
+        f"- discovered: {discovered}",
+        f"- fetched: {fetched}",
+        f"- skipped: {skipped}",
+        f"- failed: {failed}",
+        "- law_status: " + ", ".join(f"{k}={v}" for k, v in sorted(hist.items())) if hist else "- law_status: (none)",
+        f"- coverage: {coverage}",
+        f"- total_json_bytes: {nbytes}",
+        f"- license: {license_text}",
+        "- source_urls:",
+    ]
+    for u in source_urls:
+        lines.append(f"  - {u}")
+    lines.append("- notes:")
+    for n in (notes or "").splitlines():
+        lines.append(f"  {n}")
+    if extra:
+        lines.append("")
+        lines.append(extra)
+    lines.append("")
+    atomic_write(ROOT / cc / "SUMMARY.md", "\n".join(lines))
+
+
+def base_record(
+    *,
+    cc: str,
+    country: str,
+    language: str,
+    ident: str,
+    title: str,
+    text: str,
+    source_url: str,
+    source_type: str,
+    license_text: str,
+    collector: str,
+    eli: Optional[str] = None,
+    date: Optional[str] = None,
+    official_identifier: Optional[str] = None,
+    document_type: str = "statute",
+    law_status: str = "current",
+    is_current: Optional[bool] = True,
+    documents: Optional[list] = None,
+    extra_meta: Optional[dict] = None,
+    extra_fields: Optional[dict] = None,
+) -> dict:
+    rid = slug_id(cc, ident)
+    docs = documents if documents is not None else split_articles(text, rid, source_url, date)
+    rec = {
+        "schema_version": "collection_record.v1",
+        "record_type": "law",
+        "id": rid,
+        "title": title or ident,
+        "text": text or "",
+        "source_url": source_url,
+        "source_type": source_type,
+        "date": date,
+        "jurisdiction": cc.upper(),
+        "country": country,
+        "language": language,
+        "eli": eli,
+        "license": license_text,
+        "retrieved_at": utcnow(),
+        "identifier": official_identifier or ident,
+        "official_identifier": official_identifier or ident,
+        "law_identifier": official_identifier or ident,
+        "document_type": document_type,
+        "law_status": law_status,
+        "is_current": is_current,
+        "canonical_law_url": source_url,
+        "article_count": len(docs),
+        "article_extraction_status": "ok" if docs else "missing",
+        "documents": docs,
+        "metadata": {
+            "collector": collector,
+            "schema": "collection_record.v1",
+            "source_host": re.sub(r"^https?://", "", source_url).split("/")[0] if source_url else "",
+            "content_sha256": sha256_text(text or ""),
+            "rights": {
+                "not_legal_advice": True,
+                "official_reuse_url": source_url,
+                "license": license_text,
+            },
+            "text_extraction": {"source": "official", "backend": "collector"},
+        },
+    }
+    if extra_meta:
+        rec["metadata"].update(extra_meta)
+    if extra_fields:
+        rec.update(extra_fields)
+    return rec
+
+
+def ensure_dirs(cc: str) -> Path:
+    root = ROOT / cc
+    (root / "instruments").mkdir(parents=True, exist_ok=True)
+    (root / "raw").mkdir(parents=True, exist_ok=True)
+    (root / "logs").mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def iso_date(val: Optional[str]) -> Optional[str]:
+    if not val:
+        return None
+    val = str(val).strip()
+    m = re.match(r"^(\d{4})(\d{2})(\d{2})$", val)
+    if m:
+        return f"{m.group(1)}-{m.group(2)}-{m.group(3)}"
+    m = re.match(r"^(\d{4}-\d{2}-\d{2})", val)
+    if m:
+        return m.group(1)
+    m = re.match(r"^(\d{2})[./](\d{2})[./](\d{4})$", val)
+    if m:
+        return f"{m.group(3)}-{m.group(2)}-{m.group(1)}"
+    return None

scrapers/pdf_extract_lib.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""PDF text extraction helpers mirroring ipfs_datasets_py IntegratedPDFProcessor.
+
+Prefer pdfplumber -> pymupdf -> pdftotext; OCR (tesseract) only when text layer
+is missing or garbage. Honest article splits require >=2 heading matches.
+"""
+from __future__ import annotations
+
+import io
+import logging
+import re
+import subprocess
+import tempfile
+from typing import Optional
+
+log = logging.getLogger("pdf_extract_lib")
+
+# Spaced-out OCR garbage like "D  IA     R       IO"
+_GARBAGE_SPACING = re.compile(r"(?:^[A-Za-z]\s+){6,}", re.M)
+
+
+def is_garbage_text(text: str) -> bool:
+    if not text or len(text) < 40:
+        return True
+    if text.lstrip().startswith("%PDF") or "endobj" in text[:200]:
+        return True
+    if "IHDR" in text[:120] or text[:8].startswith("\x89PNG") or "PNG" in text[:20] and "IHDR" in text[:80]:
+        return True
+    sample = text[:4000]
+    letters = sum(ch.isalpha() for ch in sample)
+    spaces = sample.count(" ")
+    if letters < 80:
+        return True
+    if spaces > letters * 1.8 and _GARBAGE_SPACING.search(sample):
+        return True
+    # high ratio of isolated single letters
+    singles = len(re.findall(r"(?m)^\s*[A-Za-zÁÉÍÓÚÑáéíóúñ]\s*$", sample))
+    if singles > 30 and singles > letters * 0.15:
+        return True
+    return False
+
+
+def extract_pdfplumber(raw: bytes, max_pages: int = 200) -> tuple[str, int]:
+    import pdfplumber
+    with pdfplumber.open(io.BytesIO(raw)) as pdf:
+        n = len(pdf.pages)
+        parts = []
+        for page in pdf.pages[:max_pages]:
+            try:
+                parts.append(page.extract_text() or "")
+            except Exception:
+                continue
+    text = "\n".join(parts)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    return text, n
+
+
+def extract_pymupdf(raw: bytes, max_pages: int = 200) -> tuple[str, int]:
+    import pymupdf
+    doc = pymupdf.open(stream=raw, filetype="pdf")
+    n = doc.page_count
+    parts = [page.get_text() for page in doc[:max_pages]]
+    text = "\n".join(parts)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    return text, n
+
+
+def extract_pdftotext(raw: bytes) -> str:
+    if not raw or raw[:4] != b"%PDF":
+        return ""
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=True) as tmp:
+            tmp.write(raw)
+            tmp.flush()
+            proc = subprocess.run(
+                ["pdftotext", "-layout", "-enc", "UTF-8", tmp.name, "-"],
+                check=False, capture_output=True, timeout=180,
+            )
+        if proc.returncode == 0 and proc.stdout:
+            return proc.stdout.decode("utf-8", "replace").strip()
+    except Exception as exc:
+        log.warning("pdftotext: %s", exc)
+    return ""
+
+
+def extract_ocr(raw: bytes, lang: str = "eng", max_pages: int = 40, dpi: int = 120) -> tuple[str, int]:
+    """Render pages with pymupdf and OCR via tesseract CLI."""
+    import pymupdf
+    doc = pymupdf.open(stream=raw, filetype="pdf")
+    n = doc.page_count
+    parts = []
+    mat = pymupdf.Matrix(dpi / 72, dpi / 72)
+    for i, page in enumerate(doc):
+        if i >= max_pages:
+            break
+        pix = page.get_pixmap(matrix=mat, alpha=False)
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as img:
+            pix.save(img.name)
+            img_path = img.name
+        try:
+            env = dict(**__import__("os").environ)
+            env["OMP_THREAD_LIMIT"] = "1"
+            env["TESSDATA_PREFIX"] = env.get("TESSDATA_PREFIX", "/usr/share/tesseract-ocr/5/tessdata")
+            proc = subprocess.run(
+                ["tesseract", img_path, "stdout", "-l", lang, "--psm", "6"],
+                capture_output=True, text=True, timeout=180, env=env,
+            )
+            if proc.returncode == 0 and proc.stdout:
+                parts.append(proc.stdout)
+        except Exception as exc:
+            log.debug("ocr page %s: %s", i, exc)
+        finally:
+            try:
+                import os
+                os.unlink(img_path)
+            except Exception:
+                pass
+    text = "\n".join(parts)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    return text, n
+
+
+def extract_pdf_text(
+    raw: bytes,
+    *,
+    enable_ocr: bool = True,
+    ocr_lang: str = "eng",
+    ocr_max_pages: int = 40,
+) -> tuple[str, str, int]:
+    """Return (text, method, page_count). Mirrors IntegratedPDFProcessor order."""
+    if not raw:
+        return "", "not_pdf", 0
+    if raw[:4] != b"%PDF":
+        idx = raw.find(b"%PDF", 0, 65536)
+        if idx < 0:
+            return "", "not_pdf", 0
+        raw = raw[idx:]
+    best_text, best_method, pages = "", "failed", 0
+    for name, fn in (
+        ("pdfplumber", lambda: extract_pdfplumber(raw)),
+        ("pymupdf", lambda: extract_pymupdf(raw)),
+    ):
+        try:
+            text, pages = fn()
+            if text and not is_garbage_text(text) and len(text) >= 80:
+                return text, name, pages
+            if len(text) > len(best_text):
+                best_text, best_method = text, name
+        except Exception as exc:
+            log.debug("%s failed: %s", name, exc)
+    try:
+        text = extract_pdftotext(raw)
+        if text and not is_garbage_text(text) and len(text) >= 80:
+            return text, "pdftotext", pages
+        if len(text) > len(best_text):
+            best_text, best_method = text, "pdftotext"
+    except Exception:
+        pass
+    if enable_ocr and (is_garbage_text(best_text) or len(best_text) < 120):
+        try:
+            text, pages = extract_ocr(raw, lang=ocr_lang, max_pages=ocr_max_pages)
+            if text and len(text) >= 80 and not is_garbage_text(text):
+                return text, "ocr_tesseract", pages
+            if len(text) > len(best_text):
+                best_text, best_method = text, "ocr_tesseract"
+        except Exception as exc:
+            log.debug("ocr failed: %s", exc)
+    return best_text, best_method if best_text else "failed", pages
+
+
+def normalize_bidi(text: str) -> str:
+    return re.sub(r"[\u200e\u200f\u202a-\u202e\u2066-\u2069]", "", text or "")
+
+
+def split_by_pattern(
+    text: str,
+    law_id: str,
+    source_url: str,
+    pat: re.Pattern,
+    record_type: str = "article",
+    min_chunk: int = 40,
+    max_docs: int = 4000,
+) -> list[dict]:
+    matches = list(pat.finditer(text or ""))
+    if len(matches) < 2:
+        return []
+    docs = []
+    for i, m in enumerate(matches):
+        start = m.start()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        chunk = text[start:end].strip()
+        if len(chunk) < min_chunk:
+            continue
+        num = re.sub(r"\s+", " ", m.group(1)).strip()
+        aid = re.sub(r"[^\w\u0600-\u06FF\u1200-\u137F]+", "-", num.lower(), flags=re.U).strip("-")[:80]
+        heading = chunk.split("\n", 1)[0][:200]
+        docs.append({
+            "id": f"{law_id}-{aid}"[:180],
+            "title": heading,
+            "text": chunk,
+            "date_filed": None,
+            "document_number": num,
+            "source_url": source_url,
+            "record_type": record_type,
+            "article_number": num,
+            "law_identifier": law_id,
+            "metadata": {
+                "text_extraction": {
+                    "source": "official",
+                    "backend": "honest_heading_split",
+                    "parser": "ipfs_datasets_py.IntegratedPDFProcessor+heading_split",
+                    "pattern": pat.pattern[:100],
+                }
+            },
+        })
+        if len(docs) >= max_docs:
+            break
+    return docs if len(docs) >= 2 else []
+
+
+# Country-specific honest patterns (tried in order)
+COUNTRY_PATTERNS: dict[str, list[tuple[str, re.Pattern, str]]] = {
+    "sv": [
+        ("articulo", re.compile(r"(?im)^\s*((?:Art(?:[íi]culo|\.)?|ART[IÍ]CULO)\s+\d+[º°a-z.]*)"), "article"),
+    ],
+    "tn": [
+        ("fasl", re.compile(r"(?m)^\s*((?:الفصل|المادة)\s+\S+)"), "article"),
+        ("article", re.compile(r"(?im)^\s*((?:Article|Art\.)\s+\d+)"), "article"),
+    ],
+    "et": [
+        ("article_heading", re.compile(r"(?im)^\s*((?:Article|Art\.)\s+\d+\.?)\s*(?:[.\-–—:]|\s+[A-Z\"“])"), "article"),
+        ("article_loose", re.compile(r"(?im)^\s*((?:Article|Art\.)\s+\d+)"), "article"),
+        ("anqets", re.compile(r"(?m)^\s*((?:አንቀጽ|አንቀፅ)\s*[/\.]?\s*\d+)"), "article"),
+        ("anqets_inline", re.compile(r"(?m)((?:አንቀጽ|አንቀፅ)\s*[/.]?\s*\d+)"), "article"),
+    ],
+    "jm": [
+        ("section", re.compile(r"(?im)^\s*((?:Section|SECTION)\s+\d+[A-Za-z]?\.?)"), "section"),
+        ("part", re.compile(r"(?im)^\s*((?:PART|Part)\s+[IVXLC\d]+)"), "section"),
+    ],
+    "fj": [
+        ("numbered_emdash", re.compile(r"(?m)^\s*((?:\d+)\.—)"), "article"),
+        ("section", re.compile(r"(?im)^\s*((?:Section|SECTION|Article|ARTICLE)\s+\d+)"), "article"),
+        ("chapter", re.compile(r"(?im)^\s*((?:CHAPTER|Chapter)\s+\d+)"), "section"),
+    ],
+    "la": [
+        ("article", re.compile(r"(?im)^\s*((?:Article|Art\.|ມາດຕາ)\s*\d+)"), "article"),
+    ],
+    "lk": [
+        ("section", re.compile(r"(?im)^\s*((?:Section|SECTION)\s+\d+[A-Za-z]?)"), "section"),
+        ("article", re.compile(r"(?im)^\s*((?:Article|ARTICLE)\s+\d+)"), "article"),
+    ],
+    "md": [
+        ("articolul", re.compile(r"(?im)^\s*((?:Articolul|Art\.)\s*\d+(?:\^[0-9]+)?)"), "article"),
+        ("articolul_inline", re.compile(r"(?im)((?:Articolul|Art\.)\s*\d+(?:\^[0-9]+)?)\s*[.\-–—:]"), "article"),
+    ],
+    "mz": [
+        ("artigo", re.compile(r"(?im)^\s*((?:Artigo|Art\.|ARTIGO)\s+\d+[ºªo°a-zA-Z]?)"), "article"),
+    ],
+}
+
+
+def honest_split(cc: str, text: str, law_id: str, source_url: str) -> tuple[list[dict], str]:
+    text_n = normalize_bidi(text) if cc == "tn" else text
+    for name, pat, rtype in COUNTRY_PATTERNS.get(cc, []):
+        docs = split_by_pattern(text_n, law_id, source_url, pat, rtype)
+        if docs:
+            return docs, name
+    # shared fallback
+    from common import split_articles
+    docs = split_articles(text_n, law_id, source_url)
+    if len(docs) >= 2:
+        return docs, "common_article_split"
+    return [], "none"

scrapers/world_lib.py

@@ -0,0 +1,433 @@
+#!/usr/bin/env python3
+"""Shared helpers for new-country official gazette collectors."""
+from __future__ import annotations
+
+import logging
+import os
+import re
+import time
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urljoin, urlparse
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import (
+    ROOT,
+    DEFAULT_UA,
+    base_record,
+    ensure_dirs,
+    existing_ids,
+    html_to_text,
+    http_get,
+    iso_date,
+    log_failure,
+    slug_id,
+    split_articles,
+    utcnow,
+    write_instrument,
+    write_summary,
+)
+import archive_fallbacks as af
+
+log = logging.getLogger("world_lib")
+
+MIN_TEXT = 80
+MAX_PDF = 35 * 1024 * 1024
+
+
+def setup_log(cc: str, name: str | None = None) -> None:
+    ensure_dirs(cc)
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(message)s",
+        handlers=[
+            logging.FileHandler(ROOT / cc / "logs" / "collector.log", encoding="utf-8"),
+            logging.StreamHandler(sys.stdout),
+        ],
+        force=True,
+    )
+
+
+def pdf_to_text(raw: bytes) -> str:
+    """Extract text via pdftotext. Tries qpdf --decrypt first for copy-restricted
+    digital PDFs (still not OCR — image-only scans stay empty)."""
+    if not raw:
+        return ""
+    if raw[:4] != b"%PDF":
+        idx = raw.find(b"%PDF")
+        if idx < 0 or idx > 8192:
+            return ""
+        raw = raw[idx:]
+    try:
+        with tempfile.TemporaryDirectory() as d:
+            dpath = Path(d)
+            src = dpath / "in.pdf"
+            src.write_bytes(raw)
+            candidates = [src]
+            dec = dpath / "dec.pdf"
+            try:
+                q = subprocess.run(
+                    ["qpdf", "--decrypt", str(src), str(dec)],
+                    check=False,
+                    capture_output=True,
+                    timeout=120,
+                )
+                if q.returncode == 0 and dec.exists() and dec.stat().st_size > 1000:
+                    candidates.insert(0, dec)
+            except Exception:
+                pass
+            best = ""
+            for cand in candidates:
+                for args in (
+                    ["pdftotext", "-layout", "-enc", "UTF-8", str(cand), "-"],
+                    ["pdftotext", "-raw", "-enc", "UTF-8", str(cand), "-"],
+                ):
+                    proc = subprocess.run(
+                        args, check=False, capture_output=True, timeout=180
+                    )
+                    if proc.returncode == 0 and proc.stdout:
+                        text = proc.stdout.decode("utf-8", "replace").strip()
+                        # Ignore form-feed-only / tiny junk from image-only pages
+                        if len(text) > len(best):
+                            best = text
+                if len(best) >= 150:
+                    break
+            return best
+    except Exception as exc:
+        log.warning("pdftotext: %s", exc)
+    return ""
+
+
+def split_custom(text: str, law_id: str, source_url: str, date: Optional[str], pattern: Optional[re.Pattern]) -> list[dict]:
+    docs = split_articles(text, law_id, source_url, date)
+    if not pattern:
+        return docs
+    matches = list(pattern.finditer(text or ""))
+    if len(matches) < 2:
+        return docs if len(docs) >= 2 else []
+    out = []
+    for i, m in enumerate(matches):
+        start = m.start()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        chunk = text[start:end].strip()
+        if len(chunk) < 20:
+            continue
+        num = re.sub(r"\s+", " ", m.group(1)).strip()
+        aid = re.sub(r"[^a-zA-Z0-9\u0400-\u04FF\u0530-\u058F-]+", "-", num.lower()).strip("-")[:80]
+        heading = chunk.split("\n", 1)[0][:200]
+        out.append({
+            "id": f"{law_id}-{aid}"[:180],
+            "title": heading,
+            "text": chunk,
+            "date_filed": date,
+            "document_number": num,
+            "source_url": source_url,
+            "record_type": "article",
+            "article_number": num,
+            "law_identifier": law_id,
+            "metadata": {"text_extraction": {"source": "official", "backend": "collector"}},
+        })
+        if len(out) >= 4000:
+            break
+    return out if len(out) >= 2 else docs
+
+
+def live_get(url: str, *, ua: str = DEFAULT_UA, timeout: tuple = (20, 90), verify: bool = True, retries: int = 3):
+    import requests
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+    last = None
+    headers = {"User-Agent": ua, "Accept": "application/pdf, text/html, application/xml, */*"}
+    for attempt in range(1, retries + 1):
+        try:
+            time.sleep(0.2)
+            resp = requests.get(url, timeout=timeout, headers=headers, verify=verify, allow_redirects=True)
+            return resp
+        except Exception as exc:
+            last = exc
+            if verify and ("SSL" in type(exc).__name__ or "SSL" in str(exc)):
+                try:
+                    resp = requests.get(url, timeout=timeout, headers=headers, verify=False, allow_redirects=True)
+                    return resp
+                except Exception as exc2:
+                    last = exc2
+            time.sleep(min(8, 1.5 * attempt))
+    raise RuntimeError(f"live_get failed {url}: {last}")
+
+
+def fetch_official(
+    url: str,
+    *,
+    ua: str = DEFAULT_UA,
+    verify: bool = True,
+    wayback: bool = True,
+    wayback_ts: Optional[str] = None,
+    min_text: int = MIN_TEXT,
+) -> dict:
+    """Live official URL first; Wayback of the same official URL on failure. No WAF bypass."""
+    out = {
+        "status": "error",
+        "text": "",
+        "content": b"",
+        "source_url": url,
+        "method": "",
+        "content_type": "",
+        "error": "",
+    }
+    body = b""
+    ctype = ""
+    try:
+        r = live_get(url, ua=ua, verify=verify)
+        body = r.content or b""
+        ctype = r.headers.get("content-type") or ""
+        if r.status_code == 200 and body:
+            is_pdf = (
+                body[:4] == b"%PDF"
+                or (0 <= body.find(b"%PDF") <= 64)
+                or "pdf" in ctype.lower()
+            )
+            if is_pdf:
+                text = pdf_to_text(body)
+                if len(text) >= min_text:
+                    out.update(status="success", text=text, content=body, method="http_pdf", content_type=ctype)
+                    return out
+            text = ""
+            if "html" in ctype.lower() or "xml" in ctype.lower() or "json" in ctype.lower() or body[:1] in (b"<", b"{", b"["):
+                raw = body.decode(r.encoding or "utf-8", "replace")
+                if af.is_challenge(raw, r.status_code):
+                    out["error"] = "challenge_or_shell"
+                else:
+                    text = html_to_text(raw) if "<" in raw[:500] else raw
+                    if len(text) >= min_text and not af.is_spa_shell(raw, text):
+                        out.update(status="success", text=text, content=body, method="http_html", content_type=ctype)
+                        return out
+                    if len(text) < min_text:
+                        out["error"] = "short_or_spa"
+            elif body[:4] == b"%PDF" or (0 <= body.find(b"%PDF") <= 64):
+                # Keep bytes so callers (OCR) can work without a second download
+                pdf_body = body if body[:4] == b"%PDF" else body[body.find(b"%PDF"):]
+                out["error"] = "pdf_extract_failed"
+                out["content"] = pdf_body
+                out["content_type"] = ctype or "application/pdf"
+            elif len(body) > min_text:
+                try:
+                    text = body.decode("utf-8", "replace")
+                    if text.lstrip().startswith("%PDF") or "endobj" in text[:200]:
+                        out["error"] = "raw_pdf_bytes"
+                    elif len(text) >= min_text:
+                        out.update(status="success", text=text, content=body, method="http_text", content_type=ctype)
+                        return out
+                except Exception:
+                    pass
+        else:
+            out["error"] = f"http_{getattr(r, 'status_code', '?')}"
+    except Exception as exc:
+        out["error"] = f"live:{exc}"
+
+    if wayback:
+        try:
+            w = af.get_wayback_content(url, timestamp=wayback_ts)
+            if w.get("status") == "success":
+                raw_b = w.get("content") or b""
+                raw_t = w.get("text") or ""
+                pdf_bytes = b""
+                if isinstance(raw_b, (bytes, bytearray)) and raw_b:
+                    if raw_b[:4] == b"%PDF":
+                        pdf_bytes = bytes(raw_b)
+                    else:
+                        _idx = raw_b.find(b"%PDF", 0, 8192)
+                        if _idx >= 0:
+                            pdf_bytes = bytes(raw_b[_idx:])
+                if not pdf_bytes and raw_t:
+                    enc = raw_t.encode("latin-1", "replace")
+                    if enc[:4] == b"%PDF":
+                        pdf_bytes = enc
+                    else:
+                        _idx = enc.find(b"%PDF", 0, 8192)
+                        if _idx >= 0:
+                            pdf_bytes = enc[_idx:]
+                if pdf_bytes or (isinstance(raw_b, bytes) and (w.get("content_type") or "").lower().find("pdf") >= 0):
+                    if not pdf_bytes and isinstance(raw_b, bytes):
+                        pdf_bytes = raw_b
+                    text = pdf_to_text(pdf_bytes)
+                    if len(text) >= min_text and not text.lstrip().startswith("%PDF"):
+                        out.update(
+                            status="success",
+                            text=text,
+                            content=pdf_bytes,
+                            method="wayback_pdf",
+                            source_url=w.get("wayback_url") or w.get("url") or url,
+                            content_type="application/pdf",
+                        )
+                        return out
+                    out["error"] = (out.get("error") or "") + ";pdf_extract_failed"
+                    return out
+                if not raw_t and isinstance(raw_b, bytes):
+                    raw_t = raw_b.decode("utf-8", "replace")
+                if raw_t.lstrip().startswith("%PDF") or "endobj" in raw_t[:400] or "startxref" in raw_t[:800]:
+                    out["error"] = (out.get("error") or "") + ";raw_pdf_bytes"
+                    return out
+                text = html_to_text(raw_t) if "<" in (raw_t[:400] or "") else raw_t
+                if len(text) >= min_text and not af.is_challenge(raw_t, 200):
+                    out.update(
+                        status="success",
+                        text=text,
+                        content=raw_b if isinstance(raw_b, bytes) else raw_t.encode("utf-8", "replace"),
+                        method="wayback_html",
+                        source_url=w.get("url") or url,
+                        content_type=w.get("content_type") or "text/html",
+                    )
+                    return out
+                out["error"] = (out.get("error") or "") + ";wayback_short"
+            else:
+                out["error"] = (out.get("error") or "") + f";wayback:{w.get('error')}"
+        except Exception as exc:
+            out["error"] = (out.get("error") or "") + f";wayback:{exc}"
+    return out
+
+
+
+def best_cdx_pdf_timestamp(url: str) -> Optional[str]:
+    """Pick a CDX snapshot timestamp that looks like a real PDF (status 200)."""
+    try:
+        # Prefer exact URL match via prefix of the path
+        from urllib.parse import urlsplit
+        parts = urlsplit(url)
+        host = (parts.hostname or "").replace("www.", "")
+        path = parts.path or "/"
+        # try a few URL variants
+        candidates = []
+        for u in (url, url.replace("https://", "http://"), url.replace("http://", "https://")):
+            u2 = u.replace(":80/", "/")
+            for h in cdx_urls(u2, limit=20, match_type="exact"):
+                candidates.append(h)
+            # also prefix on host+path
+        prefix = f"{host}{path}".lstrip("/")
+        if prefix:
+            for h in cdx_urls(prefix, limit=30, match_type="prefix",
+                              extra_filters=["mimetype:application/pdf"]):
+                candidates.append(h)
+            for h in cdx_urls("www." + prefix, limit=30, match_type="prefix",
+                              extra_filters=["mimetype:application/pdf"]):
+                candidates.append(h)
+        best = None
+        for h in candidates:
+            ts = h.get("timestamp") or ""
+            sc = str(h.get("statuscode") or h.get("status") or "")
+            mt = (h.get("mimetype") or "").lower()
+            orig = (h.get("original") or "").lower()
+            if not ts:
+                continue
+            if sc and sc not in ("200", "226", "-"):
+                continue
+            score = 0
+            if "pdf" in mt or orig.endswith(".pdf"):
+                score += 2
+            if sc == "200":
+                score += 1
+            if best is None or score > best[0] or (score == best[0] and ts > best[1]):
+                best = (score, ts)
+        return best[1] if best else None
+    except Exception as exc:
+        log.info("best_cdx_pdf_timestamp fail %s: %s", url[:80], exc)
+        return None
+
+
+def fetch_official_prefer_pdf(
+    url: str,
+    *,
+    ua: str = DEFAULT_UA,
+    verify: bool = True,
+    min_text: int = MIN_TEXT,
+    wayback_ts: Optional[str] = None,
+) -> dict:
+    """Live first; on failure, Wayback with CDX PDF timestamp when available."""
+    got = fetch_official(url, ua=ua, verify=verify, wayback=True, wayback_ts=wayback_ts, min_text=min_text)
+    if got.get("status") == "success" and not (got.get("text") or "").lstrip().startswith("%PDF"):
+        # reject obvious HTML shells mistaken for success when URL is a PDF
+        if url.lower().endswith(".pdf") and got.get("method") == "wayback_html":
+            pass  # try timestamped below
+        else:
+            return got
+    ts = wayback_ts or best_cdx_pdf_timestamp(url)
+    if ts:
+        got2 = fetch_official(url, ua=ua, verify=verify, wayback=True, wayback_ts=ts, min_text=min_text)
+        if got2.get("status") == "success":
+            return got2
+        # try http variant with same ts
+        alt = url.replace("https://", "http://") if url.startswith("https://") else url.replace("http://", "https://")
+        got3 = fetch_official(alt, ua=ua, verify=verify, wayback=True, wayback_ts=ts, min_text=min_text)
+        if got3.get("status") == "success":
+            return got3
+    return got
+
+def first_title(text: str, fallback: str) -> str:
+    for line in (text or "").splitlines():
+        s = line.strip()
+        if len(s) >= 12 and not s.lower().startswith("just a moment"):
+            return s[:240]
+    return fallback[:240]
+
+
+def save_instrument(
+    *,
+    cc: str,
+    country: str,
+    language: str,
+    ident: str,
+    title: str,
+    text: str,
+    source_url: str,
+    source_type: str,
+    license_text: str,
+    collector: str,
+    date: Optional[str] = None,
+    article_re: Optional[re.Pattern] = None,
+    extra_meta: Optional[dict] = None,
+) -> bool:
+    if not text or len(text) < MIN_TEXT:
+        return False
+    rid = slug_id(cc, ident)
+    docs = split_custom(text, rid, source_url, date, article_re)
+    rec = base_record(
+        cc=cc,
+        country=country,
+        language=language,
+        ident=ident,
+        title=title or first_title(text, ident),
+        text=text,
+        source_url=source_url,
+        source_type=source_type,
+        license_text=license_text,
+        collector=collector,
+        date=iso_date(date) or date,
+        documents=docs,
+        extra_meta=extra_meta,
+    )
+    write_instrument(cc, rec)
+    return True
+
+
+def cdx_urls(host_or_url: str, *, limit: int = 200, match_type: str = "prefix", extra_filters=None) -> list[dict]:
+    try:
+        hits = af.search_wayback_machine(
+            host_or_url,
+            limit=limit,
+            match_type=match_type,
+            collapse="urlkey",
+            extra_filters=extra_filters,
+        )
+    except Exception as exc:
+        log.info("cdx err %s: %s", host_or_url, exc)
+        return []
+    return hits or []
+
+
+def env_int(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, str(default)) or default)
+    except Exception:
+        return default