rehydrate-citations.py

from collections import defaultdict
from collections.abc import Iterable
import copy
from io import TextIOBase
from functools import lru_cache
import json
from typing import Any, Optional

import click
import datetime
import ftfy  # type: ignore
import requests
from tqdm import tqdm
import trafilatura  # type: ignore
from humanfriendly import format_number


# Download parameters
DOWNLOAD_TIMEOUT = 10  # Timeout in seconds of each HTTP request
DOWNLOAD_BUFFER_SIZE = 65_536  # Size of each HTTP request chunk in bytes
CODE_MAX_NUM_CHARS = 1_000_000  # Downloaded source code character threshold (applied after decoding to text)

# Extraction parameters
INCLUDE_COMMENTS = False  # Whether to include WP user comments in extracted text
INCLUDE_TABLES = True  # Whether to include markdown for HTML tables in extracted text
INCLUDE_LINKS = True  # Whether to include markdown for HTML links in extracted text
TEXT_MIN_NUM_WORDS = 100  # Extracted text word (whitespace-delimited token) threshold; None to disable
TEXT_MIN_NUM_CHARS = None  # Extracted text character threshold; None to disable


class DownloadTooLarge(Exception):
    pass


def download_url(url: str) -> tuple[Optional[str], dict[str, Any]]:
    """
    Fetch content at URL, returning downloaded source code and metadata.
    Metadata is represented as a dictionary containing Citation keys and values.
    """
    source_code: Optional[str] = None
    content_type: Optional[str] = None
    num_chars: Optional[int] = None
    error: Optional[str] = None
    download_date = datetime.datetime.now().astimezone().isoformat()

    try:
        with requests.get(url, stream=True, timeout=DOWNLOAD_TIMEOUT) as response:
            content_type = response.headers.get('Content-Type')
            try:
                content = ''
                for chunk in response.iter_content(chunk_size=DOWNLOAD_BUFFER_SIZE, decode_unicode=True):
                    content += chunk
                    if len(content) > CODE_MAX_NUM_CHARS:
                        raise DownloadTooLarge()
                source_code = content
                num_chars = len(content)
            except DownloadTooLarge:
                source_code = None
                error = 'Download is too large'
    except Exception as ex:
        source_code = None
        error = f'{type(ex).__name__}: {ex}'

    if not source_code:
        source_code = None
        error = 'Download is empty'

    metadata = dict(
        source_code_content_type=content_type,
        source_code_num_chars=num_chars,
        source_download_date=download_date,
        source_download_error=error,
    )
    return (source_code, metadata)


def count_words(text: str) -> int:
    return len(text.split())


def has_sufficient_word_count(source_text: str) -> bool:
    return not TEXT_MIN_NUM_WORDS or count_words(source_text) > TEXT_MIN_NUM_WORDS


def has_sufficient_char_count(source_text: str) -> bool:
    return not TEXT_MIN_NUM_CHARS or len(source_text) > TEXT_MIN_NUM_CHARS


def extract_source_text(source_code: str) -> dict[str, Any]:
    """
    Given a source's HTML, extract and return textual content and error information
    as a dictionary containing citation keys and values.
    """
    text: Optional[str] = None
    error: Optional[str] = None

    try:
        text = trafilatura.extract(
            source_code,
            include_comments=INCLUDE_COMMENTS,
            include_tables=INCLUDE_TABLES,
            include_links=INCLUDE_LINKS,
        )
        if text is not None:
            text = ftfy.fix_text(text)

    except Exception as ex:
        error = f'{type(ex).__name__}: {ex}'
        text = None

    else:
        if not text:
            error = 'Text is empty'
            text = None

        elif not has_sufficient_word_count(text):
            error = f'Text is too short ({format_number(count_words(text))} words)'
            text = None

        elif not has_sufficient_char_count(text):
            error = f'Text is too short ({format_number(len(text))} characters)'
            text = None

    return dict(
        source_text=text,
        source_extract_error=error,
    )


