Refresh/add Brunei official snapshot (92 laws)

MANIFEST.md

@@ -1,9 +1,16 @@
-# MANIFEST
+# ipfs_brunei_laws manifest
 
-- generated_at: 2026-09-04T20:07:15Z
-- laws: 40
-- articles: 182
-- files:
-  - data/laws.parquet: 1133201 bytes
-  - data/articles.parquet: 989073 bytes
-  - README.md: 1769 bytes
+generated_utc: 2026-09-08T22:53:36Z
+cc: bn
+laws_rows: 92
+articles_rows: 354
+laws_bytes: 1146003
+articles_bytes: 886893
+laws_sha256: e5abc1745c4caa9175801e10793092f267194f7a1312046b0b92068090d2ce71
+articles_sha256: 3f34177b4bb9cb11451814f0abeb88fbeb1133d9d1011c7e1b68ccf71b8bd901
+compression: zstd
+live_count: 92
+archive_count: 0
+collector: scrapers/collect_bn.py
+license: Laws of Brunei / AGC official texts prevail. Not legal advice.
+uploaded: false

README.md

@@ -1,15 +1,17 @@
 ---
-pretty_name: Laws of Brunei
+pretty_name: Brunei Laws (AGC / agc.gov.bn)
 license: other
-license_name: bn-agc-laws
+license_name: bn-agc-official-texts
 language:
 - en
+- ms
 task_categories:
 - text-retrieval
 tags:
 - legal
 - law
 - brunei
+- agc
 - official-texts
 size_categories:
 - n<1K
@@ -21,44 +23,43 @@ configs:
   data_files: data/articles.parquet
 ---
 
-# Laws of Brunei
+# Brunei Laws (AGC / agc.gov.bn)
 
-Research snapshot of official legislation collected from **AGC Laws of Brunei**.
+Research snapshot of **national legislation** from official sources listed below.
 
-**Not legal advice.** Official gazettes / government portals prevail over this corpus.
+**Not legal advice.** The official gazette / authentic text of the jurisdiction
+prevails over this corpus.
 
 ## Snapshot
 
 | Field | Value |
 | --- | --- |
-| Snapshot date | 2026-09-04 |
-| Coverage | catalog-backed incomplete |
-| Source | AGC Laws of Brunei |
+| Snapshot date | 2026-09-02 |
+| Source | Attorney General's Chambers — Laws of Brunei (agc.gov.bn) |
 | Collector | `scrapers/collect_bn.py` |
-| Laws / instruments | 40 |
-| Articles | 182 |
-| Language | en |
-| Jurisdiction | Brunei |
-| License | `bn-agc-laws` |
+| Laws / instruments | 92 |
+| Articles | 354 |
+| Language | en, ms |
+| License | `bn-agc-official-texts` |
 
 ## 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 (zstd).
