src/update_descriptive_statistics.py

"""
A simple CLI to updates descriptive statistics on all datasets.

Example use:

    python update_descriptive_statistics.py --dataset wikisource

"""

import argparse
import json
import logging
import multiprocessing
from dataclasses import dataclass
from pathlib import Path
from textwrap import dedent
from typing import Self, cast

from datasets import Dataset, load_dataset
from git_utilities import check_is_ancestor, get_current_revision, get_latest_revision
from transformers import AutoTokenizer

logger = logging.getLogger(__name__)

repo_path = Path(__file__).parent.parent

tokenizer_name = "AI-Sweden-Models/Llama-3-8B-instruct"
tokenizer = AutoTokenizer.from_pretrained(tokenizer_name, use_fast=True)


def human_readable_large_int(value: int) -> str:
    thresholds = [
        (1_000_000_000, "B"),
        (1_000_000, "M"),
        (1_000, "K"),
    ]
    for threshold, label in thresholds:
        if value > threshold:
            return f"{value/threshold:.2f}{label}"

    return str(value)


def calculate_average_document_length(
    dataset: Dataset, text_column: str = "text"
) -> float:
    texts = sum(len(t) for t in dataset[text_column])
    return texts / len(dataset)


def _count_tokens(batch):
    return {
        "token_count": [
            len(tokens)
            for tokens in tokenizer(batch["text"], padding=False)["input_ids"]
        ]
    }


def calculate_number_of_tokens(
    dataset: Dataset,
    text_column: str = "text",
) -> int:
    token_counts = dataset.map(
        _count_tokens,
        batched=True,
        batch_size=1000,
        num_proc=multiprocessing.cpu_count(),
    )
    return sum(token_counts["token_count"])


@dataclass()
class DescriptiveStatsOverview:
    number_of_samples: int
    average_document_length: float
    number_of_tokens: int
    language: str = "dan, dansk, Danish"

    @classmethod
    def from_dataset(cls, dataset: Dataset) -> Self:
        return cls(
            number_of_samples=len(dataset),
            average_document_length=calculate_average_document_length(dataset),
            number_of_tokens=calculate_number_of_tokens(dataset),
        )

    def to_markdown(self) -> str:
        format = dedent(f"""

        - **Language**: {self.language}
        - **Number of samples**: {human_readable_large_int(self.number_of_samples)}
        - **Number of tokens (Llama 3)**: {human_readable_large_int(self.number_of_tokens)}
        - **Average document length (characters)**: {self.average_document_length:.2f}

        """)
        return format

    def add_to_markdown(self, markdown: str) -> str:
        start_identifier = "<!-- START-DESC-STATS -->"
        end_identifier = "<!-- END-DESC-STATS -->"

        if markdown.count(start_identifier) != 1 or markdown.count(end_identifier) != 1:
            raise ValueError("Markers should appear exactly once in the markdown.")

        start_md, _, remainder = markdown.partition(start_identifier)
        _, _, end_md = remainder.partition(end_identifier)

        stats = self.to_markdown()
        return f"{start_md}{start_identifier}{stats}{end_identifier}{end_md}"

    def to_disk(self, path: Path):
        data = self.__dict__
        data["revision"] = get_current_revision()
        with path.with_suffix(".json").open("w") as f:
            json.dump(self.__dict__, f)


def update_statitics(
    dataset_path: Path,
    name: str,
    readme_name: None | str = None,
    force: bool = False,
) -> None:
    rev = get_latest_revision(dataset_path)

    desc_stats_path = dataset_path / "descriptive_stats.json"
    if desc_stats_path.exists() and force is False:
        with desc_stats_path.open("r") as f:
            last_update = json.load(f).get("revision", None)

        if last_update is None:
            logging.warning(f"revision is not defined in {desc_stats_path}.")
        elif check_is_ancestor(ancestor_rev=last_update, rev=rev):
            logging.info(
                f"descriptive statistics for '{name}' is already up to date, skipping."
            )
            return

    logger.info(f"Updating statistics for {name}")
    ds = load_dataset(str(repo_path), name, split="train")
    ds = cast(Dataset, ds)
    desc_stats = DescriptiveStatsOverview.from_dataset(ds)

    readme_name = f"{name}.md" if readme_name is None else readme_name
    markdown_path = dataset_path / readme_name
    with markdown_path.open("r") as f:
        new_markdown = desc_stats.add_to_markdown(f.read())
    with markdown_path.open("w") as f:
        f.write(new_markdown)

    desc_stats.to_disk(desc_stats_path)


def create_parser():
    parser = argparse.ArgumentParser(
        description="Calculated descriptive statistics of the datasets in tha data folder"
    )
    parser.add_argument(
        "--dataset",
        default=None,
        type=str,
        help="Use to specify if you only want to compute the statistics from a singular dataset.",
    )
    parser.add_argument(
        "--logging_level",
        default=20,
        type=int,
        help="Sets the logging level. Default to 20 (INFO), other reasonable levels are 10 (DEBUG) and 30 (WARNING).",
    )
    parser.add_argument(
        "--force",
        type=bool,
        default=False,
        action=argparse.BooleanOptionalAction,
        help="Should the statistics be forcefully recomputed. By default it checks the difference in commit ids.",
    )
    parser.add_argument(
        "--repo_path",
        default=str(repo_path),
        type=str,
        help="The repository where to calculate the descriptive statistics from",
    )
    return parser

def update_main_table(repo_path: Path = repo_path):
    main_readme = repo_path / "README.md"
    get_tag_idx()


def main(
    dataset: str | None = None,
    logging_level: int = 20,
    force: bool = False,
    repo_path: Path = repo_path,
):
    logging.basicConfig(level=logging_level)

    if dataset:
        dataset_path = repo_path / "data" / dataset
        update_statitics(repo_path, dataset_path.name, force=force)
        return

    datasets = (repo_path / "data").glob("*")
    for dataset_path in datasets:
        update_statitics(dataset_path, dataset_path.name, force=force)

    update_statitics(repo_path, "default", "README.md", force=force)


if __name__ == "__main__":
    parser = create_parser()
    args = parser.parse_args()

    main(
        args.dataset,
        logging_level=args.logging_level,
        force=args.force,
        repo_path=Path(args.repo_path),
    )