first commit

.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

.python-version

@@ -0,0 +1 @@
+3.11

app.py

@@ -0,0 +1,178 @@
+import os
+
+import gradio as gr
+from datasets import load_dataset, Dataset
+from huggingface_hub import whoami
+
+
+EXAM_DATASET_ID = os.getenv("EXAM_DATASET_ID") or "burtenshaw/exam_questions"
+
+ds = load_dataset(EXAM_DATASET_ID, split="train")
+
+# Convert dataset to a list of dicts so we can iterate similarly to quiz_data
+quiz_data = ds.to_pandas().to_dict("records")  # or use a for-loop if you prefer
+
+
+def on_user_logged_in(token: gr.OAuthToken | None):
+    """
+    If the user has a valid token, hide the login button and show the Start button.
+    Otherwise, keep the login button visible, hide Start.
+    """
+    if token is not None:
+        return gr.update(visible=False), gr.update(visible=True)
+    else:
+        # Not logged in, keep the login visible, hide Start
+        return gr.update(visible=True), gr.update(visible=False)
+
+
+def push_results_to_hub(user_answers, token: gr.OAuthToken | None):
+    """
+    Create a new dataset from user_answers and push it to the Hub.
+    We use the user's HF token to determine the correct repo.
+    If no one is logged in, we'll return an error message.
+    """
+    if token is None:
+        gr.Warning("Please log in to Hugging Face before pushing!")
+        return
+    else:
+        gr.Info("Submitting answers to the Hub. Please wait...", duration=2)
+    user_info = whoami(token=token.token)
+    repo_id = f"{user_info['name']}/quiz-responses"  # e.g. 'myUsername/quiz-responses'
+
+    new_ds = Dataset.from_list(user_answers)
+    new_ds.push_to_hub(repo_id)
+    gr.Success("Your responses have been submitted to the Hub!")
+
+
+def handle_quiz(question_idx, user_answers, selected_answer, is_start):
+    """
+    A single function that handles both 'Start' and 'Next' logic:
+      - If is_start=True, skip storing an answer and show the first question.
+      - Otherwise, store the last answer and move on.
+      - If we've reached the end, display results.
+    """
+    # Hide the start button once the first question is shown
+    start_btn_update = gr.update(visible=False) if is_start else None
+
+    # If this is the first time (start=True), begin at question_idx=0
+    if is_start:
+        question_idx = 0
+    else:
+        # If not the very first question, store the user's last selection
+        if question_idx < len(quiz_data):
+            current_q = quiz_data[question_idx]
+            user_answers.append(
+                {"question": current_q["question"], "selected_answer": selected_answer}
+            )
+        question_idx += 1
+
+    # If we've reached the end, show final results
+    if question_idx >= len(quiz_data):
+        final_text = f"**All questions answered!**\n\nHere are your selections:\n\n{user_answers}"
+        return (
+            "",  # question_text becomes blank
+            gr.update(choices=[], visible=False),
+            "",  # status_text (can clear or reuse)
+            question_idx,
+            user_answers,
+            start_btn_update,
+            gr.update(value=final_text, visible=True),  # show final_markdown
+        )
+    else:
+        # Otherwise, show the next question
+        q = quiz_data[question_idx]
+        updated_question = f"## **Question {question_idx + 1}**: {q['question']}"
+        return (
+            updated_question,
+            gr.update(
+                choices=[
+                    q["answer_a"],
+                    q["answer_b"],
+                    q["answer_c"],
+                    q["answer_d"],
+                ],
+                value=None,
+                visible=True,
+            ),
+            "Select an answer and click 'Next' to continue.",
+            question_idx,
+            user_answers,
+            start_btn_update,
+            gr.update(visible=False),  # Hide final_markdown for now
+        )
+
+
+def success_message(response):
+    # response is whatever push_results_to_hub returned
+    return f"{response}\n\n**Success!**"
+
+
+with gr.Blocks() as demo:
+    demo.title = f"Dataset Quiz for {EXAM_DATASET_ID}"
+
+    # Header
+    gr.Markdown(f"## Welcome to the {EXAM_DATASET_ID} Quiz")
+    gr.Markdown(
+        "Log in first, then click 'Start' to begin. Answer each question, click 'Next', and finally click 'Submit' to publish your results to the Hugging Face Hub."
+    )
+
+    # Step 1: Login
+    login_btn = gr.LoginButton()
+    # We'll hide the Start button until user logs in
+    start_btn = gr.Button("Start", visible=False)
+
+    # State variables
+    question_idx = gr.State(value=0)
+    user_answers = gr.State(value=[])
+
+    # We display question text with Markdown
+    question_text = gr.Markdown("")
+    status_text = gr.Markdown("")
+    radio_choices = gr.Radio(label="Your Answer", choices=[], visible=False)
+
+    # Final results after all questions are done
+    final_markdown = gr.Markdown("", visible=False)
+
+    next_btn = gr.Button("Next")
+    submit_btn = gr.Button("Submit")
+
+    # Use click() instead of login()
+    login_btn.click(fn=on_user_logged_in, inputs=None, outputs=[login_btn, start_btn])
+
+    # Click "Start" => show first question, hide Start button
+    start_btn.click(
+        fn=handle_quiz,
+        inputs=[question_idx, user_answers, radio_choices, gr.State(True)],
+        outputs=[
+            question_text,
+            radio_choices,
+            status_text,
+            question_idx,
+            user_answers,
+            start_btn,
+            final_markdown,
+        ],
+    )
+
+    # Click "Next" => store selection, move on
+    next_btn.click(
+        fn=handle_quiz,
+        inputs=[question_idx, user_answers, radio_choices, gr.State(False)],
+        outputs=[
+            question_text,
+            radio_choices,
+            status_text,
+            question_idx,
+            user_answers,
+            start_btn,
+            final_markdown,
+        ],
+    )
+
+    submit_btn.click(fn=push_results_to_hub, inputs=[user_answers])
+
+
+if __name__ == "__main__":
+    # Note: If testing locally, you'll need to run `huggingface-cli login` or set HF_TOKEN
+    # environment variable for the login to work locally.
+    demo.launch()

