mathPix to moodle.sty

import re

def read_text_file(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        content = file.read()
    return content

txt = read_text_file("mwe/q-shortanswer-media.txt")
print(txt)

def remove_rationale(text):
    # This pattern looks for '\section*{Rationale}' and removes everything until the next '\section*{' or end of string
    text = re.sub(r'\\section\*\{Rationale\}.*?(?=\\section\*|\Z)', '', text, flags=re.DOTALL)
    return text

txt = remove_rationale(txt)
print(txt)

def fetch_correct_answer(text):
    # Find the correct answer, allowing for negative signs in the answer
    match = re.search(r'Correct Answer:\s*(-?\d+)', text)
    return match.group(1) if match else None

ans = fetch_correct_answer(txt)
print(ans)

def fetch_question_id(text):
    # Find the question ID
    match = re.search(r'\\section\*\{\s*Question ID\s+(\w+)\s*\}', text)
    return match.group(1) if match else None

q_id = fetch_question_id(txt)
print(q_id)

def fetch_question_body(text, question_id):
    # Pattern to capture everything between \section*{ID: <question-id>} and the start of choices (A., B., C., or D.)
    pattern = rf'\\section\*\{{ID: {question_id}\}}\s*(.*?)(?=\s*[A-D]\.\s|\s*\\section\*\{{ID: {question_id} Answer\}})'
    match = re.search(pattern, text, flags=re.DOTALL)
    if match:
        return match.group(1).strip()
    return None

q_body = fetch_question_body(txt, q_id)
print(q_body)

def determine_question_type(answer):
    # Determine if the question is a short answer or multiple-choice based on the answer format
    if re.match(r'^-?\d+$|^-?\d+/\d+$', answer):  # Checks if answer is a number (including negative) or fraction
        return "shortanswer"
    elif re.match(r'^[A-D]$', answer):  # Checks if answer is A, B, C, or D
        return "multi"
    return None

q_type = determine_question_type(ans)
print(q_type)

def format_shortanswer(question_id, question_body, answer):
    # Format short answer question
    formatted = f"""\\begin[fraction=100]}
{question_body}
\\item[fraction=100] {answer}
\\end"""
    return formatted

#q = format_shortanswer(q_id, q_body, ans)
#print(q)

def extract_choices(text):
    # Extract choices while handling multiline content after each label (A., B., C., D.)
    choices = []
    pattern = r'([A-D]\.\s.*?)(?=\s*[A-D]\.|\\section\*\{ID:|$)'  # Match choices A., B., C., D.
    matches = re.findall(pattern, text, flags=re.DOTALL)
    
    for match in matches:
        # Normalize line breaks and strip leading/trailing whitespace
        choices.append(match.replace('\n', ' ').strip())
        
    # Remove the choice labels (A., B., C., D.) from each extracted choice
    choices = [choice[2:].strip() for choice in choices]  # Removes label (e.g., "A. " to keep just the choice)
    
    return choices if choices else None

q_choices = extract_choices(txt)
print(q_choices) ## returns none, as the question is short-answer.

def format_multi(question_id, question_body, answer, choices):
    # Map answer to corresponding choice and format multiple-choice question
    if len(answer) == 1:
        answer_index = ord(answer) - ord('A')
        items = [f"\\item * {choice}" if i == answer_index else f"\\item {choice}" for i, choice in enumerate(choices)]
        formatted_items = "\n".join(items)
        formatted = f"""\\begin}
    {question_body}

    {formatted_items}
    \\end"""
    else:
        formatted = "None"
    return formatted

q = format_multi(q_id, q_body, ans, q_choices)
print(q) ## returns none, as the question is short-answer.

# Main function to orchestrate parsing and formatting
def parse_question(text):
    text = remove_rationale(text)
    
    question_id = fetch_question_id(text)
    answer = fetch_correct_answer(text)
    question_body = fetch_question_body(text, question_id)
    
    if not all([question_id, answer, question_body]):
        return "Error: Unable to parse question properly."

    question_type = determine_question_type(answer)
    if question_type == "shortanswer":
        return format_shortanswer(question_id, question_body, answer)
    elif question_type == "multi":
        choices = extract_choices(text)
        if choices and len(choices) == 4:
            return format_multi(question_id, question_body, answer, choices)
        else:
            return "Error: Multiple-choice question lacks choices or has an incorrect format."
    else:
        return "Error: Unknown question type or unrecognized answer format."

q = parse_question(txt)
print(q)