convert_scottish_exams.py

#!/usr/bin/env python3
"""
Convert NLS Scottish School Exams dataset to Hugging Face format with proper page numbering.

This script processes directories containing:
- image/ folder with JPG files
- alto/ folder with ALTO XML files
- METS XML files with page ordering information
- Creates one row per page with image, text, raw XML, and correct page numbers
"""

import argparse
import csv
import logging
import os
import re
import sys
import xml.etree.ElementTree as ET
from collections import defaultdict
from pathlib import Path
from typing import Optional, Dict, Tuple

from datasets import Dataset, Features, Value
from datasets import Image as HFImage
from tqdm import tqdm

# Set up logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)


def extract_base_number(filename: str) -> str:
    """Extract the base number from a filename (before first dot)."""
    return filename.split('.')[0]


def parse_mets_page_order(mets_path: Path) -> Dict[str, int]:
    """
    Parse METS XML file to extract page ordering information.
    
    Returns:
        Dictionary mapping file base numbers to page order numbers
    """
    page_order_map = {}
    
    try:
        tree = ET.parse(mets_path)
        root = tree.getroot()
        
        # Define namespaces
        ns = {
            'mets': 'http://www.loc.gov/METS/',
            'xlink': 'http://www.w3.org/1999/xlink'
        }
        
        # Find all div elements with ORDER attribute
        for div in root.findall('.//mets:div[@ORDER]', ns):
            order = div.get('ORDER')
            if order:
                # Find all file pointers in this div
                for fptr in div.findall('.//mets:fptr', ns):
                    file_id = fptr.get('FILEID')
                    if file_id and '.3' in file_id:  # Look for image files (.3.jpg)
                        # Extract base number from file ID
                        base_num = file_id.split('.')[0].replace('file_', '')
                        page_order_map[base_num] = int(order)
        
        logger.debug(f"Extracted page order for {len(page_order_map)} pages from METS")
        
    except Exception as e:
        logger.warning(f"Error parsing METS file {mets_path}: {e}")
    
    return page_order_map


def extract_exam_info_from_metadata(metadata: str) -> Dict[str, str]:
    """
    Extract exam information from metadata string.
    
    Example: "Leaving Certificate - 1888 - P.P.1888 XLI"
    Returns: {"exam_type": "Leaving Certificate", "year": "1888", "reference": "P.P.1888 XLI"}
    """
    info = {
        "exam_type": "",
        "year": "",
        "reference": ""
    }
    
    if not metadata:
        return info
    
    # Try to extract year (4 digits)
    year_match = re.search(r'\b(18\d{2}|19\d{2}|20\d{2})\b', metadata)
    if year_match:
        info["year"] = year_match.group(1)
    
    # Extract exam type (everything before the first dash)
    parts = metadata.split(' - ')
    if parts:
        info["exam_type"] = parts[0].strip()
    
    # Extract reference (usually after the last dash)
    if len(parts) >= 3:
        info["reference"] = parts[2].strip()
    
    return info


def parse_inventory_csv(root_dir: Path) -> dict[str, str]:
    """
    Parse inventory CSV file if it exists in the dataset directory.
    
    Returns:
        Dictionary mapping document_id to metadata description
    """
    inventory_pattern = "*-inventory.csv"
    inventory_files = list(root_dir.glob(inventory_pattern))

    if not inventory_files:
        logger.info("No inventory CSV file found")
        return {}

    if len(inventory_files) > 1:
        logger.warning(f"Multiple inventory files found: {inventory_files}. Using first one.")

    inventory_file = inventory_files[0]
    logger.info(f"Reading inventory from: {inventory_file}")

    metadata_map = {}

    try:
        # Use utf-8-sig to handle BOM if present
        with open(inventory_file, encoding='utf-8-sig') as f:
            reader = csv.reader(f)
            for row_num, row in enumerate(reader, 1):
                if len(row) >= 2:
                    doc_id = row[0].strip()
                    description = row[1].strip()
                    metadata_map[doc_id] = description
                else:
                    logger.warning(f"Skipping malformed row {row_num} in {inventory_file}: {row}")

    except Exception as e:
        logger.error(f"Error reading inventory CSV: {e}")
        return {}

    logger.info(f"Loaded metadata for {len(metadata_map)} documents from inventory")
    return metadata_map


