scripts/parsers/parse_lrc.py

#!/usr/bin/env python3
"""Parser for the UT Austin LRC (Linguistics Research Center) PIE lexicon.

Extracts Proto-Indo-European etyma with reconstructed forms and glosses
from the online lexicon at https://lrc.la.utexas.edu/lex

The LRC presents a multi-page index of PIE roots organized alphabetically,
with each root linking to a detail page.

Uses only stdlib (urllib, html.parser, re).
"""

from __future__ import annotations

import logging
import re
import urllib.request
import urllib.error
from html.parser import HTMLParser
from typing import Any

logger = logging.getLogger(__name__)


class LRCIndexParser(HTMLParser):
    """Parse the LRC lexicon index page to extract root links and glosses."""

    def __init__(self) -> None:
        super().__init__()
        self.in_link = False
        self.link_href = ""
        self.link_text = ""
        self.entries: list[dict] = []
        self.in_table = False
        self.in_cell = False
        self.cell_text = ""
        self.current_row: list[str] = []
        self.rows: list[list[str]] = []

    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
        attr_dict = dict(attrs)
        if tag == "a":
            href = attr_dict.get("href", "")
            if href:
                self.in_link = True
                self.link_href = href
                self.link_text = ""
        elif tag == "table":
            self.in_table = True
        elif tag == "tr" and self.in_table:
            self.current_row = []
        elif tag in ("td", "th") and self.in_table:
            self.in_cell = True
            self.cell_text = ""

    def handle_endtag(self, tag: str) -> None:
        if tag == "a" and self.in_link:
            self.in_link = False
            text = self.link_text.strip()
            if text:
                self.entries.append({
                    "text": text,
                    "href": self.link_href,
                })
        elif tag == "table":
            self.in_table = False
        elif tag == "tr" and self.in_table:
            if self.current_row:
                self.rows.append(self.current_row)
        elif tag in ("td", "th") and self.in_cell:
            self.in_cell = False
            self.current_row.append(self.cell_text.strip())

    def handle_data(self, data: str) -> None:
        if self.in_link:
            self.link_text += data
        if self.in_cell:
            self.cell_text += data


def _clean_pie_form(form: str) -> str:
    """Clean a PIE reconstructed form."""
    form = form.strip()
    # Remove leading asterisk (reconstruction marker)
    form = re.sub(r"^\*+", "", form)
    # Remove trailing punctuation
    form = re.sub(r"[.,;:]+$", "", form)
    # Remove parenthetical variants
    form = re.sub(r"\s*\([^)]*\)\s*$", "", form)
    return form.strip()


def _extract_from_index_page(html: str) -> list[dict]:
    """Extract entries from the LRC index page HTML."""
    parser = LRCIndexParser()
    parser.feed(html)

    entries: list[dict] = []

    # Strategy 1: Extract from table rows
    for row in parser.rows:
        if len(row) < 2:
            continue
        # Skip header rows
        if any(kw in c.lower() for c in row for kw in ("root", "meaning", "gloss", "#")):
            continue

        form = _clean_pie_form(row[0])
        gloss = row[1].strip() if len(row) >= 2 else ""
        # Sometimes gloss is in column 2 (after POS)
        if len(row) >= 3 and not gloss:
            gloss = row[2].strip()

        if form and gloss and len(form) < 50:
            entries.append({
                "word": form,
                "transliteration": form,
                "gloss": gloss,
            })

    # Strategy 2: Extract from link text patterns
    if not entries:
        for link_entry in parser.entries:
            text = link_entry["text"]
            # Pattern: "*root - gloss" or "*root 'gloss'"
            m = (
                re.match(r"^\*?(.+?)\s*[-–—]\s+(.+)$", text)
                or re.match(r"^\*?(.+?)\s+'(.+?)'", text)
                or re.match(r"^\*?(.+?)\s+\"(.+?)\"", text)
            )
            if m:
                form = _clean_pie_form(m.group(1))
                gloss = m.group(2).strip()
                if form and gloss:
                    entries.append({
                        "word": form,
                        "transliteration": form,
                        "gloss": gloss,
                    })

    # Strategy 3: regex fallback on raw text
    if not entries:
        text = re.sub(r"<[^>]+>", " ", html)
        # Pattern: *form meaning
        for m in re.finditer(
            r"\*([a-zA-ZÀ-žḀ-ỿəɛɪɔʊ\-]+)"
            r"\s+['\"]?([A-Za-z][A-Za-z\s,'-]{2,60}?)['\"]?"
            r"(?=[,;.\n]|$)",
            text,
        ):
            form = _clean_pie_form(m.group(1))
            gloss = m.group(2).strip()
            gloss = re.sub(r"[,;:\s]+$", "", gloss)
            if form and gloss and len(form) < 40:
                entries.append({
                    "word": form,
                    "transliteration": form,
                    "gloss": gloss,
                })

    return entries


