Add Cabo Verde official snapshot (80 laws / 548 articles; 100% boe.incv.cv)

MANIFEST.md

@@ -0,0 +1,26 @@
+# ipfs_caboverde_laws manifest
+
+generated_utc: 2026-09-09T16:13:07Z
+cc: cv
+laws_rows: 80
+articles_rows: 548
+laws_bytes: 423440
+articles_bytes: 177487
+laws_sha256: f8974a4cbf0e6d5904e5281f1ccea1d5593dd9135a8c19212c95686c2d739659
+articles_sha256: 776e3299f4163bb4f8bceab62bc0545bceafbcbd724419927ac8a435cd1dafb8
+laws_parquet: /workspace/legal-corpora/hf-staging/ipfs_caboverde_laws/data/laws.parquet
+articles_parquet: /workspace/legal-corpora/hf-staging/ipfs_caboverde_laws/data/articles.parquet
+compression: zstd
+collector: scrapers/collect_cv.py
+license: República de Cabo Verde — boe.incv.cv / incv.cv / governo.cv / parlamento.cv / justica.gov.cv / mf.gov.cv / gov.cv. Authentic Boletim Oficial / official text prevails. Not legal advice. Not Portugal (pt) / Angola (ao) / São Tomé (st).
+retrieval: live-and-wayback-of-official
+live_instruments: 80
+archive_instruments: 0
+wayback_instruments: 0
+common_crawl_instruments: 0
+archive_is_instruments: 0
+constitution_present: true
+catalog_expected: None
+catalog_gap: 
+gaps: Official Cabo Verde / Cape Verde (cc=cv) law / Boletim Oficial from *.cv / *.gov.cv only (boe.incv.cv primary). Live-first; Wayback/CDX of official URLs on fail; OCR por+fra+spa for scanned PDFs. Not AfricanLII / Droit-Afrique. No WAF bypass. Distinct from Portugal (pt), Angola (ao), São Tomé (st). Not legal advice.
+uploaded: false

README.md

@@ -0,0 +1,70 @@
+---
+pretty_name: Cabo Verde Laws and Boletim Oficial (boe.incv.cv / Governo / Parlamento / Justiça / Finanças)
+license: other
+license_name: cv-boe-incv-governo-parlamento-official-texts
+language:
+- pt
+task_categories:
+- text-retrieval
+tags:
+- legal
+- law
+- cabo-verde
+- cape-verde
+- boletim-oficial
+- boe
+- incv
+- governo
+- parlamento
+- justica
+- constitucao
+- 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
+---
+
+# Cabo Verde Laws and Boletim Oficial (boe.incv.cv / Governo / Parlamento / Justiça / Finanças)
+
+Research snapshot of official national legislation from **Imprensa Nacional / Boletim Oficial (boe.incv.cv / incv.cv) + Portal do Governo (governo.cv) + Assembleia Nacional (parlamento.cv) + Justiça (justica.gov.cv) + Finanças (mf.gov.cv) / gov.cv / BCV / Tribunal Constitucional (*.cv / *.gov.cv)**.
+
+**Not legal advice.** The official gazette / authentic source prevails over this corpus.
+
+## Snapshot
+
+| Field | Value |
+| --- | --- |
+| Snapshot date | 2026-09-09 |
+| Coverage | catalog-backed incomplete (BOE ActFilter HTML + Bulletin PDF downloads + live crawl governo.cv / parlamento.cv / justica.gov.cv / mf.gov.cv + CDX of official *.cv / *.gov.cv) |
+| Source | Imprensa Nacional / Boletim Oficial (boe.incv.cv / incv.cv) + Portal do Governo (governo.cv) + Assembleia Nacional (parlamento.cv) + Justiça (justica.gov.cv) + Finanças (mf.gov.cv) / gov.cv / BCV / Tribunal Constitucional (*.cv / *.gov.cv) |
+| Collector | `scrapers/collect_cv.py` |
+| Laws / instruments | 80 |
+| Articles | 548 |
+| Language | pt |
+| Jurisdiction | Cabo Verde |
+| License | `cv-boe-incv-governo-parlamento-official-texts` |
+
+## Contents
+
+- `data/laws.parquet` — one row per instrument.
+- `data/articles.parquet` — article/section rows for the same snapshot.
+- `scrapers/collect_cv.py` — research collector used to build this snapshot.
+
+## License / reuse
+
+República de Cabo Verde — boe.incv.cv / incv.cv / governo.cv / parlamento.cv / justica.gov.cv / mf.gov.cv / gov.cv. Authentic Boletim Oficial / official text prevails. Not legal advice. Not Portugal (pt) / Angola (ao) / São Tomé (st)..
+
+This dataset is **not legal advice**. The official source prevails.
+
+## Source
+
+- https://boe.incv.cv/
+
+## Known gaps
+
+Official Cabo Verde / Cape Verde (cc=cv) law / Boletim Oficial from *.cv / *.gov.cv only (boe.incv.cv primary). Live-first; Wayback/CDX of official URLs on fail; OCR por+fra+spa for scanned PDFs. Not AfricanLII / Droit-Afrique. No WAF bypass. Distinct from Portugal (pt), Angola (ao), São Tomé (st). Not legal advice.

data/articles.parquet

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

data/laws.parquet

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

scrapers/archive_fallbacks.py