def extract_text_from_alto(alto_path: Path) -> tuple[str, str]:
    """
    Extract text content from an ALTO XML file.
    
    Returns:
        Tuple of (extracted_text, raw_xml)
    """
    try:
        with open(alto_path, encoding='utf-8') as f:
            raw_xml = f.read()

        # Parse XML
        root = ET.fromstring(raw_xml)

        # Find all String elements (they contain the actual text)
        # ALTO namespace
        ns = {'alto': 'http://www.loc.gov/standards/alto/v3/alto.xsd'}

        # Extract text from all String elements
        text_parts = []

        # Find all TextLine elements
        for textline in root.findall('.//alto:TextLine', ns):
            line_parts = []

            # Get all String elements in this line
            for string_elem in textline.findall('./alto:String', ns):
                content = string_elem.get('CONTENT', '')
                if content:
                    line_parts.append(content)

            # Join words in the line with spaces
            if line_parts:
                text_parts.append(' '.join(line_parts))

        # Join lines with newlines
        extracted_text = '\n'.join(text_parts)

        return extracted_text, raw_xml

    except Exception as e:
        logger.warning(f"Error processing ALTO file {alto_path}: {e}")
        return "", ""


def process_document_folder(doc_path: Path, metadata_map: dict[str, str] = None) -> list[dict]:
    """
    Process a single document folder and return list of page records.
    
    Args:
        doc_path: Path to document folder
        metadata_map: Optional dictionary mapping document_id to metadata
    """
    records = []
    doc_id = doc_path.name
    doc_metadata = metadata_map.get(doc_id, None) if metadata_map else None
    
    # Extract exam information from metadata
    exam_info = extract_exam_info_from_metadata(doc_metadata)

    image_dir = doc_path / "image"
    alto_dir = doc_path / "alto"
    mets_file = doc_path / f"{doc_id}-mets.xml"

    if not image_dir.exists() or not alto_dir.exists():
        logger.warning(f"Skipping {doc_path}: missing image or alto directory")
        return records

    # Parse METS file to get page ordering
    page_order_map = {}
    if mets_file.exists():
        page_order_map = parse_mets_page_order(mets_file)
    else:
        logger.warning(f"No METS file found for {doc_id}, using filename sorting for page order")

    # Get all image files
    image_files = {f for f in os.listdir(image_dir)
                   if f.lower().endswith(('.jpg', '.jpeg', '.png', '.tiff', '.tif'))}

    # Get all ALTO files
    alto_files = {f for f in os.listdir(alto_dir) if f.endswith('.xml')}

    # Create mapping from base number to files
    image_map = {extract_base_number(f): f for f in image_files}
    alto_map = {extract_base_number(f): f for f in alto_files}

    # Get all unique page numbers
    all_pages = set(image_map.keys()) | set(alto_map.keys())

    # If no METS page order, create sequential numbering
    if not page_order_map:
        sorted_pages = sorted(all_pages)
        page_order_map = {page: idx + 1 for idx, page in enumerate(sorted_pages)}

    # Process each page
    for page_base in sorted(all_pages, key=lambda x: page_order_map.get(x, 999999)):
        actual_page_number = page_order_map.get(page_base, 0)
        
        record = {
            'document_id': doc_path.name,
            'page_number': actual_page_number,
            'file_identifier': page_base,
            'image_path': None,
            'alto_xml': None,
            'text': None,
            'has_image': False,
            'has_alto': False,
            'document_metadata': doc_metadata,
            'has_metadata': doc_metadata is not None,
            'exam_type': exam_info['exam_type'],
            'exam_year': exam_info['year'],
            'exam_reference': exam_info['reference']
        }

        # Check for image
        if page_base in image_map:
            image_path = image_dir / image_map[page_base]
            if image_path.exists():
                record['image_path'] = str(image_path)
                record['has_image'] = True

        # Check for ALTO
        if page_base in alto_map:
            alto_path = alto_dir / alto_map[page_base]
            if alto_path.exists():
                text, xml = extract_text_from_alto(alto_path)
                record['alto_xml'] = xml
                record['text'] = text
                record['has_alto'] = True

        records.append(record)

    return records


