normalize.py

#!/usr/bin/env python3
import argparse
import json
import re
import shutil
from pathlib import Path


OPTION_PREFIX_RE = re.compile(r"^\s*[A-Ea-e]\s*[\)\.\:\-]\s*")


def clean_option(text: str) -> str:
    """Remove leading A), B), etc. and normalize whitespace."""
    text = OPTION_PREFIX_RE.sub("", str(text)).strip()
    return " ".join(text.split())


def normalize_text(text: str) -> str:
    return " ".join(str(text).strip().split())


def make_new_id(i: int) -> str:
    return f"metalex_{i:06d}"


def load_jsonl(path: Path):
    rows = []
    with path.open("r", encoding="utf-8") as f:
        for line_no, line in enumerate(f, start=1):
            if line.strip():
                try:
                    rows.append(json.loads(line))
                except json.JSONDecodeError as e:
                    raise ValueError(f"Bad JSON on line {line_no}: {e}") from e
    return rows


def write_jsonl(path: Path, rows):
    with path.open("w", encoding="utf-8") as f:
        for row in rows:
            f.write(json.dumps(row, ensure_ascii=False) + "\n")


def normalize_dataset(
    input_jsonl: Path,
    input_images_dir: Path,
    output_dir: Path,
    source: str = "English Wiktionary",
    split: str = "test",
    example_n: int = 25,
    copy_images: bool = True,
):
    output_data_dir = output_dir / "data"
    output_images_dir = output_dir / "images"
    output_examples_dir = output_dir / "examples"

    output_data_dir.mkdir(parents=True, exist_ok=True)
    output_images_dir.mkdir(parents=True, exist_ok=True)
    output_examples_dir.mkdir(parents=True, exist_ok=True)

    rows = load_jsonl(input_jsonl)
    normalized_rows = []
    warnings = []

    for new_i, entry in enumerate(rows):
        old_id = entry.get("id", new_i)
        new_id = make_new_id(new_i)

        idiom = normalize_text(entry.get("word", entry.get("idiom", "")))
        literal_text = normalize_text(entry.get("literal", entry.get("literal_text", "")))
        figurative = normalize_text(entry.get("figurative", entry.get("correct_definition", "")))

        raw_options = entry.get("options", entry.get("choices", []))
        choices = [clean_option(o) for o in raw_options]

        # In the original MetaLex files, answer is always option A.
        # Therefore, after removing A)/B)/... prefixes, the gold answer is choices[0].
        if not choices:
            raise ValueError(f"{new_id}: no options found.")

        answer_index = 0
        answer = choices[0]

        # Keep the long definition separately, but do NOT insert it into choices.
        # This preserves the exact original MCQ options.
        if figurative and figurative.lower() != answer.lower():
            warnings.append(
                f"{new_id}: figurative field differs from option A; kept option A as the answer."
            )

        src_image = input_images_dir / f"{old_id}_img.png"
        dst_image_name = f"{new_id}.png"
        dst_image = output_images_dir / dst_image_name

        if src_image.exists():
            if copy_images:
                shutil.copy2(src_image, dst_image)
            else:
                shutil.move(src_image, dst_image)
        else:
            warnings.append(f"{new_id}: missing image {src_image}")

        normalized = {
            "id": new_id,
            "idiom": idiom,
            "literal_text": literal_text,
            "image": f"images/{dst_image_name}",
            "correct_definition": figurative,
            "choices": choices,
            "answer_index": answer_index,
            "answer": answer,
            "split": split,
            "source": source,
        }

        for optional_key in [
            "category",
            "source_domain",
            "target_domain",
            "notes",
            "license",
            "wiktionary_url",
        ]:
            if optional_key in entry and entry[optional_key] not in ("", None):
                normalized[optional_key] = entry[optional_key]

        normalized_rows.append(normalized)

    main_jsonl = output_data_dir / "metalex_test.jsonl"
    examples_jsonl = output_examples_dir / "metalex_examples.jsonl"

    write_jsonl(main_jsonl, normalized_rows)
    write_jsonl(examples_jsonl, normalized_rows[:example_n])

    schema = {
        "id": "stable string id, e.g. metalex_000001",
        "idiom": "lexicalised metaphor string",
        "literal_text": "literal paraphrase used to generate/evaluate the scene",
        "image": "relative path to literal image",
        "correct_definition": "full gold figurative meaning/definition",
        "choices": "multiple-choice answer options without A/B/C prefixes",
        "answer_index": "always 0 because the correct answer is always option A in the source file",
        "answer": "choices[0], the correct option text",
        "split": "dataset split",
        "source": "source lexicon or source description",
    }

    with (output_dir / "schema.json").open("w", encoding="utf-8") as f:
        json.dump(schema, f, ensure_ascii=False, indent=2)

    if warnings:
        warning_path = output_dir / "normalization_warnings.txt"
        warning_path.write_text("\n".join(warnings) + "\n", encoding="utf-8")
        print(f"Wrote {len(warnings)} warnings to {warning_path}")

    print(f"Wrote {len(normalized_rows)} rows to {main_jsonl}")
    print(f"Wrote {min(example_n, len(normalized_rows))} examples to {examples_jsonl}")
    print(f"Images written to {output_images_dir}")


def main():
    parser = argparse.ArgumentParser(description="Normalize MetaLex JSONL and image filenames for upload.")
    parser.add_argument(
        "--base_dir",
        type=Path,
        default=Path(r"c:\Users\pranjal\Desktop\ProjectVLM\dataset_to_upload"),
        help="Folder containing met_schema.json and images/",
    )
    parser.add_argument("--json_name", default="met_schema.json", help="Input JSONL filename.")
    parser.add_argument("--images_name", default="images", help="Input image folder name.")
    parser.add_argument("--out_dir", type=Path, default=None, help="Output folder. Default: base_dir/metalex_hf_upload")
    parser.add_argument("--source", default="English Wiktionary")
    parser.add_argument("--split", default="test")
    parser.add_argument("--example_n", type=int, default=25)
    parser.add_argument("--move_images", action="store_true", help="Move images instead of copying them.")
    args = parser.parse_args()

    base_dir = args.base_dir
    input_jsonl = base_dir / args.json_name
    input_images_dir = base_dir / args.images_name
    output_dir = args.out_dir or (base_dir / "metalex_hf_upload")

    normalize_dataset(
        input_jsonl=input_jsonl,
        input_images_dir=input_images_dir,
        output_dir=output_dir,
        source=args.source,
        split=args.split,
        example_n=args.example_n,
        copy_images=not args.move_images,
    )


if __name__ == "__main__":
    main()