legex/scrapers/gh.py

"""Ghana Supreme Court via GhaLII (https://ghalii.org).

GhaLII publishes Supreme Court judgments under `/judgments/GHASC/`. Each entry exposes its
citation and decision date in the listing markup, so we can build a Goldenset from metadata alone.
Full text is PDF-only on GhaLII and not extracted here, the labelers click the link to read the judgment.
"""

import html
import logging
import re
import time
from datetime import date
from typing import Iterable

import requests

from legex.models.base import Case
from legex.scrapers.base import BaseScraper

log = logging.getLogger(__name__)

BASE_URL = "https://ghalii.org"
PAGE_DELAY_SECONDS = 0.5
USER_AGENT = "legex-research (open-data, friendly)"
MAX_PAGES_PER_YEAR = 20

_LINK_RE = re.compile(
    r'href="(/akn/gh[^"]*?/judgment/ghasc/(\d{4})/(\d+)/eng@(\d{4}-\d{2}-\d{2}))"'
    r'[^>]*data-key-link="document"[^>]*>([^<]+)</a>'
)
_CRIMINAL_RE = re.compile(r"^\s*(the\s+)?republic\s+v(rs?|\.)?\b", re.IGNORECASE)


class GHScraper(BaseScraper):
    country = "Ghana"

    def scrape(
        self,
        start_date: date | None = None,
        end_date: date | None = None,
    ) -> list[Case]:
        session = requests.Session()
        session.headers.update({"User-Agent": USER_AGENT})

        # Per-year URLs give much better historical coverage than the global listing
        start_year = (start_date or date(2015, 1, 1)).year
        end_year = (end_date or date(2025, 12, 31)).year

        cases: list[Case] = []
        seen: set[str] = set()
        for year in range(start_year, end_year + 1):
            year_cases = self._scrape_year(session, year, start_date, end_date, seen)
            cases.extend(year_cases)

        cases.sort(key=lambda c: c.decision_date or date.min, reverse=True)
        log.info("Collected %d Ghana cases", len(cases))
        return cases

    def _scrape_year(
        self,
        session: requests.Session,
        year: int,
        start_date: date | None,
        end_date: date | None,
        seen: set[str],
    ) -> list[Case]:
        out: list[Case] = []
        for page in range(1, MAX_PAGES_PER_YEAR + 1):
            url = f"{BASE_URL}/judgments/GHASC/{year}/?page={page}"
            try:
                resp = session.get(url, timeout=30)
            except Exception as e:
                log.warning("GH %d page %d request failed (%s); stopping year", year, page, e)
                break
            if resp.status_code == 404:
                break
            if resp.status_code != 200:
                log.warning("GH %d page %d HTTP %d; stopping year", year, page, resp.status_code)
                break

            entries = list(self._parse_listing(resp.text))
            if not entries:
                break

            new_on_page = 0
            for path, ent_year, number, iso_date, title in entries:
                try:
                    decision_date = date.fromisoformat(iso_date)
                except ValueError:
                    continue
                if start_date and decision_date < start_date:
                    continue
                if end_date and decision_date > end_date:
                    continue
                case_id = f"[{ent_year}] GHASC {number}"
                if case_id in seen:
                    continue
                seen.add(case_id)
                new_on_page += 1
                out.append(
                    Case(
                        case_id=case_id,
                        link=f"{BASE_URL}{path}",
                        decision_date=decision_date,
                        jurisdiction="gh",
                        language="en",
                        full_text=None,
                        metadata={
                            "title": html.unescape(title).strip(),
                            "year": ent_year,
                            "number": number,
                        },
                    )
                )
            log.info("GH %d page %d: %d entries (%d new)", year, page, len(entries), new_on_page)
            if new_on_page == 0:
                break
            time.sleep(PAGE_DELAY_SECONDS)
        return out

    @staticmethod
    def _parse_listing(html_text: str) -> Iterable[tuple[str, str, str, str, str]]:
        for match in _LINK_RE.finditer(html_text):
            yield match.group(1), match.group(2), match.group(3), match.group(4), match.group(5)

    @staticmethod
    def civil_filter(cases: list[Case]) -> list[Case]:
        # Heuristic: drop criminal prosecutions "(The) Republic v(rs) X".
        kept = [c for c in cases if not _CRIMINAL_RE.match((c.metadata or {}).get("title", ""))]
        log.info("GH civil_filter kept %d/%d", len(kept), len(cases))
        return kept