Upload folder using huggingface_hub

MANIFEST.md

@@ -1,13 +1,13 @@
 # ipfs_philippines_laws manifest
 
-generated_utc: 2026-09-09T06:15:57Z
+generated_utc: 2026-09-16T21:52:12Z
 cc: ph
 laws_rows: 10870
-articles_rows: 33589
-laws_bytes: 13157421
-articles_bytes: 9651096
-laws_sha256: c508d78e255d3378d44876f202d202b73c4cc4fdbb73f23d2de95e4d78afcca6
-articles_sha256: e11f165ec9f79cf6f40fbd6ca8da4e1e0cb4a0d6ec112934c974a61b55aa21c6
+articles_rows: 93180
+laws_bytes: 13168648
+articles_bytes: 15271881
+laws_sha256: 8717484e0e634b94239dea2012ffe546a5ab3f9f847796cf480bd9fc948db7bd
+articles_sha256: ab4b3ad31ff667c01e40a34b0a99501f5a404ed1fd192a3f05eab1e54463d5ea
 laws_parquet: /workspace/legal-corpora/hf-staging/ipfs_philippines_laws/data/laws.parquet
 articles_parquet: /workspace/legal-corpora/hf-staging/ipfs_philippines_laws/data/articles.parquet
 compression: zstd

README.md

@@ -34,12 +34,12 @@ Research snapshot of official national legislation from **Official Gazette of th
 
 | Field | Value |
 | --- | --- |
-| Snapshot date | 2026-09-09 |
+| Snapshot date | 2026-09-16 |
 | Coverage | interim |
 | Source | Official Gazette of the Republic of the Philippines + Senate LRB issuances library |
 | Collector | `scrapers/collect_ph.py` |
 | Laws / instruments | 10,870 |
-| Articles | 33,589 |
+| Articles | 93,180 |
 | Language | en |
 | Jurisdiction | Philippines |
 | License | `ph-official-gazette-texts` |

data/articles.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e11f165ec9f79cf6f40fbd6ca8da4e1e0cb4a0d6ec112934c974a61b55aa21c6
-size 9651096
+oid sha256:ab4b3ad31ff667c01e40a34b0a99501f5a404ed1fd192a3f05eab1e54463d5ea
+size 15271881

data/laws.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c508d78e255d3378d44876f202d202b73c4cc4fdbb73f23d2de95e4d78afcca6
-size 13157421
+oid sha256:8717484e0e634b94239dea2012ffe546a5ab3f9f847796cf480bd9fc948db7bd
+size 13168648

