Refresh Honduras official snapshot (200 laws / 4330 articles; tsc.gob.hn La Gaceta)

MANIFEST.md

@@ -1,9 +1,26 @@
-# MANIFEST
+# ipfs_honduras_laws manifest
 
-- generated_at: 2026-09-04T20:07:07Z
-- laws: 40
-- articles: 529
-- files:
-  - data/laws.parquet: 644133 bytes
-  - data/articles.parquet: 493804 bytes
-  - README.md: 1817 bytes
+generated_utc: 2026-09-08T23:32:55Z
+cc: hn
+laws_rows: 200
+articles_rows: 4330
+laws_bytes: 2271454
+articles_bytes: 2103036
+laws_sha256: b0361320825423b3c9e1669383a3ed8d45cf3a9b24a8ca8f15463bde04c9a4d9
+articles_sha256: 38060b6ec82b3512a02e47233b2ab47d13a3bdd15351b029dee860f0a6b4a6cd
+laws_parquet: /workspace/legal-corpora/hf-staging/ipfs_honduras_laws/data/laws.parquet
+articles_parquet: /workspace/legal-corpora/hf-staging/ipfs_honduras_laws/data/articles.parquet
+compression: zstd
+collector: scrapers/collect_hn.py
+license: Official Honduras La Gaceta texts mirrored by TSC; authentic La Gaceta prevails; not legal advice
+retrieval: live-and-wayback-of-official
+live_instruments: 200
+archive_instruments: 0
+wayback_instruments: 0
+common_crawl_instruments: 0
+archive_is_instruments: 0
+constitution_present: false
+catalog_expected: None
+catalog_gap: 
+gaps: Official PDFs from tsc.gob.hn/web/leyes only (live + Wayback). Gap-fill above thin Hub ~40. Not vLex.
+uploaded: false

README.md

@@ -1,7 +1,7 @@
 ---
-pretty_name: Laws of Honduras
+pretty_name: Honduras La Gaceta Laws (TSC / tsc.gob.hn)
 license: other
-license_name: hn-tsc-gaceta
+license_name: hn-la-gaceta
 language:
 - es
 task_categories:
@@ -10,9 +10,11 @@ tags:
 - legal
 - law
 - honduras
+- la-gaceta
+- tsc
 - official-texts
 size_categories:
-- n<1K
+- 1K<n<10K
 configs:
 - config_name: laws
   data_files: data/laws.parquet
@@ -21,44 +23,42 @@ configs:
   data_files: data/articles.parquet
 ---
 
-# Laws of Honduras
+# Honduras La Gaceta Laws (TSC / tsc.gob.hn)
 
-Research snapshot of official legislation collected from **TSC / La Gaceta tsc.gob.hn/web/leyes**.
+Research snapshot of official national legislation from **Tribunal Superior de Cuentas / La Gaceta (tsc.gob.hn)**.
 
-**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 |
+| Snapshot date | 2026-09-08 |
 | Coverage | catalog-backed incomplete |
-| Source | TSC / La Gaceta tsc.gob.hn/web/leyes |
+| Source | Tribunal Superior de Cuentas / La Gaceta (tsc.gob.hn) |
 | Collector | `scrapers/collect_hn.py` |
-| Laws / instruments | 40 |
-| Articles | 529 |
+| Laws / instruments | 200 |
+| Articles | 4,330 |
 | Language | es |
 | Jurisdiction | Honduras |
-| License | `hn-tsc-gaceta` |
+| License | `hn-la-gaceta` |
 
 ## Contents
 
-- `data/laws.parquet` — one row per instrument (id, title, full text, dates, status, identifiers, article count, source URL).
-- `data/articles.parquet` — one row per article/section (`law_id`, article number, title, text, source URL).
+- `data/laws.parquet` — one row per instrument.
+- `data/articles.parquet` — article/section rows for the same snapshot.
 - `scrapers/collect_hn.py` — research collector used to build this snapshot.
-- `scrapers/common.py` — shared collector helpers.
-- `scrapers/world_lib.py` — shared fetch (live official URL, Wayback fallback).
-- `scrapers/archive_fallbacks.py` — Wayback / Common Crawl CDX helpers.
 
 ## License / reuse
 
