Refresh Kuwait official e.gov.kw Forms via Wayback (93 laws; was thin ~54)

MANIFEST.md

@@ -1,21 +1,26 @@
 # ipfs_kuwait_laws manifest
 
-generated_utc: 2026-09-04T18:06:18Z
+generated_utc: 2026-09-09T14:14:48Z
 cc: kw
-slug: kuwait
-laws_rows: 69
+laws_rows: 93
 articles_rows: 0
-laws_bytes: 4474479
-articles_bytes: 1607
-laws_sha256: 67e8883263c212a949874d85fc58ad3612ccf6682c77cdc68d1b8dbf52d5dda8
-articles_sha256: 22806421f93c50153de0a7c5a04022ed12bee1b183d3b90c19b4e9be46c75fd7
-laws_parquet: /workspace/legal-corpora-releases/kuwait/data/laws.parquet
-articles_parquet: /workspace/legal-corpora-releases/kuwait/data/articles.parquet
+laws_bytes: 1499937
+articles_bytes: 986
+laws_sha256: e769dc99505be9d81c51c34711a0581b898310b037176d936293273d8337ff11
+articles_sha256: cc851f16b1aa2815fb071b0f5c25300be24bc6c697df8b5dea3efe80f72ea276
+laws_parquet: /workspace/legal-corpora/hf-staging/ipfs_kuwait_laws/data/laws.parquet
+articles_parquet: /workspace/legal-corpora/hf-staging/ipfs_kuwait_laws/data/articles.parquet
 compression: zstd
 collector: scrapers/collect_kuwaitalyawm.py
-source: Kuwait Alyawm / e.gov.kw official PDFs
-coverage: kuwait alyawm / e.gov.kw snapshot
-snapshot_date: 2026-09-04
+license: Ministry of Information / official gazette terms; not legal advice
+retrieval: official
+live_instruments: 93
+archive_instruments: 0
+wayback_instruments: 0
+common_crawl_instruments: 0
+archive_is_instruments: 0
+constitution_present: true
+catalog_expected: None
+catalog_gap: 
+gaps: Gazette flip viewer is subscriber-only; full texts from official e.gov.kw PDFs and Wayback of official URLs.
 uploaded: false
-gaps:
-  Research snapshot of Kuwait official e.gov.kw / Kuwait Alyawm-linked PDFs. Incomplete; subscriber viewer texts limited. Official source prevails. Not legal advice.

README.md

@@ -1,7 +1,7 @@
 ---
-pretty_name: Laws of Kuwait
+pretty_name: Kuwait Official Gazette Laws (الكويت اليوم)
 license: other
-license_name: kuwait-official
+license_name: kuwait-gazette-terms
 language:
 - ar
 task_categories:
@@ -22,44 +22,42 @@ configs:
   data_files: data/articles.parquet
 ---
 
-# Laws of Kuwait
+# Kuwait Official Gazette Laws (الكويت اليوم)
 
-Research snapshot of official legislation collected from **Kuwait Alyawm / e.gov.kw official PDFs**.
+Research snapshot of official national legislation from **الكويت اليوم (Ministry of Information) + e.gov.kw official PDFs**.
 
-**Not legal advice.** Official gazettes / government portals prevail over this corpus.
+**Not legal advice.** The official gazette / authentic source prevails over this corpus.
 
 ## Snapshot
 
 | Field | Value |
 | --- | --- |
-| Snapshot date | 2026-09-04 |
-| Coverage | kuwait alyawm / e.gov.kw snapshot |
-| Source | Kuwait Alyawm / e.gov.kw official PDFs |
+| Snapshot date | 2026-09-09 |
+| Coverage | partial-official-fulltext |
+| Source | الكويت اليوم (Ministry of Information) + e.gov.kw official PDFs |
 | Collector | `scrapers/collect_kuwaitalyawm.py` |
-| Laws / instruments | 69 |
+| Laws / instruments | 93 |
 | Articles | 0 |
 | Language | ar |
 | Jurisdiction | Kuwait |