scrapers/_ph_densify_articles.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""PH Cap/Section densify on existing instruments (offline, no re-fetch / no WARC).
+
+Senate LRB / Official Gazette Republic Acts — Commonwealth SECTION/SEC./Section/
+Article/CHAPTER Cap. Many Senate LRB bodies jam SEC. markers mid-line; jam-normalize
+inserts newlines before Cap markers, then prefer_enacting_body skips chrome after
+"Be it enacted … assembled:". LEAN Cap: write only when article count rises.
+Official pack text only.
+TAG: ph_cap_section_v1
+"""
+from __future__ import annotations
+
+import json
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import ROOT, INDEX_FIELDS, atomic_write
+from world_lib import split_custom
+
+# Insert newline before Cap markers jammed after non-newline (Senate LRB HTML→text).
+JAM = re.compile(
+    r"(?<=[^\n])(?=(?:SECTION|SEC\.|Section|Sec\.|ARTICLE|Article|Art\.|"
+    r"CHAPTER|Chapter)\s+[IVXLCDM0-9]+[A-Za-z]?\b)"
+)
+
+ART = re.compile(
+    r"(?im)^\s*((?:ARTICLE|Article|Art\.|SECTION|Section|SEC\.|Sec\.)\s+[IVXLCDM0-9]+[A-Za-z]?\b|"
+    r"(?:CHAPTER|Chapter|PART|Part)\s+[IVXLCDM0-9]+)"
+)
+ART_STRICT = re.compile(
+    r"(?im)^\s*((?:SECTION|Section|SEC\.|Sec\.|ARTICLE|Article)\s+[IVXLCDM0-9]+[A-Za-z]?\b|"
+    r"(?:CHAPTER|Chapter)\s+[IVXLCDM0-9]+)"
+)
+TAG = "ph_cap_section_v1"
+
+
+def jam_normalize(text: str) -> str:
+    if not text:
+        return text
+    return JAM.sub("\n", text)
+
+
+def prefer_enacting_body(text: str) -> str:
+    """Skip OG/Senate chrome; start after Be it enacted … assembled: or last Sec. 1."""
+    if not text:
+        return text
+    m = re.search(r"(?is)Be it enacted.{0,500}?assembled\s*:", text)
+    if m and m.end() < len(text) - 80:
+        rest = text[m.end() :]
+        if len(rest) > len(text) * 0.12:
+            return rest
+    m = re.search(r"(?is)BE IT ENACTED.{0,400}?:", text)
+    if m and m.end() < len(text) - 80:
+        rest = text[m.end() :]
+        if len(rest) > len(text) * 0.12:
+            return rest
+    secs = list(re.finditer(r"(?im)^\s*(?:SECTION|Section|SEC\.|Sec\.)\s+1\b", text))
+    if len(secs) >= 2:
+        return text[secs[-1].start() :]
+    if len(secs) == 1 and secs[0].start() > 120:
+        return text[secs[0].start() :]
+    return text
+
+
+def pick_docs(text: str, rid: str, url: str, date):
+    norm = jam_normalize(text)
+    body = prefer_enacting_body(norm)
+    d_lean = split_custom(body, rid, url, date, ART)
+    d_strict = split_custom(body, rid, url, date, ART_STRICT)
+    if len(body) < len(norm) * 0.35:
+        d_lean_f = split_custom(norm, rid, url, date, ART)
+        d_strict_f = split_custom(norm, rid, url, date, ART_STRICT)
+        if len(d_lean_f) >= len(d_lean):
+            d_lean = d_lean_f
+        if len(d_strict_f) >= len(d_strict):
+            d_strict = d_strict_f
+    # fallback: no jam (already newline-friendly texts)
+    body0 = prefer_enacting_body(text)
+    d_raw = split_custom(body0, rid, url, date, ART)
+    best, mode = d_lean, "lean"
+    if len(d_strict) > len(best):
+        best, mode = d_strict, "strict"
+    if len(d_raw) > len(best):
+        best, mode = d_raw, "raw"
+    return best, mode
+
+
+def rebuild_index() -> tuple[int, int]:
+    inst = ROOT / "ph" / "instruments"
+    index = ROOT / "ph" / "index.jsonl"
+    rows = []
+    arts = 0
+    for p in sorted(inst.glob("*.json")):
+        try:
+            rec = json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        n = int(rec.get("article_count") or len(rec.get("documents") or []) or 0)
+        arts += n
+        line = {k: rec.get(k) for k in INDEX_FIELDS if k not in ("path", "bytes", "article_count")}
+        line["path"] = f"instruments/{p.name}"
+        line["article_count"] = n
+        line["bytes"] = p.stat().st_size
+        line["id"] = rec.get("id") or p.stem
+        rows.append(line)
+    atomic_write(index, "".join(json.dumps(r, ensure_ascii=False) + "\n" for r in rows))
+    return len(rows), arts
+
+
+def main():
+    dry = "--dry-run" in sys.argv
+    root = ROOT / "ph" / "instruments"
+    old_sum = new_sum = changed = zero_fixed = 0
+    modes: dict[str, int] = {}
+    shellish = 0
+    sample_shell: list[dict] = []
+    for path in sorted(root.glob("*.json")):
+        try:
+            rec = json.loads(path.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        text = rec.get("text") or ""
+        old = int(rec.get("article_count") or len(rec.get("documents") or []) or 0)
+        if len(text) < 80:
+            old_sum += old
+            new_sum += old
+            continue
+        rid = rec.get("id") or path.stem
+        url = rec.get("source_url") or ""
+        date = rec.get("date")
+        docs, mode = pick_docs(text, rid, url, date)
+        new = len(docs)
+        modes[mode] = modes.get(mode, 0) + 1
+        if new <= old:
+            old_sum += old
+            new_sum += old
+            continue
+        if new < 2 and old >= new:
+            old_sum += old
+            new_sum += old
+            continue
+        is_shell = False
+        if docs:
+            avg = sum(len(d.get("text") or "") for d in docs) / len(docs)
+            if avg < 80 or len(text) < 400:
+                is_shell = True
+                shellish += 1
+                if len(sample_shell) < 8:
+                    sample_shell.append({
+                        "id": rid,
+                        "new": new,
+                        "avg_chunk": round(avg, 1),
+                        "text_len": len(text),
+                        "title0": (docs[0].get("title") or "")[:80],
+                    })
+        if dry:
+            changed += 1
+            if old == 0 and new > 0:
+                zero_fixed += 1
+            old_sum += old
+            new_sum += new
+            continue
+        if is_shell:
+            old_sum += old
+            new_sum += old
+            continue
+        rec["documents"] = docs
+        rec["article_count"] = new
+        rec["article_extraction_status"] = "ok" if new >= 2 else ("missing" if not new else "partial")
+        meta = rec.get("metadata") or {}
+        meta["article_re"] = TAG
+        meta["article_re_mode"] = mode
+        meta["article_reprocess"] = "collect_ph.py-cap-sections"
+        meta["article_split"] = "commonwealth-cap"
+        rec["metadata"] = meta
+        atomic_write(path, json.dumps(rec, ensure_ascii=False, indent=2) + "\n")
+        changed += 1
+        if old == 0 and new > 0:
+            zero_fixed += 1
+        old_sum += old
+        new_sum += new
+    laws, arts = (0, 0)
+    if not dry:
+        laws, arts = rebuild_index()
+    report = {
+        "cc": "ph",
+        "tag": TAG,
+        "dry_run": dry,
+        "changed": changed,
+        "old_articles_sum": old_sum,
+        "new_articles_sum": new_sum,
+        "delta": new_sum - old_sum,
+        "zero_fixed": zero_fixed,
+        "shellish_skipped": shellish,
+        "hub_tip_articles": 33589,
+        "laws": laws,
+        "articles": arts,
+        "modes": modes,
+        "sample_shellish": sample_shell,
+    }
+    out = ROOT / "ph" / "raw" / "densify_articles_report.json"
+    if not dry:
+        out.parent.mkdir(parents=True, exist_ok=True)
+        atomic_write(out, json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report), flush=True)
+
+
+if __name__ == "__main__":
+    main()

scrapers/archive_fallbacks.py

@@ -288,10 +288,13 @@ def search_wayback_machine(
     return out[:target]
 
 
+
 def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
     """Fetch a snapshot; id_ modifier skips Wayback chrome. No CDX search.
 
     Prefer HTTP Wayback via curl (requests follows http→https and SSL-EOFs here).