-Official government / gazette texts; reuse per public-sector terms of the
-source portal. This packaging, metadata, and collector script are provided
-for research.
+Official Honduras La Gaceta texts mirrored by TSC; authentic La Gaceta prevails; 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
 
-Official gazette/portal PDFs via live+Wayback. Catalog-backed incomplete. Not legal advice.
+- https://www.tsc.gob.hn/web/leyes/
+
+## Known gaps
+
+Official PDFs from tsc.gob.hn/web/leyes only (live + Wayback). Gap-fill above thin Hub ~40. Not vLex.

data/articles.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d3b1c8008b0d6dea5212e1ae38b28774b5b1754e60e090cc6adef5a7fa295657
-size 493804
+oid sha256:38060b6ec82b3512a02e47233b2ab47d13a3bdd15351b029dee860f0a6b4a6cd
+size 2103036

data/laws.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c318e67cd24a03157efcafc2114f19d4c3a5d155d2bfc75ca9f27e29bcac925b
-size 644133
+oid sha256:b0361320825423b3c9e1669383a3ed8d45cf3a9b24a8ca8f15463bde04c9a4d9
+size 2271454

scrapers/archive_fallbacks.py

@@ -24,8 +24,10 @@ from requests.adapters import HTTPAdapter
 
 log = logging.getLogger("archive_fallbacks")
 
-WAYBACK_CDX = "http://web.archive.org/cdx/search/cdx"
-WAYBACK_WEB = "http://web.archive.org/web"
+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,112 @@ 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).
+    """
+    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, 4):
+        _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", "-fsS", "--max-time", "90",
+                    "-A", UA,
+                    "-w", "\n__HTTP_STATUS__%{http_code}\n__CONTENT_TYPE__%{content_type}\n__URL_EFFECTIVE__%{url_effective}",
+                    "--output", "-",
+                    target,
+                ],
+                capture_output=True,
+                timeout=100,
+            )
+            raw = proc.stdout or b""
+            # Trailer is text appended after body when -w is used with --output -
+            # With --output -, -w goes to stdout after body. Split on trailer markers.
+            marker = b"\n__HTTP_STATUS__"
+            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)
+                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
+            else:
+                body = raw
+                status = 200 if proc.returncode == 0 and raw else 0
+            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 < 3:
+                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 +403,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 +472,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_hn.py

@@ -38,7 +38,7 @@ def discover():
         "tsc.gob.hn/web/leyes/",
         "www.tsc.gob.hn/leyes/",
     ):
-        for h in cdx_urls(prefix, limit=env_int("CDX_LIMIT", 250), match_type="prefix",
+        for h in cdx_urls(prefix, limit=env_int("CDX_LIMIT", 2000), match_type="prefix",
                           extra_filters=["mimetype:application/pdf"]):
             orig = h.get("original") or ""
             if orig:
@@ -50,8 +50,8 @@ def discover():
 def main():
     setup_log(CC)
     t0 = utcnow()
-    max_new = env_int("MAX_NEW", 40)
-    max_seconds = env_int("MAX_SECONDS", 2400)
+    max_new = env_int("MAX_NEW", 200)
+    max_seconds = env_int("MAX_SECONDS", 3600)
     t_start = time.time()
     done = existing_ids(CC)
     ok = skip = fail = 0

scrapers/common.py

@@ -234,13 +234,11 @@ def xml_to_text(raw: str, skip_tags: Optional[set[str]] = None) -> str:
 
 ARTICLE_SPLIT = re.compile(
     r"(?im)^\s*((?:art(?:icle|ikel|\.)|§|článek|článok|član|artikkel|articolo|"
-    r"artigo|artículo|artykuł|art\.\s*|str\.\s*|para(?:graph)?\.?|szakasz|"
-    r"άρθρο|Άρθρο|ΑΡΘΡΟ)\s+"
-    r"[\dIVXLCDMΑ-Ω]+[a-zA-ZΑ-Ωa-z]?)\b"
+    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 []
@@ -506,3 +504,28 @@ def iso_date(val: Optional[str]) -> Optional[str]:
     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

@@ -105,7 +105,20 @@ def split_custom(text: str, law_id: str, source_url: str, date: Optional[str], p
     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)
@@ -138,6 +151,7 @@ def fetch_official(
     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": "",