-| License | `kuwait-official` |
+| License | `kuwait-gazette-terms` |
 
 ## Contents
 
-- `data/laws.parquet` — one row per instrument (id, title, full text, ELI,
-  dates, status, identifiers, article count, source URL).
-- `data/articles.parquet` — one row per article/section (`law_id`, article
-  number, title, text, source URL).
+- `data/laws.parquet` — one row per instrument.
+- `data/articles.parquet` — article/section rows for the same snapshot.
 - `scrapers/collect_kuwaitalyawm.py` — research collector used to build this snapshot.
-- `scrapers/common.py` — shared collector helpers.
 
 ## License / reuse
 
-Official government / gazette texts; reuse per public-sector terms of the
-source portal. This packaging, metadata, and collector script are provided
-for research.
+Ministry of Information / official gazette terms; not legal advice.
 
-This dataset is **not** an official consolidation and is **not legal advice**.
-The official source prevails.
+This dataset is **not legal advice**. The official source prevails.
 
-## Notes
+## Source
 
-Research snapshot of Kuwait official e.gov.kw / Kuwait Alyawm-linked PDFs. Incomplete; subscriber viewer texts limited. Official source prevails. Not legal advice.
+- https://kuwaitalyawm.media.gov.kw/online/AdsCategory/9
+
+## Known gaps
+
+Gazette flip viewer is subscriber-only; full texts from official e.gov.kw PDFs and Wayback of official URLs.

data/articles.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:22806421f93c50153de0a7c5a04022ed12bee1b183d3b90c19b4e9be46c75fd7
-size 1607
+oid sha256:cc851f16b1aa2815fb071b0f5c25300be24bc6c697df8b5dea3efe80f72ea276
+size 986

data/laws.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:67e8883263c212a949874d85fc58ad3612ccf6682c77cdc68d1b8dbf52d5dda8
-size 4474479
+oid sha256:e769dc99505be9d81c51c34711a0581b898310b037176d936293273d8337ff11
+size 1499937

scrapers/archive_fallbacks.py

@@ -24,8 +24,10 @@ from requests.adapters import HTTPAdapter
 
 log = logging.getLogger("archive_fallbacks")
 