def _fetch_page(url: str) -> str:
    """Fetch a single page, returning empty string on failure."""
    try:
        req = urllib.request.Request(url, headers={"User-Agent": "PhaiPhon/1.0"})
        with urllib.request.urlopen(req, timeout=30) as resp:
            return resp.read().decode("utf-8", errors="replace")
    except (urllib.error.URLError, urllib.error.HTTPError, OSError) as exc:
        logger.warning("LRC: failed to download %s: %s", url, exc)
        return ""


def parse(url: str, **kwargs: Any) -> list[dict]:
    """Download and parse the LRC PIE lexicon.

    Args:
        url: Base URL to the LRC lexicon, e.g.
             https://lrc.la.utexas.edu/lex
        **kwargs:
            max_pages: Maximum number of subpages to fetch (default 30).

    Returns:
        List of dicts with keys: word, transliteration, gloss.
        Returns empty list if URL is unreachable.
    """
    # No artificial page limit — follow ALL pagination links
    max_pages = kwargs.get("max_pages", 9999)
    logger.info("LRC: downloading index from %s", url)

    html = _fetch_page(url)
    if not html:
        return []

    entries = _extract_from_index_page(html)

    # If the index page has pagination links, follow them
    # Look for page links like ?page=2 or /lex/2 etc.
    page_pattern = re.compile(
        r'href="([^"]*(?:page=\d+|/lex/[a-z]|/lex\?letter=[a-z])[^"]*)"',
        re.IGNORECASE,
    )
    subpage_urls: set[str] = set()
    for m in page_pattern.finditer(html):
        href = m.group(1)
        # Make absolute URL
        if href.startswith("/"):
            # Extract base domain
            domain_match = re.match(r"(https?://[^/]+)", url)
            if domain_match:
                href = domain_match.group(1) + href
        elif href.startswith("?"):
            href = url.rstrip("/") + href
        elif not href.startswith("http"):
            href = url.rstrip("/") + "/" + href
        subpage_urls.add(href)

    # Fetch subpages (up to max_pages)
    pages_fetched = 0
    for subpage_url in sorted(subpage_urls):
        if pages_fetched >= max_pages:
            break
        logger.info("LRC: downloading subpage %s", subpage_url)
        subpage_html = _fetch_page(subpage_url)
        if subpage_html:
            sub_entries = _extract_from_index_page(subpage_html)
            entries.extend(sub_entries)
            pages_fetched += 1

    # Deduplicate
    seen: set[tuple[str, str]] = set()
    unique: list[dict] = []
    for e in entries:
        key = (e["word"], e["gloss"])
        if key not in seen:
            seen.add(key)
            unique.append(e)

    logger.info("LRC: extracted %d unique entries total", len(unique))
    return unique


if __name__ == "__main__":
    import sys
    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")

    test_url = (
        sys.argv[1] if len(sys.argv) > 1
        else "https://lrc.la.utexas.edu/lex"
    )
    results = parse(test_url)
    print(f"\nExtracted {len(results)} entries:")
    for entry in results[:15]:
        print(f"  *{entry['word']:25s}  {entry['gloss']}")
    if len(results) > 15:
        print(f"  ... and {len(results) - 15} more")