+- `data/articles.parquet` — article/section rows for the same snapshot.
 - `scrapers/collect_bn.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.
+Laws of Brunei / AGC official texts prevail. 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 gazette prevails.
 
-## Notes
+## Source
 
-Official gazette/portal PDFs via live+Wayback. Catalog-backed incomplete. Not legal advice.
+- https://www.agc.gov.bn/
+- https://agc.gov.bn/
+
+## Known gaps
+
+- Incomplete vs full AGC corpus.
+- Markup PDF variants skipped.

data/articles.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7f57247064ff85230419d19c191153234ec6932cad33bf4a293f6d0810430971
-size 989073
+oid sha256:3f34177b4bb9cb11451814f0abeb88fbeb1133d9d1011c7e1b68ccf71b8bd901
+size 886893

data/laws.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e814f5085426fc16afcd29cb237d58ea53f5af7562402d60b0b9ea142c9e78ec
-size 1133201
+oid sha256:e5abc1745c4caa9175801e10793092f267194f7a1312046b0b92068090d2ce71
+size 1146003

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 = "https://web.archive.org/cdx/search/cdx"
+WAYBACK_WEB = "https://web.archive.org/web"
+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,10 @@ 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:
+                r = session().get(WAYBACK_CDX, params=items, timeout=(20, 90))
+            except requests.RequestException:
+                r = session().get(WAYBACK_CDX_HTTP, params=items, timeout=(20, 90))
         except requests.RequestException as exc:
             last_err = exc
             log.warning("wayback cdx fail %s: %s", url, exc)
@@ -283,22 +288,27 @@ 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; HTTPS Wayback SSL-EOFs from this host (same as VN VBPL).
+    """
     if timestamp:
-        wb = f"{WAYBACK_WEB}/{timestamp}id_/{url}"
+        path = f"/{timestamp}id_/{url}"
     else:
-        wb = f"{WAYBACK_WEB}/2id_/{url}"
+        path = f"/2id_/{url}"
     r = None
     last_err = None
-    for attempt in range(1, 5):
-        _sleep_wayback(1.2 if attempt == 1 else min(20.0, 2.5 * attempt))
+    candidates = [WAYBACK_WEB_HTTP + path, WAYBACK_WEB + path]
+    for attempt in range(1, 4):
+        target = candidates[min(attempt-1, len(candidates)-1)]
+        _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)
+            r = session().get(target, timeout=(20, 90), allow_redirects=True)
         except requests.RequestException as exc:
             last_err = str(exc)
             log.info("wayback replay fail %s: %s", url, exc)
             continue
-        if r.status_code in (403, 429, 503, 502, 504) and attempt < 4:
+        if r.status_code in (403, 429, 503, 502, 504) and attempt < 3:
             log.info("wayback replay HTTP %s %s attempt=%s", r.status_code, url, attempt)
             continue
         break
@@ -349,32 +359,40 @@ def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
 
 # --- 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 +418,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_bn.py

@@ -19,6 +19,44 @@ ART = re.compile(r"(?im)^\s*((?:Section|Article|Art\.?)\s+[0-9]+)\b")
 log = logging.getLogger("bn")
 
 
+def load_prior_catalog(seen: set) -> list:
+    """Resume from raw/catalog.jsonl, index.jsonl, or instrument source_urls when CDX fails."""
+    import json
+    from common import ROOT
+    items = []
+    def add_pair(ident, url):
+        if not url or url in seen:
+            return
+        seen.add(url)
+        items.append((ident or Path(url.split("?")[0]).stem[:160], url))
+    cat = ROOT / "bn" / "raw" / "catalog.jsonl"
+    if cat.exists():
+        for line in cat.open(encoding="utf-8"):
+            try:
+                row = json.loads(line)
+            except Exception:
+                continue
+            add_pair(row.get("ident") or row.get("identifier"), row.get("url") or row.get("source_url"))
+    idx = ROOT / "bn" / "index.jsonl"
+    if idx.exists():
+        for line in idx.open(encoding="utf-8"):
+            try:
+                row = json.loads(line)
+            except Exception:
+                continue
+            add_pair(row.get("identifier") or row.get("id"), row.get("source_url") or row.get("url"))
+    inst = ROOT / "bn" / "instruments"
+    if inst.exists():
+        for jp in inst.glob("*.json"):
+            try:
+                row = json.loads(jp.read_text(encoding="utf-8"))
+            except Exception:
+                continue
+            add_pair(row.get("official_identifier") or row.get("identifier") or jp.stem,
+                     row.get("source_url") or (row.get("metadata") or {}).get("source_url"))
+    return items
+
+
 def discover():
     items, seen = [], set()
     def add(url):
@@ -45,11 +83,21 @@ def discover():
         "www.agc.gov.bn/agc%20images/laws/",
         "www.agc.gov.bn/AGC Images/LAWS/",
     ):
-        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", 1200), match_type="prefix",
                           extra_filters=["mimetype:application/pdf"]):
             orig = h.get("original") or ""
             if orig:
                 add(orig)
+    if not items:
+        items = load_prior_catalog(seen)
+        log.info("cdx empty — reused prior catalog %s", len(items))
+    else:
+        # persist for idempotent resume when CDX is flaky
+        cat = Path(__file__).resolve().parents[1] / "bn" / "raw" / "catalog.jsonl"
+        cat.parent.mkdir(parents=True, exist_ok=True)
+        with cat.open("w", encoding="utf-8") as f:
+            for ident, url in items:
+                f.write(__import__("json").dumps({"ident": ident, "url": url}, ensure_ascii=False) + "\n")
     log.info("catalog %s", len(items))
     return items
 
@@ -57,8 +105,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", 400)
+    max_seconds = env_int("MAX_SECONDS", 7200)
     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 ""