-WAYBACK_CDX = "https://web.archive.org/cdx/search/cdx"
-WAYBACK_WEB = "https://web.archive.org/web"
+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/"
@@ -207,7 +209,11 @@ def _wayback_cdx_page(
             items = [(k, psz if k == "limit" else v) for k, v in items]
             _sleep_wayback(1.5)
         try:
-            r = session().get(WAYBACK_CDX, params=items, timeout=(20, 90))
+            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)
@@ -283,54 +289,127 @@ def search_wayback_machine(
 
 
 def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
-    """Fetch a snapshot; id_ modifier skips Wayback chrome. No CDX search."""
+    """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:
-        wb = f"{WAYBACK_WEB}/{timestamp}id_/{url}"
+        path = f"/{timestamp}id_/{url}"
     else:
-        wb = f"{WAYBACK_WEB}/2id_/{url}"
-    r = None
+        path = f"/2id_/{url}"
+    target = WAYBACK_WEB_HTTP + path
     last_err = None
-    for attempt in range(1, 5):
-        _sleep_wayback(1.2 if attempt == 1 else min(20.0, 2.5 * attempt))
+    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:
-            r = session().get(wb, timeout=(20, 90), allow_redirects=True)
-        except requests.RequestException as exc:
+            # 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
-        if r.status_code in (403, 429, 503, 502, 504) and attempt < 4:
-            log.info("wayback replay HTTP %s %s attempt=%s", r.status_code, url, attempt)
-            continue
-        break
-    if r is None:
-        return {"status": "error", "error": last_err or "no_response", "url": url}
+    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})", r.url or "")
+    m = re.search(r"/web/(\d{14})", final_url or "")
     if m:
         cap_ts = m.group(1)
-    ctype = r.headers.get("content-type") or ""
-    body = r.content or b""
     text = ""
     if "html" in ctype or "xml" in ctype or "text/" in ctype or not ctype:
-        enc = r.encoding or "utf-8"
         try:
-            text = body.decode(enc, "replace")
-        except Exception:
             text = body.decode("utf-8", "replace")
-    if r.status_code != 200 or not body:
+        except Exception:
+            text = ""
+    if status != 200 or not body:
         return {
             "status": "error",
-            "error": f"http_{r.status_code}",
-            "http_status": r.status_code,
-            "wayback_url": r.url,
+            "error": f"http_{status}",
+            "http_status": status,
+            "wayback_url": final_url,
             "original_url": url,
         }
-    if text and is_challenge(text, r.status_code):
+    if text and is_challenge(text, status):
         return {
             "status": "error",
             "error": "challenge_or_shell",
-            "http_status": r.status_code,
-            "wayback_url": r.url,
+            "http_status": status,
+            "wayback_url": final_url,
             "original_url": url,
             "content": text[:2000],
         }
@@ -339,42 +418,50 @@ def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
         "content": body,
         "text": text,
         "content_type": ctype,
-        "wayback_url": r.url,
+        "wayback_url": final_url,
         "capture_timestamp": cap_ts,
         "original_url": url,
-        "http_status": r.status_code,
-        "method": "wayback",
+        "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:
-        try:
-            r = session().get(CC_COLLINFO, timeout=30)
-            cols = r.json() if r.status_code == 200 else []
-            ids = []
-            for c in cols:
-                cid = c.get("id") or ""
-                cdx = c.get("cdx-api") or c.get("cdx_api") or ""
-                if cid:
-                    ids.append(cdx or f"https://index.commoncrawl.org/{cid}-index")
-            # collinfo is newest-first. Do not drop crawls that 404 a
-            # specific URL (that means "no captures", not a dead index).
-            _cc_indexes = ids or [
-                "https://index.commoncrawl.org/CC-MAIN-2025-18-index",
-                "https://index.commoncrawl.org/CC-MAIN-2024-33-index",
-            ]
-        except Exception as exc:
-            log.warning("cc collinfo: %s", exc)
-            _cc_indexes = [
-                "https://index.commoncrawl.org/CC-MAIN-2026-34-index",
-                "https://index.commoncrawl.org/CC-MAIN-2026-30-index",
-                "https://index.commoncrawl.org/CC-MAIN-2026-25-index",
-                "https://index.commoncrawl.org/CC-MAIN-2024-33-index",
-            ]
+        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]
 
 
@@ -400,8 +487,12 @@ def search_common_crawl(url: str, *, limit: int = 80, indexes: Optional[list[str
         try:
             r = session().get(idx, params=params, timeout=(12, 25))
         except requests.RequestException as exc:
-            log.info("cc cdx %s fail %s", idx, exc)
-            continue
+            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)

scrapers/collect_kuwaitalyawm.py

@@ -51,6 +51,41 @@ EGOV_PDFS = [
     "https://www.e.gov.kw/sites/kgoArabic/Forms/DastoorKuwaity.pdf",
 ]
 
+# Administrative form stubs (نموذج) — not legislation; drop from harvest.
+FORM_RE = re.compile(
+    r"(?i)(%D9%86%D9%85%D8%A7%D8%B0%D8%AC|%D9%86%D9%85%D9%88%D8%B0%D8%AC|"
+    r"namothaj|namothage|namothg|estimara|talab|form[_-]?0|awqaf-form|"
+    r"student_support|authorizeda|bulletinlabour|annualextern|"
+    r"caitauthorized|/Forms/[^/]*form)"
+)
+
+LAWISH_RE = re.compile(
+    r"(?i)(dastoor|dastor|cma|qawan|qanun|law|tashree|tashrea|jamarek|"
+    r"monadham|khass|amateurradio|constitution|مرسوم|قانون|دستور)"
+)
+
+
+def is_form_stub(url: str) -> bool:
+    from urllib.parse import unquote
+    u = unquote(url or "")
+    if FORM_RE.search(url or "") or FORM_RE.search(u):
+        # keep if clearly a law compilation despite form-ish tokens
+        if LAWISH_RE.search(url or "") or LAWISH_RE.search(u):
+            return False
+        return True
+    # Arabic نموذج / نماذج in path
+    if "نموذج" in u or "نماذج" in u:
+        return True
+    return False
+
+
+def env_int(name: str, default: int) -> int:
+    import os
+    try:
+        return int(os.environ.get(name, str(default)) or default)
+    except Exception:
+        return default
+
 
 def setup():
     ensure_dirs(CC)
@@ -218,30 +253,49 @@ def write_law(ident, title, text, source_url, date, extra_meta, doc_type="statut
 def add_egov_pdfs() -> tuple[int, int]:
     ok = fail = 0
     urls = list(EGOV_PDFS)
+    cdx_lim = env_int("CDX_LIMIT", 400)
     extra = search_wayback_machine(
         "https://www.e.gov.kw/sites/kgoArabic/Forms/", match_type="prefix",
-        limit=80, extra_filters=["mimetype:application/pdf"],
+        limit=cdx_lim, extra_filters=["mimetype:application/pdf"],
     )
     extra += search_wayback_machine(
         "https://e.gov.kw/sites/kgoEnglish/Forms/", match_type="prefix",
-        limit=80, extra_filters=["mimetype:application/pdf"],
+        limit=cdx_lim, extra_filters=["mimetype:application/pdf"],
+    )
+    extra += search_wayback_machine(
+        "https://www.e.gov.kw/sites/kgoarabic/Forms/", match_type="prefix",
+        limit=cdx_lim, extra_filters=["mimetype:application/pdf"],
     )
     log.info("egov wayback pdf cdx=%s", len(extra))
     seen = set()
     jobs = []
     for u in urls:
         jobs.append({"original": u, "timestamp": None, "source": "live-or-wayback"})
+    skipped_forms = 0
     for rec in extra:
         orig = rec.get("original") or ""
         if not orig.lower().endswith(".pdf"):
             continue
+        if is_form_stub(orig):
+            skipped_forms += 1
+            continue
         if orig in seen:
             continue
         seen.add(orig)
         jobs.append({"original": orig, "timestamp": rec.get("timestamp"), "source": "wayback"})
+    log.info("egov jobs=%s skipped_forms=%s", len(jobs), skipped_forms)
+    jobs.sort(key=lambda j: (0 if LAWISH_RE.search(j["original"] or "") else 1, j["original"]))
+    max_new = env_int("MAX_NEW", 120)
+    got = 0
+    known = existing_ids(CC)
     for job in jobs:
+        if max_new and got >= max_new:
+            break
         orig = job["original"]
         ident = Path(orig.split("?")[0]).stem[:80] or "egov-pdf"
+        rid = slug_id(CC, ident)
+        if rid in known:
+            continue
         text = ""
         src = orig
         # live
@@ -272,10 +326,14 @@ def add_egov_pdfs() -> tuple[int, int]:
         }, doc_type=doc_type)
         if st == "ok":
             ok += 1
+            got += 1
+            known.add(rid)
             log.info("egov pdf ok %s chars=%s", ident, len(text))
         elif st == "fail":
             fail += 1
             log_failure(CC, {"identifier": ident, "source_url": orig, "status": "failed", "reason": "empty_pdf"})
+        elif st == "skip":
+            pass
     return ok, fail
 
 
@@ -298,7 +356,8 @@ def add_wayback_gazette_html() -> tuple[int, int]:
             if ln >= 8000:
                 keep.append(rec)
     seen = set()
-    for rec in keep[:80]:
+    max_wb = env_int("MAX_WAYBACK_HTML", 40)
+    for rec in keep[:max_wb]:
         orig = rec.get("original")
         if orig in seen:
             continue

scrapers/common.py

@@ -509,8 +509,13 @@ def iso_date(val: Optional[str]) -> Optional[str]:
 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 or raw[:4] != b"%PDF":
+    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)

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