def process_dataset(root_dir: Path, max_docs: Optional[int] = None,
                   include_metadata: bool = True) -> list[dict]:
    """
    Process entire dataset directory.
    
    Args:
        root_dir: Root directory of dataset
        max_docs: Maximum number of documents to process
        include_metadata: Whether to include metadata from inventory CSV
    """
    all_records = []

    # Parse inventory CSV if requested
    metadata_map = {}
    if include_metadata:
        metadata_map = parse_inventory_csv(root_dir)

    # Find all document directories
    doc_dirs = [d for d in root_dir.iterdir()
                if d.is_dir() and not d.name.startswith('.') 
                and d.name not in ['__pycache__']]

    if max_docs:
        doc_dirs = doc_dirs[:max_docs]

    logger.info(f"Processing {len(doc_dirs)} document directories...")

    # Process each document
    for doc_dir in tqdm(doc_dirs, desc="Processing documents"):
        records = process_document_folder(doc_dir, metadata_map)
        all_records.extend(records)

    return all_records


def create_huggingface_dataset(records: list[dict], include_missing: bool = True) -> Dataset:
    """
    Create a Hugging Face dataset from records.
    
    Args:
        records: List of page records
        include_missing: If False, only include pages with both image and ALTO
    """
    # Filter records if needed
    if not include_missing:
        records = [r for r in records if r['has_image'] and r['has_alto']]
        logger.info(f"Filtered to {len(records)} records with both image and ALTO")

    # Prepare data for HF dataset
    dataset_dict = defaultdict(list)

    for record in records:
        dataset_dict['document_id'].append(record['document_id'])
        dataset_dict['page_number'].append(record['page_number'])
        dataset_dict['file_identifier'].append(record['file_identifier'])

        # Store image path instead of loading image
        # HuggingFace datasets will handle loading when needed
        if record['has_image'] and record['image_path']:
            dataset_dict['image'].append(record['image_path'])
        else:
            dataset_dict['image'].append(None)

        dataset_dict['text'].append(record['text'] or "")
        dataset_dict['alto_xml'].append(record['alto_xml'] or "")
        dataset_dict['has_image'].append(record['has_image'])
        dataset_dict['has_alto'].append(record['has_alto'])
        dataset_dict['document_metadata'].append(record.get('document_metadata') or "")
        dataset_dict['has_metadata'].append(record.get('has_metadata', False))
        dataset_dict['exam_type'].append(record.get('exam_type', ''))
        dataset_dict['exam_year'].append(record.get('exam_year', ''))
        dataset_dict['exam_reference'].append(record.get('exam_reference', ''))

    # Create HF dataset
    features = Features({
        'document_id': Value('string'),
        'page_number': Value('int32'),
        'file_identifier': Value('string'),
        'image': HFImage(),
        'text': Value('string'),
        'alto_xml': Value('string'),
        'has_image': Value('bool'),
        'has_alto': Value('bool'),
        'document_metadata': Value('string'),
        'has_metadata': Value('bool'),
        'exam_type': Value('string'),
        'exam_year': Value('string'),
        'exam_reference': Value('string')
    })

    dataset = Dataset.from_dict(dict(dataset_dict), features=features)

    return dataset