example.json

@@ -0,0 +1,82 @@
+[
+    {
+        "question": "Which of the following best describes a Large Language Model (LLM)?",
+        "answer_a": "A model specializing in language recognition",
+        "answer_b": "A massive neural network that understands and generates human language",
+        "answer_c": "A model exclusively used for language data tasks like summarization or classification",
+        "answer_d": "A rule-based chatbot used for conversations",
+        "correct_answer": "B"
+    },
+    {
+        "question": "LLMs are typically:",
+        "answer_a": "Pre-trained on small, curated datasets",
+        "answer_b": "Trained on large text corpora to capture linguistic patterns",
+        "answer_c": "Trained purely on translation tasks",
+        "answer_d": "Designed to function solely with GPU resources",
+        "correct_answer": "B"
+    },
+    {
+        "question": "Which of the following is a common architecture for LLMs?",
+        "answer_a": "Convolutional Neural Networks (CNNs)",
+        "answer_b": "Transformer",
+        "answer_c": "Recurrent Neural Networks (RNNs) with LSTM",
+        "answer_d": "Support Vector Machines",
+        "correct_answer": "B"
+    },
+    {
+        "question": "What does it mean when we say LLMs are \"autoregressive\"?",
+        "answer_a": "They regress to the mean to reduce variance",
+        "answer_b": "They generate text by predicting the next token based on previous tokens",
+        "answer_c": "They can only handle labeled data",
+        "answer_d": "They can output text only after the entire input is known at once",
+        "correct_answer": "B"
+    },
+    {
+        "question": "Which of these is NOT a common use of LLMs?",
+        "answer_a": "Summarizing content",
+        "answer_b": "Generating code",
+        "answer_c": "Playing strategy games like chess or Go",
+        "answer_d": "Conversational AI",
+        "correct_answer": "C"
+    },
+    {
+        "question": "Which of the following best describes a \"special token\"?",
+        "answer_a": "A token that makes the model forget all context",
+        "answer_b": "A model signature required for API calls",
+        "answer_c": "A token that helps segment or structure the conversation in the model",
+        "answer_d": "A token that always represents the end of text",
+        "correct_answer": "C"
+    },
+    {
+        "question": "What is the primary goal of a \"chat template\"?",
+        "answer_a": "To force the model into a single-turn conversation",
+        "answer_b": "To structure interactions and define roles in a conversation",
+        "answer_c": "To replace the need for system messages",
+        "answer_d": "To store prompts into the model's weights permanently",
+        "correct_answer": "B"
+    },
+    {
+        "question": "How do tokenizers handle text for modern NLP models?",
+        "answer_a": "By splitting text into individual words only",
+        "answer_b": "By breaking words into subword units and assigning numerical IDs",
+        "answer_c": "By storing text directly without transformation",
+        "answer_d": "By removing all punctuation automatically",
+        "correct_answer": "B"
+    },
+    {
+        "question": "Which role in a conversation sets the overall behavior for a model?",
+        "answer_a": "user",
+        "answer_b": "system",
+        "answer_c": "assistant",
+        "answer_d": "developer",
+        "correct_answer": "B"
+    },
+    {
+        "question": "Which statement is TRUE about tool usage in chat templates?",
+        "answer_a": "Tools cannot be used within the conversation context.",
+        "answer_b": "Tools are used only for logging messages.",
+        "answer_c": "Tools allow the assistant to offload tasks like web search or calculations.",
+        "answer_d": "Tools are unsupported in all modern LLMs.",
+        "correct_answer": "C"
+    }
+]

pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "quiz-app"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "datasets>=3.2.0",
+    "gradio[oauth]>=5.13.1",
+    "huggingface-hub>=0.27.1",
+    "ipykernel>=6.29.5",
+]