@lru_cache
def scrape_source_fields(url: str) -> dict[str, Any]:
    """
    Download source code at URL and extract text from the downloaded source code,
    returning a dictionary of fields to add to the corresponding citation.
    This abstraction is a little awkward, but it facilitates caching.
    """
    download_fields: dict[str, Any] = {}
    extraction_fields: dict[str, Any] = {}

    if url:
        (source_code, download_fields) = download_url(url)
        if source_code:
            extraction_fields = extract_source_text(source_code)

    return download_fields | extraction_fields


def scrape_source(citation: dict[str, Any]) -> dict[str, Any]:
    """
    Scrape sources for citation, storing scraped content in citation *in-place.*
    """
    if citation['url']:
        citation['dehydrated_citation'] = copy.deepcopy(citation)
        citation.update(scrape_source_fields(citation['url']))

    return citation


def update_citations_in_excerpts_with_citations(
    excerpts_with_citations: list[dict[str, Any]],
    new_citations: Iterable[dict[str, Any]],
) -> list[dict[str, Any]]:
    """
    Replace citations in `excerpts_with_citations` with the corresponding citations from `new_citations`,
    EXCEPT for the `char_index` field (leaving it as-is).
    Citations are aligned/matched by their content field.
    If a citation content string appears multiple times in `new_citations`, matching citations in
    `excerpts_with_citations` will be replaced with the final match in `new_citations`.
    `excerpts_with_citations` is modified *in-place,* and the updated list is returned.
    """
    ewc_citation_indices_by_key: dict[str, set[tuple[int, int]]] = defaultdict(set)
    for (i, ewc) in enumerate(excerpts_with_citations):
        for (j, citation) in enumerate(ewc['citations']):
            key = citation['content']
            ewc_citation_indices_by_key[key].add((i, j))

    for new_citation in new_citations:
        key = new_citation['content']
        for (i, j) in ewc_citation_indices_by_key[key]:
            excerpts_with_citations[i]['citations'][j] |= {
                k: v
                for (k, v) in new_citation.items()
                if k != 'char_index'
            }

    return excerpts_with_citations  # was modified in-place


def scrape_article_sources(article: dict[str, Any]) -> dict[str, Any]:
    """
    Scrape sources for all web citations in article, storing scraped content in article citation
    objects *in-place.*  Return modified article for convenience.
    """
    all_citations = []
    for element in article['elements']:
        if element['type'] == 'paragraph':
            for sentence in element['sentences']:
                for citation in sentence['citations']:
                    scrape_source(citation)  # modifies in-place
                    all_citations.append(citation)
        elif element['type'] == 'heading':
            for citation in element['citations']:
                scrape_source(citation)  # modifies in-place
                all_citations.append(citation)

    # modifies in-place
    update_citations_in_excerpts_with_citations(article['excerpts_with_citations'], all_citations)

    return article


@click.command(context_settings={'show_default': True})
@click.argument('input_file', type=click.File())
@click.argument('output_file', type=click.File(mode='w'))
@click.option('--stream', '-s', is_flag=True,
              help='Read one article at a time, rehydrating it and writing the output article before reading the next'
                   ' article.  The default behavior is to read all articles into memory before processing them.')
def main(input_file: TextIOBase, output_file: TextIOBase, stream: bool) -> None:
    """
    Scrape sources for all MegaWika 2 articles in JSON-lines (one JSON-encoded article per line) file INPUT_FILE,
    updating each web citation with source-scraping content and metadata and writing the articles with source content
    to JSON-lines file OUTPUT_FILE.

    Each web citation will be updated with `source_text` *and* source-scraping metadata fields; the original
    (dehydrated, metadata-only) web citation will be stored under the new citation field `dehydrated_citation`.
    """
    articles: Iterable[dict[str, Any]] = (json.loads(line) for line in input_file)
    if not stream:
        click.echo('Reading all articles into memory')
        articles = list(articles)

    for article in tqdm(articles, desc='Rehydrating', unit='article'):
        scrape_article_sources(article)
        output_file.write(json.dumps(article) + '\n')

    click.echo('Done')


if __name__ == '__main__':
    main()