Create app.py

app.py

@@ -0,0 +1,340 @@
+# app.py
+# Gradio web app for Hugging Face Spaces: Bloom's Taxonomy Classifier, Generator, and Rewriter
+# No external model downloads; purely rule-based and reproducible.
+
+import re
+import random
+from typing import Dict, List, Tuple
+
+import gradio as gr
+
+BLOOMS_LEVELS = [
+    "Remember",
+    "Understand",
+    "Apply",
+    "Analyze",
+    "Evaluate",
+    "Create",
+]
+
+# Seed for reproducibility across runs
+random.seed(42)
+
+# ---- Heuristic resources -----------------------------------------------------
+
+VERBS = {
+    "Remember": [
+        "define", "list", "name", "recall", "state", "identify", "label",
+        "match", "enumerate", "select", "recognize", "who", "what", "when",
+    ],
+    "Understand": [
+        "explain", "describe", "summarize", "paraphrase", "interpret", "classify",
+        "outline", "illustrate", "give an example", "why", "how does", "compare (basic)",
+    ],
+    "Apply": [
+        "apply", "use", "compute", "calculate", "solve", "demonstrate", "implement",
+        "show how", "execute", "perform",
+    ],
+    "Analyze": [
+        "analyze", "compare", "contrast", "differentiate", "examine", "categorize",
+        "diagram", "break down", "distinguish", "investigate", "what is the relationship",
+        "cause", "effect", "why (multi-part)",
+    ],
+    "Evaluate": [
+        "evaluate", "argue", "assess", "justify", "critique", "defend", "appraise",
+        "prioritize", "recommend", "debate", "which is better", "to what extent",
+    ],
+    "Create": [
+        "create", "design", "develop", "compose", "formulate", "invent", "propose",
+        "construct", "devise", "generate", "plan", "produce", "draft",
+    ],
+}
+
+# Templates to generate or rewrite questions by Bloom level.
+TEMPLATES = {
+    "Remember": [
+        "Define {topic}.",
+        "List three key facts about {topic}.",
+        "Identify the primary purpose of {topic}.",
+        "State the meaning of {topic} in one sentence.",
+        "Name two examples related to {topic}.",
+    ],
+    "Understand": [
+        "Explain {topic} in your own words.",
+        "Describe how {topic} works to a beginner.",
+        "Summarize the main idea behind {topic}.",
+        "Classify {topic} into an appropriate category and explain why.",
+        "Illustrate {topic} with a simple, concrete example.",
+    ],
+    "Apply": [
+        "Apply {topic} to solve a real-world problem; show the steps.",
+        "Use {topic} to compute the result for this scenario: [add numbers/conditions].",
+        "Demonstrate {topic} on a new example you devise.",
+        "Solve a practical case where {topic} is required; justify each step.",
+        "Implement a basic procedure using {topic} and report the outcome.",
+    ],
+    "Analyze": [
+        "Compare and contrast {topic} with a closely related concept; highlight key differences.",
+        "Analyze the components of {topic} and explain how they interact.",
+        "Examine the causes and effects involved in {topic}.",
+        "Categorize elements of {topic} into meaningful groups and justify your grouping.",
+        "Break down {topic} into sub-problems and explain each part.",
+    ],
+    "Evaluate": [
+        "Evaluate the strengths and weaknesses of {topic}; provide criteria and evidence.",
+        "Argue for or against the use of {topic} in a specific context.",
+        "Assess the effectiveness of {topic} using clear metrics.",
+        "Justify a recommendation regarding {topic}, noting trade-offs.",
+        "Critique a common approach to {topic} and suggest improvements.",
+    ],
+    "Create": [
+        "Design a novel solution that uses {topic}; outline the key steps.",
+        "Develop a project plan that incorporates {topic} with milestones and deliverables.",
+        "Propose an original framework that extends {topic}.",
+        "Formulate a research question involving {topic} and sketch a method to investigate it.",
+        "Compose a scenario or case study that requires {topic} to resolve.",
+    ],
+}
+
+# Light penalties/bonuses to help disambiguate borderline levels
+STRUCTURE_HINTS = {
+    "Remember": ["define", "list", "identify", "name", "state"],
+    "Understand": ["explain", "describe", "summarize", "illustrate", "classify"],
+    "Apply": ["solve", "compute", "calculate", "apply", "use", "demonstrate"],
+    "Analyze": ["compare", "contrast", "analyze", "why", "cause", "effect", "break down"],
+    "Evaluate": ["evaluate", "assess", "justify", "which is better", "argue", "critique"],
+    "Create": ["design", "develop", "propose", "create", "formulate", "invent", "plan"],
+}
+
+def normalize(text: str) -> str:
+    return re.sub(r"\s+", " ", text.strip().lower())
+
+def score_levels(question: str) -> Dict[str, float]:
+    """Keyword scoring with mild normalization and overlap handling."""
+    q = normalize(question)
+    scores = {lvl: 0.0 for lvl in BLOOMS_LEVELS}
+    # Count verb hits (phrase -> weight)
+    for lvl, words in VERBS.items():
+        for w in words:
+            # phrase-aware search; word boundary for single words
+            if " " in w:
+                if w in q:
+                    scores[lvl] += 1.5
+            else:
+                # word-boundary with stemming-ish match for simple endings
+                if re.search(rf"\b{re.escape(w)}(e|ed|ing|s)?\b", q):
+                    scores[lvl] += 1.0
+
+    # Structural hints get a small bonus
+    for lvl, hints in STRUCTURE_HINTS.items():
+        for h in hints:
+            if h in q:
+                scores[lvl] += 0.25
+
+    # Heuristic nudges
+    # Longer, multi-part questions tend to be higher-order
+    tokens = len(q.split())
+    if tokens >= 25:
+        scores["Analyze"] += 0.3
+        scores["Evaluate"] += 0.3
+        scores["Create"] += 0.3
+
+    # Presence of "design", "propose", etc. strongly suggests Create
+    if any(k in q for k in ["design", "develop", "propose", "invent", "formulate", "plan"]):
+        scores["Create"] += 1.2
+
+    # Presence of justification language boosts Evaluate
+    if any(k in q for k in ["justify", "assess", "evaluate", "argue", "critique", "recommend"]):
+        scores["Evaluate"] += 1.2
+
+    # "compare/contrast" and "why" boost Analyze
+    if any(k in q for k in ["compare", "contrast", "analyze", "why", "cause", "effect"]):
+        scores["Analyze"] += 0.8
+
+    # Basic who/what/when/where—if no other signal—leans Remember/Understand
+    if re.search(r"\b(who|what|when|where)\b", q):
+        scores["Remember"] += 0.4
+        scores["Understand"] += 0.2
+
+    return scores
+
+def classify_question(question: str) -> Tuple[str, Dict[str, float], str]:
+    if not question or not question.strip():
+        return "", {}, "Please enter a question to classify."
+    scores = score_levels(question)
+    # pick max; tie-break by deeper levels if scores equal (to avoid under-classification)
+    best_level = max(BLOOMS_LEVELS, key=lambda lvl: (scores[lvl], BLOOMS_LEVELS.index(lvl)))
+    # Rationale: top 2 contributors
+    top = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:2]
+    rationale = "Top signals → " + ", ".join(f"{k}: {v:.2f}" for k, v in top)
+    return best_level, scores, rationale
+
+def extract_topic_from_question(q: str) -> str:
+    """Very lightweight topic guesser for rewrite; falls back to original content."""
+    text = normalize(q).rstrip("?.")
+
+    # Prefer phrases after 'about/on/of'
+    m = re.search(r"\b(?:about|on|of)\s+(.+)", text)
+    if m:
+        topic = m.group(1)
+        # trim trailing question cues
+        topic = re.sub(r"\b(why|how|what|when|where|who)\b.*$", "", topic).strip()
+        if topic:
+            return topic
+
+    # Remove leading command verbs
+    command_verbs = sum(VERBS.values(), [])
+    pattern = r"^(" + "|".join(re.escape(v) for v in sorted(set(command_verbs), key=len, reverse=True)) + r")\b"
+    text2 = re.sub(pattern, "", text).strip(",.:- ").strip()
+    if text2:
+        return text2
+
+    # Fallback: keep original question minus punctuation
+    return re.sub(r"[?.!]+$", "", q).strip()
+
+def generate_questions(topic: str, level: str, n: int) -> str:
+    topic = topic.strip()
+    if not topic:
+        return "Please provide a topic."
+    if level not in BLOOMS_LEVELS:
+        return "Please choose a valid Bloom’s level."
+    n = max(1, min(int(n), 20))  # keep it reasonable
+    templates = TEMPLATES[level][:]
+    out: List[str] = []
+    used: set = set()
+
+    # Slight variations to avoid duplicates: add extra cues or contexts
+    extras = [
+        "",
+        " Include one concrete example.",
+        " Keep your response concise.",
+        " Explain your reasoning.",
+        " Use no more than 3 sentences.",
+        " Include assumptions you make.",
+        " Relate this to a real-world case.",
+        " Provide step-by-step reasoning.",
+    ]
+
+    attempts = 0
+    while len(out) < n and attempts < n * 10:
+        attempts += 1
+        template = random.choice(templates)
+        extra = random.choice(extras)
+        q = (template.format(topic=topic) + extra).strip()
+        if q not in used:
+            used.add(q)
+            out.append(q)
+
+    # Ensure numbering and distinctness
+    lines = [f"{i+1}. {q}" for i, q in enumerate(out)]
+    return "\n".join(lines)
+
+def rewrite_question_to_level(question: str, new_level: str) -> str:
+    question = question.strip()
+    if not question:
+        return "Please paste a question to rewrite."
+    if new_level not in BLOOMS_LEVELS:
+        return "Please choose a valid Bloom’s level."
+
+    topic_guess = extract_topic_from_question(question)
+    # Select a template that best preserves meaning while switching the cognitive demand
+    # Prefer more general templates for rewrite
+    candidates = TEMPLATES[new_level]
+    # avoid extremely specific ones when the source already contains constraints
+    generic_first = sorted(candidates, key=lambda s: len(s))
+    template = generic_first[0] if generic_first else "{topic}"
+
+    rewritten = template.format(topic=topic_guess)
+    # Add helpful adaptation notes for higher levels
+    if new_level in ["Analyze", "Evaluate", "Create"]:
+        # Encourage depth without changing grading rubric here
+        rewritten += " Be explicit about your reasoning."
+
+    return rewritten
+
+# ---- Gradio UI ---------------------------------------------------------------
+
+EXAMPLES = [
+    ["What is photosynthesis and when does it occur?",],
+    ["Design a simple experiment to test the effect of sunlight on plant growth.",],
+    ["Compare and contrast arrays and linked lists.",],
+    ["Justify whether encryption should be mandatory on consumer devices.",],
+]
+
+with gr.Blocks(title="Bloom's Taxonomy Helper", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # Bloom’s Taxonomy Helper
+        A compact tool to **classify**, **generate**, and **rewrite** exam questions by Bloom’s level:
+        **Remember · Understand · Apply · Analyze · Evaluate · Create**
+        """
+    )
+
+    with gr.Tabs():
+        # --- Tab 1: Classify ---------------------------------------------------
+        with gr.TabItem("Classify"):
+            gr.Markdown("### Paste or type a question. I’ll guess its Bloom’s level.")
+            q_in = gr.Textbox(label="Question", placeholder="e.g., Compare and contrast stack and queue operations.", lines=3)
+            classify_btn = gr.Button("Classify")
+            level_out = gr.Label(label="Predicted Bloom’s level")
+            scores_out = gr.JSON(label="Scores by level (higher = stronger signal)")
+            rationale_out = gr.Markdown()
+
+            def on_classify(q):
+                lvl, scores, rationale = classify_question(q)
+                # Format Label expects mapping; we provide {'label': score}
+                if lvl:
+                    return {lvl: 1.0}, scores, f"**Rationale:** {rationale}"
+                else:
+                    return {}, {}, rationale
+
+            classify_btn.click(on_classify, inputs=[q_in], outputs=[level_out, scores_out, rationale_out])
+
+            gr.Examples(
+                examples=EXAMPLES,
+                inputs=[q_in],
+                label="Try examples",
+            )
+
+        # --- Tab 2: Generate ---------------------------------------------------
+        with gr.TabItem("Generate"):
+            gr.Markdown("### Enter a topic, choose a Bloom’s level, and how many questions to create.")
+            topic_in = gr.Textbox(label="Topic", placeholder="e.g., Dynamic programming, photosynthesis, supply and demand", lines=2)
+            level_in = gr.Dropdown(choices=BLOOMS_LEVELS, value="Understand", label="Bloom’s level")
+            num_in = gr.Slider(1, 20, value=5, step=1, label="Number of questions")
+            gen_btn = gr.Button("Generate")
+            gen_out = gr.Textbox(label="Generated Questions", lines=12)
+
+            gen_btn.click(
+                fn=lambda topic, level, n: generate_questions(topic, level, int(n)),
+                inputs=[topic_in, level_in, num_in],
+                outputs=[gen_out],
+            )
+
+        # --- Tab 3: Rewrite ----------------------------------------------------
+        with gr.TabItem("Rewrite"):
+            gr.Markdown("### Paste a question and choose a new Bloom’s level. I’ll rewrite it for that cognitive level.")
+            rewrite_in = gr.Textbox(label="Original Question", placeholder="e.g., List the steps of cellular respiration.", lines=3)
+            rewrite_level = gr.Dropdown(choices=BLOOMS_LEVELS, value="Analyze", label="Target Bloom’s level")
+            rewrite_btn = gr.Button("Rewrite")
+            rewrite_out = gr.Textbox(label="Rewritten Question", lines=5)
+
+            rewrite_btn.click(
+                fn=rewrite_question_to_level,
+                inputs=[rewrite_in, rewrite_level],
+                outputs=[rewrite_out],
+            )
+
+    gr.Markdown(
+        """
+        ---
+        **Notes**
+        - This app uses lightweight heuristics (keyword signals and structure cues) rather than a trained model.
+        - Generation ensures questions are distinct and clearly numbered.
+        - Rewriting keeps the topic while shifting cognitive demand to the selected Bloom’s level.
+        """
+    )
+
+if __name__ == "__main__":
+    # For local testing; on Spaces you don't need to set server params explicitly.
+    demo.launch()