def print_statistics(records: list[dict]):
    """Print statistics about the processed dataset."""
    total = len(records)
    with_both = sum(1 for r in records if r['has_image'] and r['has_alto'])
    image_only = sum(1 for r in records if r['has_image'] and not r['has_alto'])
    alto_only = sum(1 for r in records if not r['has_image'] and r['has_alto'])
    with_metadata = sum(1 for r in records if r.get('has_metadata', False))

    print("\n=== Dataset Statistics ===")
    print(f"Total pages: {total:,}")
    print(f"Pages with both image and ALTO: {with_both:,} ({with_both/total*100:.1f}%)")
    print(f"Pages with image only: {image_only:,} ({image_only/total*100:.1f}%)")
    print(f"Pages with ALTO only: {alto_only:,} ({alto_only/total*100:.1f}%)")
    if with_metadata > 0:
        print(f"Pages with metadata: {with_metadata:,} ({with_metadata/total*100:.1f}%)")

    # Document statistics
    docs = defaultdict(lambda: {'pages': 0, 'complete': 0, 'has_metadata': False})
    for r in records:
        docs[r['document_id']]['pages'] += 1
        if r['has_image'] and r['has_alto']:
            docs[r['document_id']]['complete'] += 1
        if r.get('has_metadata', False):
            docs[r['document_id']]['has_metadata'] = True

    print(f"\nTotal documents: {len(docs)}")
    complete_docs = sum(1 for d in docs.values() if d['pages'] == d['complete'])
    print(f"Documents with all pages complete: {complete_docs} "
          f"({complete_docs/len(docs)*100:.1f}%)")

    docs_with_metadata = sum(1 for d in docs.values() if d['has_metadata'])
    if docs_with_metadata > 0:
        print(f"Documents with metadata: {docs_with_metadata} "
              f"({docs_with_metadata/len(docs)*100:.1f}%)")
    
    # Year distribution
    years = defaultdict(int)
    for r in records:
        year = r.get('exam_year', '')
        if year:
            years[year] += 1
    
    if years:
        print("\n=== Exam Years Distribution ===")
        for year in sorted(years.keys()):
            print(f"{year}: {years[year]} pages")


def main():
    parser = argparse.ArgumentParser(description='Convert NLS Scottish Exams dataset to Hugging Face format')
    parser.add_argument('input_dir', type=str, help='Path to dataset directory')
    parser.add_argument('output_path', type=str, help='Output path for HF dataset')
    parser.add_argument('--max-docs', type=int, help='Maximum number of documents to process')
    parser.add_argument('--include-missing', action='store_true',
                       help='Include pages with missing image or ALTO')
    parser.add_argument('--format', choices=['parquet', 'json', 'csv'],
                       default='parquet', help='Output format')
    parser.add_argument('--push-to-hub', action='store_true',
                       help='Push dataset to Hugging Face Hub')
    parser.add_argument('--repo-id', type=str,
                       help='Repository ID on Hugging Face Hub (e.g., username/dataset-name)')
    parser.add_argument('--private', action='store_true',
                       help='Make the dataset private on Hugging Face Hub')
    parser.add_argument('--include-metadata', type=str, default='true',
                       choices=['true', 'false'],
                       help='Include metadata from inventory CSV if available (default: true)')

    args = parser.parse_args()

    # Validate arguments
    if args.push_to_hub and not args.repo_id:
        logger.error("--repo-id is required when using --push-to-hub")
        sys.exit(1)

    input_path = Path(args.input_dir)
    if not input_path.exists():
        logger.error(f"Input directory does not exist: {input_path}")
        sys.exit(1)

    # Convert string boolean to actual boolean
    include_metadata = args.include_metadata.lower() == 'true'

    # Process dataset
    logger.info(f"Processing dataset from {input_path}")
    records = process_dataset(input_path, args.max_docs, include_metadata)

    if not records:
        logger.error("No records found!")
        sys.exit(1)

    # Print statistics
    print_statistics(records)

    # Create HF dataset
    logger.info("Creating Hugging Face dataset...")
    dataset = create_huggingface_dataset(records, include_missing=args.include_missing)

    # Save dataset locally
    logger.info(f"Saving dataset to {args.output_path}")
    if args.format == 'parquet':
        dataset.to_parquet(args.output_path)
    elif args.format == 'json':
        dataset.to_json(args.output_path)
    elif args.format == 'csv':
        dataset.to_csv(args.output_path)

    logger.info(f"Dataset saved successfully! Total rows: {len(dataset)}")

    # Push to Hugging Face Hub if requested
    if args.push_to_hub:
        logger.info(f"Pushing dataset to Hugging Face Hub: {args.repo_id}")
        try:
            dataset.push_to_hub(
                repo_id=args.repo_id,
                private=args.private,
                commit_message=f"Add NLS Scottish Exams dataset with {len(dataset)} pages"
            )
            logger.info(f"Dataset successfully pushed to https://huggingface.co/datasets/{args.repo_id}")
        except Exception as e:
            logger.error(f"Failed to push to Hub: {e}")
            logger.info("Make sure you're logged in with 'huggingface-cli login'")
            sys.exit(1)


if __name__ == "__main__":
    main()