+    Follow 3xx Location only after rewriting https://web.archive.org → http://.
+    Redirect hops do not consume the HTTP retry budget.
     """
     import subprocess
 
@@ -305,15 +308,19 @@ def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
     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))
+    redirects_left = 8
+    attempts_left = 5
+    first = True
+    while attempts_left > 0:
+        _sleep_wayback(0.35 if not first and redirects_left < 8 else (0.8 if first else min(8.0, 1.8 * (6 - attempts_left))))
+        first = False
         try:
             # Stay on HTTP: no -L (redirects flip to https and SSLEOF on this host)
             proc = subprocess.run(
                 [
-                    "curl", "-fsS", "--max-time", "90",
+                    "curl", "-sS", "--max-time", "90",
                     "-A", UA,
-                    "-w", "\n__HTTP_STATUS__%{http_code}\n__CONTENT_TYPE__%{content_type}\n__URL_EFFECTIVE__%{url_effective}",
+                    "-w", "\n__HTTP_STATUS__%{http_code}\n__CONTENT_TYPE__%{content_type}\n__URL_EFFECTIVE__%{url_effective}\n__REDIRECT_URL__%{redirect_url}",
                     "--output", "-",
                     target,
                 ],
@@ -321,55 +328,95 @@ def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
                 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__"
+            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 "").strip()
+                if loc.startswith("/"):
+                    loc = "http://web.archive.org" + loc
+                if loc.startswith("https://web.archive.org/"):
+                    loc = "http://" + loc[len("https://"):]
+                if loc.startswith("http://web.archive.org/") and redirects_left > 0:
+                    log.info("wayback replay follow HTTP redirect %s -> %s", status, loc[:120])
+                    target = loc
+                    final_url = loc
+                    redirects_left -= 1
+                    continue  # redirect hop: do not consume attempts_left
+                last_err = f"http_{status}_bad_redirect"
+                log.info("wayback replay HTTP %s bad redirect %s", status, (loc or "")[:160])
+                attempts_left -= 1
+                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)
+                attempts_left -= 1
                 continue
-            if status in (403, 429, 503, 502, 504) and attempt < 3:
-                log.info("wayback replay HTTP %s %s attempt=%s", status, url, attempt)
+            if status in (403, 429, 503, 502, 504) and attempts_left > 1:
+                log.info("wayback replay HTTP %s %s attempts_left=%s", status, url, attempts_left)
+                attempts_left -= 1
                 continue
             break
         except Exception as exc:
             last_err = str(exc)
             log.info("wayback replay fail %s: %s", url, exc)
+            attempts_left -= 1
             continue
     else:
         # fallback: requests without following redirects to https
         try:
-            r = session().get(target, timeout=(20, 90), allow_redirects=False)
-            status = r.status_code
-            body = r.content or b""
-            ctype = r.headers.get("content-type") or ""
-            final_url = r.url or target
-            if status in (301, 302, 303, 307, 308):
-                loc = r.headers.get("Location") or ""
+            hops = 0
+            while hops < 8:
+                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 not in (301, 302, 303, 307, 308):
+                    break
+                loc = (r.headers.get("Location") or "").strip()
+                if loc.startswith("/"):
+                    loc = "http://web.archive.org" + loc
                 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
+                if not loc.startswith("http://web.archive.org/"):
+                    last_err = f"http_{status}_bad_redirect"
+                    break
+                target = loc
+                final_url = loc
+                hops += 1
         except requests.RequestException as exc:
             return {"status": "error", "error": last_err or str(exc), "url": url}
 
-    if not body and status != 200:
+    if (not body and status != 200) or status == 404:
+        # /2id_/ sometimes lands on a missing capture; pick an explicit CDX 200 snapshot.
+        if not timestamp:
+            try:
+                hits = search_wayback_machine(url, limit=5, filter_status="200", collapse="digest")
+                for hit in hits:
+                    ts = hit.get("timestamp") or ""
+                    orig = hit.get("original") or url
+                    if not ts:
+                        continue
+                    alt = get_wayback_content(orig, timestamp=ts)
+                    if alt.get("status") == "success" and (alt.get("content") or b""):
+                        return alt
+                    # also try original host/path casing from CDX
+            except Exception as exc:
+                log.info("wayback cdx retry after http_%s: %s", status, exc)
         return {"status": "error", "error": last_err or f"http_{status}", "url": url}
     cap_ts = timestamp or ""
     m = re.search(r"/web/(\d{14})", final_url or "")

scrapers/world_lib.py

@@ -217,15 +217,28 @@ def fetch_official(
                             text=text,
                             content=pdf_bytes,
                             method="wayback_pdf",
-                            source_url=w.get("url") or url,
+                            source_url=w.get("wayback_url") or w.get("url") or url,
                             content_type="application/pdf",
                         )
                         return out
+                    # Keep PDF bytes so caller can OCR (image-only / bad text layer)
+                    out.update(
+                        content=pdf_bytes,
+                        content_type="application/pdf",
+                        method="wayback_pdf_bytes",
+                        source_url=w.get("wayback_url") or w.get("url") or url,
+                    )
                     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]:
+                    # Treat as PDF bytes for OCR upstream
+                    pdf_bytes = raw_b if isinstance(raw_b, bytes) else raw_t.encode("latin-1", "replace")
+                    if isinstance(pdf_bytes, bytes) and b"%PDF" in pdf_bytes[:8192]:
+                        if pdf_bytes[:4] != b"%PDF":
+                            pdf_bytes = pdf_bytes[pdf_bytes.find(b"%PDF"):]
+                        out.update(content=pdf_bytes, content_type="application/pdf", method="wayback_pdf_bytes")
                     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