@@ -0,0 +1,717 @@
+#!/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"  # https SSLEOF from collector host
+WAYBACK_WEB = "http://web.archive.org/web"  # https SSLEOF from collector host
+WAYBACK_CDX_HTTP = "http://web.archive.org/cdx/search/cdx"
+WAYBACK_WEB_HTTP = "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:
+            try:
+                # Prefer HTTP CDX — HTTPS to archive.org often SSLEOF from this host
+                r = session().get(WAYBACK_CDX_HTTP, params=items, timeout=(20, 90))
+            except requests.RequestException:
+                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.
+
+    Prefer HTTP Wayback via curl (requests follows http→https and SSL-EOFs here).
+    Follow 3xx Location only after rewriting https://web.archive.org → http://.
+    """
+    import subprocess
+
+    if timestamp:
+        path = f"/{timestamp}id_/{url}"
+    else:
+        path = f"/2id_/{url}"
+    target = WAYBACK_WEB_HTTP + path
+    last_err = None
+    body = b""
+    ctype = ""
+    final_url = target
+    status = 0
+    for attempt in range(1, 6):
+        _sleep_wayback(0.8 if attempt == 1 else min(8.0, 1.8 * attempt))
+        try:
+            # Stay on HTTP: no -L (redirects flip to https and SSLEOF on this host)
+            proc = subprocess.run(
+                [
+                    "curl", "-sS", "--max-time", "90",
+                    "-A", UA,
+                    "-w", "\n__HTTP_STATUS__%{http_code}\n__CONTENT_TYPE__%{content_type}\n__URL_EFFECTIVE__%{url_effective}\n__REDIRECT_URL__%{redirect_url}",
+                    "--output", "-",
+                    target,
+                ],
+                capture_output=True,
+                timeout=100,
+            )
+            raw = proc.stdout or b""
+            # Trailer is text appended after body when -w is used with --output -
+            marker = b"\n__HTTP_STATUS__"
+            redirect_url = ""
+            if marker in raw:
+                body, rest = raw.rsplit(marker, 1)
+                trailer = (b"__HTTP_STATUS__" + rest).decode("utf-8", "replace")
+                mstat = re.search(r"__HTTP_STATUS__(\d+)", trailer)
+                mctype = re.search(r"__CONTENT_TYPE__([^\n]*)", trailer)
+                murl = re.search(r"__URL_EFFECTIVE__([^\n]*)", trailer)
+                mredir = re.search(r"__REDIRECT_URL__([^\n]*)", trailer)
+                status = int(mstat.group(1)) if mstat else 0
+                ctype = (mctype.group(1) if mctype else "") or ""
+                final_url = (murl.group(1) if murl else target) or target
+                redirect_url = (mredir.group(1) if mredir else "") or ""
+            else:
+                body = raw
+                status = 200 if proc.returncode == 0 and raw else 0
+            if status in (301, 302, 303, 307, 308):
+                loc = redirect_url or ""
+                if loc.startswith("https://web.archive.org/"):
+                    loc = "http://" + loc[len("https://"):]
+                if loc.startswith("http://web.archive.org/"):
+                    log.info("wayback replay follow HTTP redirect %s -> %s", status, loc[:120])
+                    target = loc
+                    final_url = loc
+                    continue
+                last_err = f"http_{status}_bad_redirect"
+                log.info("wayback replay HTTP %s bad redirect %s", status, (loc or "")[:160])
+                continue
+            if proc.returncode != 0 and not body:
+                last_err = (proc.stderr or b"").decode("utf-8", "replace")[:300] or f"curl_rc_{proc.returncode}"
+                log.info("wayback replay curl fail %s: %s", url, last_err)
+                continue
+            if status in (403, 429, 503, 502, 504) and attempt < 5:
+                log.info("wayback replay HTTP %s %s attempt=%s", status, url, attempt)
+                continue
+            break
+        except Exception as exc:
+            last_err = str(exc)
+            log.info("wayback replay fail %s: %s", url, exc)
+            continue
+    else:
+        # fallback: requests without following redirects to https
+        try:
+            r = session().get(target, timeout=(20, 90), allow_redirects=False)
+            status = r.status_code
+            body = r.content or b""
+            ctype = r.headers.get("content-type") or ""
+            final_url = r.url or target
+            if status in (301, 302, 303, 307, 308):
+                loc = r.headers.get("Location") or ""
+                if loc.startswith("https://web.archive.org/"):
+                    loc = "http://" + loc[len("https://"):]
+                if loc.startswith("http://web.archive.org/"):
+                    r2 = session().get(loc, timeout=(20, 90), allow_redirects=False)
+                    status = r2.status_code
+                    body = r2.content or b""
+                    ctype = r2.headers.get("content-type") or ""
+                    final_url = r2.url or loc
+        except requests.RequestException as exc:
+            return {"status": "error", "error": last_err or str(exc), "url": url}
+
+    if not body and status != 200:
+        return {"status": "error", "error": last_err or f"http_{status}", "url": url}
+    cap_ts = timestamp or ""
+    m = re.search(r"/web/(\d{14})", final_url or "")
+    if m:
+        cap_ts = m.group(1)
+    text = ""
+    if "html" in ctype or "xml" in ctype or "text/" in ctype or not ctype:
+        try:
+            text = body.decode("utf-8", "replace")
+        except Exception:
+            text = ""
+    if status != 200 or not body:
+        return {
+            "status": "error",
+            "error": f"http_{status}",
+            "http_status": status,
+            "wayback_url": final_url,
+            "original_url": url,
+        }
+    if text and is_challenge(text, status):
+        return {
+            "status": "error",
+            "error": "challenge_or_shell",
+            "http_status": status,
+            "wayback_url": final_url,
+            "original_url": url,
+            "content": text[:2000],
+        }
+    return {
+        "status": "success",
+        "content": body,
+        "text": text,
+        "content_type": ctype,
+        "wayback_url": final_url,
+        "capture_timestamp": cap_ts,
+        "original_url": url,
+        "http_status": status,
+        "method": "wayback_curl_http",
+    }
+
+
+# --- Common Crawl ---
+
+def _http_cc_index(url: str) -> str:
+    if url.startswith("https://index.commoncrawl.org"):
+        return "http://" + url[len("https://"):]
+    return url
+
+
+def cc_indexes(n: int = 6) -> list[str]:
+    global _cc_indexes
+    if _cc_indexes is None:
+        cols = []
+        last_exc = None
+        for coll in (CC_COLLINFO, CC_COLLINFO.replace("https://", "http://", 1)):
+            try:
+                r = session().get(coll, timeout=30)
+                if r.status_code == 200:
+                    cols = r.json() or []
+                    break
+            except Exception as exc:
+                last_exc = exc
+                log.warning("cc collinfo %s: %s", coll, exc)
+        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(_http_cc_index(cdx or f"http://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 [
+            "http://index.commoncrawl.org/CC-MAIN-2026-34-index",
+            "http://index.commoncrawl.org/CC-MAIN-2024-33-index",
+        ]
+        if last_exc and not ids:
+            log.warning("cc collinfo fallback indexes after %s", last_exc)
+    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:
+            alt = _http_cc_index(idx) if idx.startswith("https://") else idx.replace("http://", "https://", 1)
+            try:
+                r = session().get(alt, params=params, timeout=(12, 25))
+            except requests.RequestException as exc2:
+                log.info("cc cdx %s fail %s / %s", idx, exc, exc2)
+                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_cv.py

@@ -0,0 +1,723 @@
+#!/usr/bin/env python3
+"""Cabo Verde / Cape Verde (cv): official Boletim Oficial + law texts from *.cv / *.gov.cv.
+
+Official only (Portuguese primary):
+  - https://boe.incv.cv/  (Imprensa Nacional — BOE / Boletim Oficial; /api/v1)
+  - https://incv.cv/ / kiosk.incv.cv (redirects to boe.incv.cv)
+  - https://www.governo.cv/ / governo.cv
+  - https://www.parlamento.cv/ / parlamento.cv (Assembleia Nacional)
+  - https://justica.gov.cv/ / www.justica.gov.cv
+  - https://www.mf.gov.cv/ / mf.gov.cv (Finanças)
+  - https://www.gov.cv/ / gov.cv
+  - https://www.bcv.cv/ / https://www.ine.cv/
+  - https://www.tribunalconstitucional.cv/
+  - Wayback/CDX of the same official *.cv / *.gov.cv URLs
+
+Filter: prefer lei/decreto/constituição/código/Boletim; skip PDFs >12MB.
+Not AfricanLII / Droit-Afrique. No WAF bypass. Not legal advice.
+NOTE: Leave Lesotho / Eswatini / Burundi / Portugal alone.
+"""
+from __future__ import annotations
+
+import html as html_lib
+import json
+import logging
+import re
+import subprocess
+import sys
+import tempfile
+import time
+from datetime import date, timedelta
+from pathlib import Path
+from urllib.parse import quote, unquote, urlencode, urljoin, urlsplit, urlunsplit
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import existing_ids, html_to_text, http_get, log_failure, utcnow, write_summary
+from world_lib import (
+    cdx_urls,
+    env_int,
+    fetch_official,
+    live_get,
+    pdf_to_text,
+    save_instrument,
+    setup_log,
+    slug_id,
+)
+
+CC, COUNTRY, LANG = "cv", "Cabo Verde", "pt"
+SOURCE_TYPE = "caboverde_official_boletim_oficial_laws"
+LICENSE = (
+    "República de Cabo Verde — Imprensa Nacional / Boletim Oficial (boe.incv.cv / incv.cv) / "
+    "Portal do Governo (governo.cv) / Assembleia Nacional (parlamento.cv) / "
+    "Justiça (justica.gov.cv) / Finanças (mf.gov.cv) / gov.cv / BCV / INE / "
+    "Tribunal Constitucional and other *.cv / *.gov.cv gazette hosts. Authentic Boletim "
+    "Oficial / official text prevails. Not legal advice. Not Portugal (pt) / Angola (ao) / "
+    "São Tomé (st)."
+)
+UA = (
+    "legal-corpora-collector/1.0 (research; source=https://boe.incv.cv/; "
+    "CaboVerde=cv not pt/ao/st)"
+)
+ART = re.compile(
+    r"(?im)^\s*((?:Artigo|Art\.?|Secção|Secao|Capítulo|Capitulo|Cap\.?|"
+    r"Título|Titulo|Parte|Disposição|Disposicao)\s*[IVXLC0-9º°a-zA-Z]*)\b"
+)
+log = logging.getLogger("cv")
+
+MAX_PDF_BYTES = 12 * 1024 * 1024
+API = "https://boe.incv.cv/api/v1"
+API_HEADERS = {
+    "User-Agent": UA,
+    "Accept": "application/json",
+    "Ankira-App-Version": "1.0.0",
+}
+
+ALLOWED = (
+    "boe.incv.cv",
+    "incv.cv",
+    "www.incv.cv",
+    "kiosk.incv.cv",
+    "governo.cv",
+    "www.governo.cv",
+    "parlamento.cv",
+    "www.parlamento.cv",
+    "assembleianacional.cv",
+    "www.assembleianacional.cv",
+    "presidencia.cv",
+    "www.presidencia.cv",
+    "gov.cv",
+    "www.gov.cv",
+    "justica.gov.cv",
+    "www.justica.gov.cv",
+    "mf.gov.cv",
+    "www.mf.gov.cv",
+    "bcv.cv",
+    "www.bcv.cv",
+    "ine.cv",
+    "www.ine.cv",
+    "tribunalconstitucional.cv",
+    "www.tribunalconstitucional.cv",
+    "stj.cv",
+    "www.stj.cv",
+    "pgr.cv",
+    "www.pgr.cv",
+    "anac.cv",
+    "www.anac.cv",
+    "are.cv",
+    "www.are.cv",
+)
+
+KEEP_RE = re.compile(
+    r"(lei|leis|decreto|diploma|resolu[cç][aã]o|proclama|"
+    r"constitui[cç][aã]o|regulamento|portaria|despacho|"
+    r"boletim|oficial|gazette|jornal|"
+    r"legislacao|legisla[cç][aã]o|normativo|estatuto|codigo|c[oó]digo|"
+    r"amendment|altera[cç][aã]o|lei[_/\-]|decreto[_/\-]|"
+    r"wp-content/uploads|/uploads/|/files/|/documents?/|/ficheiros?/|"
+    r"cabo.?verde|cape.?verde|/Bulletins/Download/)",
+    re.I,
+)
+DROP_RE = re.compile(
+    r"(africanlii|droit-afrique|gazettes\.africa|law\.africa|"
+    r"discurso|allocution|communique|comunicado|nota.?de.?prensa|photo|banner|logo|"
+    r"biograf|organigrama|presentacion|newsletter|"
+    r"facebook|twitter|linkedin|album|actualites|licitacao|"
+    r"favicon|apple-touch|webmanifest|/css/|\.css\b|"
+    r"portugal|\.pt/|dre\.pt|diariodarepublica|"
+    r"angola|\.ao/|sao.?tome|\.st/|lesotho|eswatini|burundi)",
+    re.I,
+)
+TEXT_KEEP_RE = re.compile(
+    r"\b(lei|decreto|diploma|constitui[cç][aã]o|boletim\s+oficial|"
+    r"c[oó]digo|rep[uú]blica\s+de\s+cabo\s+verde|"
+    r"assembleia\s+nacional|presidente\s+da\s+rep[uú]blica|promulga|"
+    r"artigo|cabo\s+verde|resolu[cç][aã]o|regulamento|ac[oó]rd[aã]o)\b",
+    re.I,
+)
+
+ACT_QUERIES = [
+    "constituição",
+    "código civil",
+    "código penal",
+    "código comercial",
+    "código do trabalho",
+    "decreto-lei",
+    "decreto legislativo",
+    "Lei n.º",
+    "Lei Orgânica",
+    "Assembleia Nacional",
+    "regulamento",
+    "estatuto",
+    "portaria",
+    "resolução",
+    "Banco de Cabo Verde",
+    "Tribunal Constitucional",
+    "Código da Propriedade Industrial",
+    "regime jurídico",
+]
+
+HOMES = [
+    "https://boe.incv.cv/",
+    "https://incv.cv/",
+    "https://incv.cv/boletim-oficial/",
+    "https://www.governo.cv/",
+    "https://www.governo.cv/documentos/",
+    "https://www.parlamento.cv/",
+    "https://www.parlamento.cv/legislacao.php",
+    "https://justica.gov.cv/",
+    "https://justica.gov.cv/legisla%C3%A7%C3%B5es",
+    "https://www.mf.gov.cv/",
+    "https://www.gov.cv/",
+    "https://www.gov.cv/legislacao",
+    "https://www.gov.cv/lei-justica",
+    "https://www.bcv.cv/",
+    "https://www.bcv.cv/pt/O%20Banco/Constituicao%20da%20Republica/Paginas/ConstituicaodaRepublica.aspx",
+    "https://www.bcv.cv/pt/O%20Banco/Lei%20Organica/Paginas/LeiOrganica.aspx",
+    "https://www.ine.cv/",
+    "https://www.tribunalconstitucional.cv/",
+]
+
+CDX_PREFIXES = (
+    "boe.incv.cv/",
+    "incv.cv/",
+    "www.incv.cv/",
+    "www.governo.cv/",
+    "governo.cv/",
+    "www.parlamento.cv/",
+    "parlamento.cv/",
+    "justica.gov.cv/",
+    "www.justica.gov.cv/",
+    "www.mf.gov.cv/",
+    "mf.gov.cv/",
+    "www.gov.cv/",
+    "gov.cv/",
+    "www.bcv.cv/",
+    "www.ine.cv/",
+    "www.tribunalconstitucional.cv/",
+)
+
+SEED_PDFS = [
+    # filled dynamically; keep a couple known BO downloads as seeds
+    "https://boe.incv.cv/Bulletins/Download/34017",
+    "https://boe.incv.cv/Bulletins/Download/23930",
+]
+
+
+def _host_ok(url: str) -> bool:
+    host = (urlsplit(url).hostname or "").lower()
+    if any(
+        x in host
+        for x in (
+            "africanlii",
+            "droit-afrique",
+            "gazettes.africa",
+            "law.africa",
+        )
+    ):
+        return False
+    if host.endswith((".pt", ".ao", ".st", ".ls", ".sz", ".bi", ".gq", ".gw")):
+        return False
+    if any(x in host for x in ("portugal", "angola", "saotome", "lesotho", "eswatini", "burundi")):
+        return False
+    if host.endswith(".gov.cv") or host in ("gov.cv", "www.gov.cv"):
+        return True
+    if host.endswith(".cv"):
+        return any(host == s or host.endswith("." + s) for s in ALLOWED) or host in ALLOWED
+    return any(host == s or host.endswith("." + s) for s in ALLOWED)
+
+
+def _norm_url(url: str) -> str:
+    url = html_lib.unescape((url or "").split("#")[0].strip())
+    if not url:
+        return ""
+    url = url.replace(":80/", "/").replace(":80?", "?")
+    if url.startswith("http://"):
+        url = "https://" + url[len("http://") :]
+    try:
+        p = urlsplit(url)
+        host = (p.hostname or "").lower()
+        parts = []
+        for seg in p.path.split("/"):
+            if not seg:
+                parts.append(seg)
+                continue
+            parts.append(seg if "%" in seg else quote(seg, safe="._-()[]',"))
+        url = urlunsplit((p.scheme or "https", host, "/".join(parts), "", ""))
+    except Exception:
+        url = url.replace(" ", "%20")
+    return url
+
+
+def _ident_from_url(url: str, title: str | None = None) -> str:
+    path = unquote(urlsplit(url).path)
+    if title:
+        t = re.sub(r"\W+", "-", title).strip("-").lower()[:100]
+        if t and len(t) > 8:
+            return t
+    name = Path(path).name or path
+    stem = Path(name).stem
+    return re.sub(r"\W+", "-", stem).strip("-").lower()[:160] or re.sub(r"\W+", "-", url)[-80:]
+
+
+def _is_bo_pdf(url: str) -> bool:
+    path = unquote(urlsplit(url).path).lower()
+    return "/bulletins/download/" in path or bool(
+        re.search(r"(?i)(boletim.?oficial|bo[_/\-]|serie)", path)
+    )
+
+
+def _keep_pdf(url: str, title: str | None = None) -> bool:
+    if not _host_ok(url):
+        return False
+    blob = unquote(urlsplit(url).path) + " " + url + " " + (title or "")
+    if DROP_RE.search(blob):
+        return False
+    path = unquote(urlsplit(url).path).lower()
+    if not path.endswith(".pdf") and "/bulletins/download/" not in path:
+        return False
+    if any(x in path for x in ("/css/", "favicon", "apple-touch", ".css", "webmanifest", "/js/")):
+        return False
+    if _is_bo_pdf(url):
+        return True
+    return bool(KEEP_RE.search(blob))
+
+
+def _api_get(path: str, params: dict | None = None) -> dict | None:
+    qs = ("?" + urlencode(params, doseq=True)) if params else ""
+    url = f"{API}/{path.lstrip('/')}{qs}"
+    try:
+        r = http_get(url, ua=UA, timeout=(15, 60), retries=2, sleep=0.2, headers=API_HEADERS)
+        if getattr(r, "status_code", 0) != 200:
+            log.info("api status=%s %s", getattr(r, "status_code", None), url[:120])
+            return None
+        raw = (r.text or "").strip()
+        if not raw.startswith("{") and not raw.startswith("["):
+            return None
+        return json.loads(raw)
+    except Exception as exc:
+        log.info("api %s %s", path, exc)
+        return None
+
+
+def ocr_pdf(raw: bytes) -> str:
+    max_pages = env_int("MAX_OCR_PAGES", 12)
+    dpi = env_int("OCR_DPI", 140)
+    try:
+        with tempfile.TemporaryDirectory() as td:
+            pdf = Path(td) / "doc.pdf"
+            pdf.write_bytes(raw)
+            proc = subprocess.run(
+                [
+                    "pdftoppm", "-png", "-r", str(dpi),
+                    "-f", "1", "-l", str(max_pages),
+                    str(pdf), str(Path(td) / "p"),
+                ],
+                check=False, capture_output=True, timeout=240,
+            )
+            if proc.returncode != 0:
+                return ""
+            chunks = []
+            for img in sorted(Path(td).glob("p*.png")):
+                tproc = subprocess.run(
+                    ["tesseract", str(img), "stdout", "-l", "por+fra+spa", "--psm", "6"],
+                    check=False, capture_output=True, timeout=120,
+                )
+                if tproc.returncode == 0 and tproc.stdout:
+                    chunks.append(tproc.stdout.decode("utf-8", "replace").strip())
+            return "\n\n".join(c for c in chunks if c).strip()
+    except Exception as exc:
+        log.warning("ocr_pdf: %s", exc)
+        return ""
+
+
+def fetch_cv(url: str, wayback_ts: str | None = None) -> dict:
+    got = fetch_official(url, ua=UA, verify=False, min_text=120, wayback=True, wayback_ts=wayback_ts)
+    if got.get("status") == "success" and len(got.get("text") or "") >= 120:
+        return got
+    body = got.get("content") or b""
+    if not (isinstance(body, bytes) and body[:4] == b"%PDF"):
+        try:
+            r = live_get(url, ua=UA, verify=False, timeout=(20, 90), retries=2)
+            if getattr(r, "status_code", 0) == 200 and (r.content or b"")[:4] == b"%PDF":
+                body = r.content
+                got["method"] = "live_pdf"
+        except Exception as exc:
+            got["error"] = (got.get("error") or "") + f";live_pdf:{exc}"
+            return got
+    if not (isinstance(body, bytes) and body[:4] == b"%PDF"):
+        return got
+    if len(body) > MAX_PDF_BYTES:
+        got["error"] = f"pdf_too_large:{len(body)}"
+        return got
+    text = pdf_to_text(body)
+    if len(text) >= 120:
+        got.update(status="success", text=text, content=body, method=got.get("method") or "http_pdf")
+        return got
+    max_ocr_bytes = env_int("MAX_OCR_BYTES", 8 * 1024 * 1024)
+    if len(body) > max_ocr_bytes:
+        got["error"] = (got.get("error") or "") + f";skip_ocr_large:{len(body)}"
+        return got
+    log.info("OCR por %s bytes=%s", _ident_from_url(url)[:40], len(body))
+    ocr = ocr_pdf(body)
+    if len(ocr) >= 120:
+        got.update(status="success", text=ocr, content=body, method="ocr_por")
+        return got
+    got["error"] = (got.get("error") or "") + ";ocr_short"
+    return got
+
+
+def _add(items, seen, ident, url, ts=None, priority=50, size_hint=None, title=None, kind="pdf", text=None, meta=None):
+    url = _norm_url(url) if url else ""
+    if kind == "pdf":
+        if not url or not _keep_pdf(url, title=title):
+            return
+        key = url.lower().split("?")[0]
+    else:
+        # act text from official API
+        if not text or len(text) < 120:
+            return
+        key = f"act:{ident}"
+    key2 = key.replace("://www.", "://")
+    if key in seen or key2 in seen:
+        return
+    if size_hint and size_hint > MAX_PDF_BYTES:
+        return
+    seen.add(key)
+    seen.add(key2)
+    ident = re.sub(r"\W+", "-", (ident or _ident_from_url(url, title)).strip("-")).lower()[:160]
+    items.append((priority, ident, url, ts, size_hint, title, kind, text, meta or {}))
+
+
+def _discover_acts(items, seen):
+    """Primary: official BOE ActFilter JSON with embedded HTML law text."""
+    for q in ACT_QUERIES:
+        data = _api_get("Filter/ActFilter", {"query": q})
+        if not data or not data.get("success"):
+            continue
+        n = 0
+        for act in data.get("content") or []:
+            aid = act.get("id")
+            if not aid:
+                continue
+            html = act.get("content") or ""
+            text = html_to_text(html)
+            summary = (act.get("summary") or "").strip()
+            legal = (act.get("legalNorm") or "").strip()
+            if len(text) < 200:
+                continue
+            if not TEXT_KEEP_RE.search(text[:8000]) and not TEXT_KEEP_RE.search(summary + " " + legal):
+                continue
+            # Prefer substantive instruments
+            pri = 18
+            blob = (summary + " " + legal + " " + text[:2000]).lower()
+            if re.search(r"constitui", blob):
+                pri = 4
+            elif re.search(r"c[oó]digo", blob):
+                pri = 6
+            elif re.search(r"\blei\b|decreto.?lei|decreto.?legislativo", blob):
+                pri = 8
+            elif re.search(r"regulamento|estatuto|portaria", blob):
+                pri = 12
+            title = summary or legal or f"Acto BOE {aid}"
+            title = re.sub(r"\s+", " ", title).strip()[:240]
+            source_url = f"https://boe.incv.cv/Bulletins/View/{aid}"
+            ident = f"boe-act-{aid}-{_ident_from_url(source_url, title)[:80]}"
+            _add(
+                items, seen, ident, source_url, ts=None, priority=pri,
+                title=title, kind="act", text=text,
+                meta={
+                    "act_id": aid,
+                    "is_full_text": act.get("isFullText"),
+                    "query": q,
+                    "legal_norm": legal[:500] if legal else None,
+                },
+            )
+            n += 1
+        log.info("actfilter q=%r hits=%s kept~%s overmax=%s", q, len(data.get("content") or []), n, data.get("overmax"))
+
+
+def _discover_bo_pdfs(items, seen):
+    """Enumerate recent Boletim Oficial PDF downloads via Home API calendar."""
+    months_back = env_int("BO_MONTHS", 18)
+    today = date.today()
+    # walk month starts
+    y, m = today.year, today.month
+    for _ in range(months_back):
+        start = date(y, m, 1)
+        if m == 12:
+            end = date(y, 12, 31)
+        else:
+            end = date(y, m + 1, 1) - timedelta(days=1)
+        days = _api_get("Home/DaysWithPublications", {"start": start.isoformat(), "end": end.isoformat()})
+        content = (days or {}).get("content") or {}
+        # Cap days per month to keep lean
+        day_keys = sorted(content.keys(), reverse=True)[: env_int("BO_DAYS_PER_MONTH", 8)]
+        for day_key in day_keys:
+            day_s = day_key[:10]
+            for serie in (1, 2):  # I Série priority, then II
+                bf = _api_get("Home/BulletinFilter", {"serie": serie, "date": day_s})
+                for b in (bf or {}).get("content") or []:
+                    bid = b.get("id")
+                    if not bid:
+                        continue
+                    number = b.get("number")
+                    series = ((b.get("series") or {}).get("description")) or f"Série {serie}"
+                    date_fmt = b.get("dateFormat") or day_s
+                    title = f"Boletim Oficial n.º {number}, {series} de {date_fmt}"
+                    if b.get("numberSup"):
+                        title = (
+                            f"Boletim Oficial n.º {number}, {b.get('numberSup')}.º Suplemento, "
+                            f"{series} de {date_fmt}"
+                        )
+                    url = f"https://boe.incv.cv/Bulletins/Download/{bid}"
+                    pri = 10 if serie == 1 else 16
+                    _add(
+                        items, seen, f"bo-{bid}-{number}-s{serie}", url,
+                        ts=None, priority=pri, title=title, kind="pdf",
+                        meta={"bulletin_id": bid, "serie": serie, "number": number},
+                    )
+        # previous month
+        m -= 1
+        if m == 0:
+            m = 12
+            y -= 1
+    log.info("bo pdf candidates so far=%s", sum(1 for it in items if it[6] == "pdf"))
+
+
+def discover():
+    items = []
+    seen = set()
+
+    for seed in SEED_PDFS:
+        _add(items, seen, _ident_from_url(seed), seed, ts=None, priority=9, title="Boletim Oficial seed")
+
+    _discover_acts(items, seen)
+    _discover_bo_pdfs(items, seen)
+
+    for home in HOMES:
+        try:
+            r = live_get(home, ua=UA, verify=False, timeout=(12, 40), retries=1)
+            if getattr(r, "status_code", 0) != 200:
+                log.info("home status=%s %s", getattr(r, "status_code", None), home)
+                continue
+            text = r.text or ""
+            if re.search(r"(?i)(celtabet|gambling|casino|bet365)", text[:2000]):
+                log.info("home compromised/skip %s", home)
+                continue
+            n = 0
+            for href in re.findall(r"""href=["']([^"']+)["']""", text, re.I):
+                full = urljoin(home, html_lib.unescape(href))
+                if ".pdf" in full.lower() or "/Bulletins/Download/" in full:
+                    pri = 20
+                    low = unquote(full).lower()
+                    if re.search(r"(?i)(constitu)", low):
+                        pri = 5
+                    elif re.search(r"(?i)(lei|decreto|codigo|regulamento)", low):
+                        pri = 12
+                    elif _is_bo_pdf(full):
+                        pri = 14
+                    _add(items, seen, _ident_from_url(full), full, ts=None, priority=pri)
+                    n += 1
+            for href in re.findall(r"(https?://[^\s\"'<>]+\.pdf)", text, re.I):
+                _add(items, seen, _ident_from_url(href), href, ts=None, priority=22)
+                n += 1
+            sub = []
+            for href in re.findall(r"""href=["']([^"']+)["']""", text, re.I):
+                full = urljoin(home, html_lib.unescape(href))
+                if not _host_ok(full):
+                    continue
+                low = unquote(full).lower()
+                if any(
+                    k in low
+                    for k in (
+                        "lei", "leis", "decreto", "constitu", "boletim", "legisl",
+                        "documento", "download", "upload", "files", "regulamento",
+                        "norma", "ficheiros", "codigo",
+                    )
+                ):
+                    if full not in sub and not low.endswith(".pdf"):
+                        sub.append(full)
+            for sub_url in sub[:6]:
+                try:
+                    r2 = live_get(sub_url, ua=UA, verify=False, timeout=(10, 30), retries=1)
+                    if getattr(r2, "status_code", 0) != 200:
+                        continue
+                    t2 = r2.text or ""
+                    for href in re.findall(r"""href=["']([^"']+)["']""", t2, re.I):
+                        full = urljoin(sub_url, html_lib.unescape(href))
+                        if ".pdf" in full.lower() or "/Bulletins/Download/" in full:
+                            pri = 18
+                            low = unquote(full).lower()
+                            if re.search(r"(?i)(constitu)", low):
+                                pri = 5
+                            elif re.search(r"(?i)(lei|decreto|codigo)", low):
+                                pri = 12
+                            _add(items, seen, _ident_from_url(full), full, ts=None, priority=pri)
+                            n += 1
+                except Exception as exc:
+                    log.info("sub %s %s", sub_url[:80], exc)
+            log.info("home %s links=%s", home, n)
+        except Exception as exc:
+            log.info("home %s %s", home, exc)
+
+    for prefix in CDX_PREFIXES:
+        try:
+            hits = cdx_urls(
+                prefix,
+                limit=env_int("CDX_LIMIT", 120),
+                match_type="prefix",
+                extra_filters=["statuscode:200", "mimetype:application/pdf"],
+            ) or []
+        except Exception as exc:
+            log.info("cdx %s %s", prefix, exc)
+            hits = []
+        if len(hits) < 3:
+            try:
+                hits2 = cdx_urls(
+                    prefix,
+                    limit=env_int("CDX_LIMIT", 120),
+                    match_type="prefix",
+                    extra_filters=["statuscode:200"],
+                ) or []
+                for h in hits2:
+                    orig = (h.get("original") or "").lower()
+                    if ".pdf" in orig or "/bulletins/download/" in orig:
+                        hits.append(h)
+            except Exception as exc:
+                log.info("cdx2 %s %s", prefix, exc)
+        for h in hits:
+            orig = h.get("original") or ""
+            ts = (h.get("timestamp") or "")[:14] or None
+            try:
+                length = int(h.get("length") or 0)
+            except Exception:
+                length = 0
+            if length and length > MAX_PDF_BYTES:
+                continue
+            if not _keep_pdf(orig):
+                continue
+            pri = 30
+            low = unquote(orig).lower()
+            if re.search(r"(?i)(constitu)", low):
+                pri = 5
+            elif _is_bo_pdf(orig):
+                pri = 15
+            elif re.search(r"(?i)(lei|codigo|regulamento)", low):
+                pri = 14
+            elif re.search(r"(?i)(decreto|diploma|resolu|portaria|despacho)", low):
+                pri = 22
+            _add(items, seen, _ident_from_url(orig), orig, ts=ts, priority=pri, size_hint=length or None)
+
+    items.sort(key=lambda x: (x[0], x[1]))
+    out = [
+        (ident, url, ts, size, title, kind, text, meta)
+        for _, ident, url, ts, size, title, kind, text, meta in items
+    ]
+    log.info("catalog %s (acts=%s pdfs=%s)", len(out), sum(1 for x in out if x[5] == "act"), sum(1 for x in out if x[5] == "pdf"))
+    return out
+
+
+def main():
+    setup_log(CC)
+    t0 = utcnow()
+    max_new = env_int("MAX_NEW", 80)
+    max_seconds = env_int("MAX_SECONDS", 2400)
+    t_start = time.time()
+    done = existing_ids(CC)
+    already = len(done)
+    target_total = env_int("TARGET_TOTAL", 0)
+    ok = skip = fail = 0
+    for ident, url, ts, size_hint, title, kind, preset_text, meta in discover():
+        if max_new and ok >= max_new:
+            break
+        if target_total and (already + ok) >= target_total:
+            break
+        if time.time() - t_start > max_seconds:
+            break
+        if size_hint and size_hint > MAX_PDF_BYTES:
+            skip += 1
+            continue
+        rid = slug_id(CC, ident)
+        if rid in done:
+            skip += 1
+            continue
+        if url and not _host_ok(url):
+            fail += 1
+            log_failure(CC, {"identifier": ident, "source_url": url, "reason": "host_not_cv"})
+            continue
+
+        if kind == "act" and preset_text:
+            text = preset_text
+            method = "boe_actfilter_html"
+            got = {"status": "success", "method": method, "text": text}
+        else:
+            got = fetch_cv(url, wayback_ts=ts)
+            text = got.get("text") or ""
+            method = got.get("method")
+
+        if got.get("status") != "success":
+            fail += 1
+            log_failure(CC, {"identifier": ident, "source_url": url, "reason": got.get("error"), "wayback_ts": ts})
+            continue
+        if len(text) > 2_500_000:
+            log.info("skip huge text chars=%s %s", len(text), ident[:50])
+            fail += 1
+            log_failure(CC, {"identifier": ident, "source_url": url, "reason": "text_too_large", "chars": len(text)})
+            continue
+        if not TEXT_KEEP_RE.search(text[:8000]) and not _is_bo_pdf(url or ""):
+            if not re.search(r"(?i)(lei|decreto|constitu|codigo|regulamento|diploma|boletim|acord)", ident):
+                fail += 1
+                log_failure(CC, {"identifier": ident, "source_url": url, "reason": "text_not_legal"})
+                continue
+        use_title = title
+        if not use_title:
+            for line in text.splitlines():
+                if len(line.strip()) > 18:
+                    use_title = line.strip()[:240]
+                    break
+        if save_instrument(
+            cc=CC, country=COUNTRY, language=LANG, ident=ident,
+            title=use_title or ident, text=text, source_url=url or f"https://boe.incv.cv/",
+            source_type=SOURCE_TYPE, license_text=LICENSE, collector="collect_cv.py",
+            article_re=ART,
+            extra_meta={
+                "fetch_method": method,
+                "wayback_ts": ts,
+                "size_hint": size_hint,
+                **(meta or {}),
+            },
+        ):
+            ok += 1
+            done.add(rid)
+            log.info("ok %s method=%s chars=%s ts=%s", ident[:60], method, len(text), ts)
+        else:
+            fail += 1
+    write_summary(
+        CC, country=COUNTRY,
+        source="Cabo Verde Boletim Oficial / Laws (boe.incv.cv / governo.cv / parlamento.cv / justica.gov.cv / mf.gov.cv)",
+        source_urls=[
+            "https://boe.incv.cv/",
+            "https://incv.cv/",
+            "https://www.governo.cv/",
+            "https://www.parlamento.cv/",
+            "https://justica.gov.cv/",
+            "https://www.mf.gov.cv/",
+            "https://www.gov.cv/",
+            "https://www.bcv.cv/",
+            "https://www.tribunalconstitucional.cv/",
+        ],
+        license_text=LICENSE, discovered=ok + skip + fail, fetched=ok, skipped=skip, failed=fail,
+        coverage="catalog-backed incomplete (BOE ActFilter HTML + BO PDF downloads + live/CDX *.cv / *.gov.cv)",
+        notes=(
+            "Official *.cv / *.gov.cv lei/decreto/constituição / Boletim Oficial only "
+            "(Cabo Verde). Primary: boe.incv.cv /api/v1 ActFilter + Bulletin Download. "
+            "OCR por+fra+spa for scans. Not AfricanLII. No WAF bypass. Not legal advice. "
+            "cv=Cabo Verde (not Portugal/pt, not Angola/ao, not São Tomé/st)."
+        ),
+        last_run=t0,
+    )
+    log.info("done ok=%s skip=%s fail=%s total_instruments=%s", ok, skip, fail, len(done))
+
+
+if __name__ == "__main__":
+    main()

scrapers/common.py

@@ -0,0 +1,531 @@
+#!/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\.|str\.|para(?:graph)?\.?|szakasz)\s+"
+    r"[\dIVXLCDM]+[a-zA-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
+
+
+def pdf_bytes_to_text(raw: bytes, timeout: int = 180) -> str:
+    """Extract text from PDF bytes via pdftotext. Empty on failure."""
+    import subprocess
+    if not raw:
+        return ""
+    if raw[:4] != b"%PDF":
+        idx = raw.find(b"%PDF", 0, 8192)
+        if idx < 0:
+            return ""
+        raw = raw[idx:]
+    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=timeout,
+            )
+        if proc.returncode == 0 and proc.stdout:
+            return proc.stdout.decode("utf-8", "replace").strip()
+    except Exception:
+        return ""
+    return ""

scrapers/pdf_extract_lib.py

@@ -0,0 +1,325 @@
+#!/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[:8000]
+    # Broken ToUnicode / CID font dumps from Arabic/Persian PDFs
+    if sample.count("(cid:") >= 8:
+        return True
+    arabic = sum(1 for ch in sample if "\u0600" <= ch <= "\u06FF")
+    ctrl = sum(1 for ch in sample if ord(ch) < 32 and ch not in "\n\r\t\x0c")
+    n = max(1, len(sample))
+    # Encoding-corrupt Arabic/Persian PDFs: many controls / almost no Arabic script
+    if len(sample) > 500 and (ctrl / n) > 0.04 and (arabic / n) < 0.05:
+        return True
+    if len(sample) > 800 and arabic < 80 and sample.count("@") > 30:
+        return True
+    letters = sum(ch.isalpha() for ch in sample)
+    spaces = sample.count(" ")
+    if letters < 80 and arabic < 40:
+        return True
+    # Mojibake Latin stand-in for Arabic (common in old MoJ PDFs)
+    ascii_letters = sum(ch.isalpha() and ord(ch) < 128 for ch in sample)
+    if len(sample) > 500 and arabic < 20 and ascii_letters > 400:
+        return True
+    if spaces > letters * 1.8 and _GARBAGE_SPACING.search(sample):
+        return True
+    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\u200c\u200d\ufeff]", "", text or "")
+
+
+_EASTERN_DIGITS = str.maketrans(
+    "\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669"
+    "\u06f0\u06f1\u06f2\u06f3\u06f4\u06f5\u06f6\u06f7\u06f8\u06f9",
+    "01234567890123456789",
+)
+
+
+def normalize_rtl_text(text: str) -> str:
+    """Strip bidi marks and map Arabic/Persian digits to ASCII for heading regexes."""
+    t = normalize_bidi(text or "")
+    t = re.sub(r"[\u00ad\u200b]", "", t)
+    return t.translate(_EASTERN_DIGITS)
+
+
+
+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"),
+        ("article_inline", re.compile(r"(?im)((?:Article|Art\.)\s+\d+)(?![\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"),
+    ],
+    "iq": [
+        ("mada", re.compile(r"(?m)^\s*((?:المادة|مادة)\s*[-–—:]*\s*\d+)(?!\d)"), "article"),
+        ("mada_ocr", re.compile(r"(?m)^\s*((?:المادة|مادة)\s*[-–—:\s]*\d+)(?!\d)"), "article"),
+        ("fasl", re.compile(r"(?m)^\s*((?:الفصل|الباب)\s+\S+)"), "section"),
+        ("article_en", re.compile(r"(?im)^\s*((?:Article|Art\.?)\s+\d+)(?!\d)"), "article"),
+    ],
+    "ir": [
+        ("mada", re.compile(r"(?m)^\s*((?:ماده)\s*(?:واحده|\d+))(?!\d)"), "article"),
+        ("mada_prefixed", re.compile(
+            r"(?m)^\s*(?:\d+[\-–—ـ.)\]]*\s*)?((?:ماده)\s*(?:واحده|\d+))(?!\d)"
+        ), "article"),
+        ("fasl_bab", re.compile(
+            r"(?m)^\s*((?:فصل|باب)\s*(?:اول|دوم|سوم|چهارم|پنجم|ششم|هفتم|هشتم|نهم|دهم|\d+))"
+        ), "section"),
+        ("article_en", re.compile(r"(?im)^\s*((?:Article|Art\.?)\s+\d+)(?!\d)"), "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]:
+    if cc in ("tn", "iq", "ir", "dz", "lb", "ma", "eg", "sa", "ae"):
+        text_n = normalize_rtl_text(text)
+    else:
+        text_n = 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,316 @@
+#!/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:
+    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 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 normalize_official_url(url: str) -> str:
+    """Fix CDX quirks: https://host:80/... breaks TLS (WRONG_VERSION_NUMBER)."""
+    if not url:
+        return url
+    url = url.replace("http://", "https://", 1) if "lawcommission.gov.np" in url and url.startswith("http://") else url
+    url = url.replace("https://www.lawcommission.gov.np:80/", "https://www.lawcommission.gov.np/")
+    url = url.replace("https://lawcommission.gov.np:80/", "https://lawcommission.gov.np/")
+    url = url.replace(":80/", "/") if url.startswith("https://") and ":80/" in url else url
+    url = url.replace(":80?", "?") if url.startswith("https://") and ":80?" in url else url
+    return url
+
+def live_get(url: str, *, ua: str = DEFAULT_UA, timeout: tuple = (20, 90), verify: bool = True, retries: int = 3):
+    url = normalize_official_url(url)
+    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."""
+    url = normalize_official_url(url)
+    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:
+            if body[:4] == b"%PDF" or "pdf" in ctype.lower():
+                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":
+                out["error"] = "pdf_extract_failed"
+            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 ""
+                if (isinstance(raw_b, bytes) and raw_b[:4] == b"%PDF") or (raw_t[:4] == "%PDF"):
+                    pdf_bytes = raw_b if isinstance(raw_b, bytes) and raw_b[:4] == b"%PDF" else raw_t.encode("latin-1", "replace")
+                    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("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[:200]:
+                    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 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