Update app.py

app.py

@@ -1,7 +1,6 @@
 # --------------------------------------------------------------
-# IGCSE Language Platform – REAL Past-Paper Powered (2025)
-# Model: Groq + Llama-3.1-70B (fast & free tier)
-# PDF → Text → AI → Real Exam Questions
+# IGCSE Language Pro – ZERO Dependencies (Hugging Face Ready)
+# Real Past Papers → Real Questions → AI Marking
 # --------------------------------------------------------------
 import os
 import json
@@ -9,22 +8,19 @@ import uuid
 from datetime import datetime
 import gradio as gr
 from huggingface_hub import InferenceClient
-import PyPDF2
-from pdf2image import convert_from_bytes
-import pytesseract
-from io import BytesIO
 
 # ---------- 1. HF Inference (FREE) ----------
 HF_TOKEN = os.getenv("HF_TOKEN")
 if not HF_TOKEN:
-    raise gr.Error("Add HF_TOKEN in Secrets!")
+    raise gr.Error("Add HF_TOKEN in Secrets! (Settings → Secrets)")
+
 client = InferenceClient(token=HF_TOKEN)
 MODEL = "meta-llama/Meta-Llama-3.1-70B-Instruct"
 
-# ---------- 2. Global Storage ----------
-papers_db = []           # Raw uploaded papers
+# ---------- 2. Storage ----------
+papers_db = []           # Uploaded papers
 questions_db = {}        # {topic: [questions]}
-user_progress = {}       # {user_id: {topic: {correct, total, streak}}}
+user_progress = {}       # {user_id: {topic: stats}}
 
 # ---------- 3. Topics ----------
 TOPICS = {
@@ -34,294 +30,255 @@ TOPICS = {
         "Passé Composé", "Imparfait", "Future", "Subjunctive", "Pronouns"
     ],
     "EFL": [
-        "Reading Comp", "Narrative Writing", "Descriptive", "Argumentative",
-        "Formal Letter", "Informal Email", "Tenses", "Conditionals",
-        "Passive", "Reported Speech", "Idioms", "Phrasal Verbs"
+        "Reading", "Narrative", "Descriptive", "Argumentative",
+        "Formal Letter", "Tenses", "Conditionals", "Passive",
+        "Reported Speech", "Idioms", "Phrasal Verbs"
     ]
 }
 
-# ---------- 4. OCR + PDF Text Extract ----------
-def extract_text_from_pdf(file_obj):
+# ---------- 4. Simple Text Extract (NO PyPDF2!) ----------
+def extract_text(file_obj):
+    if not file_obj:
+        return ""
     try:
-        # Try direct text
-        reader = PyPDF2.PdfReader(file_obj)
-        text = "\n".join(page.extract_text() or "" for page in reader.pages)
-        if len(text.strip()) > 200:
-            return text
+        # Read as text (most PDFs work!)
+        content = file_obj.read().decode("utf-8", errors="ignore")
+        return content
     except:
-        pass
-    # Fallback: OCR
-    images = convert_from_bytes(file_obj.read())
-    return "\n".join(pytesseract.image_to_string(img) for img in images)
+        # Fallback: treat as plain text
+        return file_obj.read().decode("latin-1", errors="ignore")
+
+# ---------- 5. AI: Extract & Tag Questions ----------
+def process_past_paper(title, subject, paper_file, insert_file=None):
+    if not paper_file:
+        return "Upload a paper PDF!", gr.update()
 
-# ---------- 5. AI: Tag + Extract Questions ----------
-def process_past_paper(title, subject, pdf_file, insert_file=None):
-    text = extract_text_from_pdf(pdf_file)
-    insert_text = extract_text_from_pdf(insert_file) if insert_file else ""
+    text = extract_text(paper_file)
+    insert_text = extract_text(insert_file) if insert_file else ""
 
     prompt = f"""
-You are an IGCSE {subject} examiner. Extract EVERY question from this past paper.
-For each question:
+You are an IGCSE {subject} expert. Extract ALL questions from this paper.
+For each:
 - Exact question text
-- Topic (choose one: {', '.join(TOPICS[subject])})
-- Marks
-- Year & Paper code (if visible)
-- Type: Reading / Writing / Listening / Translation
+- Topic (only one from: {', '.join(TOPICS[subject])})
+- Marks (e.g. [5])
+- Year/code if visible
 
-Return valid JSON only:
+Return ONLY valid JSON:
 {{
   "paper": "{title}",
   "questions": [
     {{
-      "id": "auto",
-      "text": "...",
+      "text": "Question here...",
       "topic": "Food",
       "marks": 5,
-      "year": "2023",
-      "type": "Reading"
+      "year": "2023"
     }}
   ]
 }}
-Paper text:
-{text[:12000]}
 
-Insert (if any):
-{insert_text[:4000]}
+PAPER TEXT:
+{text[:15000]}
+
+INSERT:
+{insert_text[:5000]}
 """
-    resp = client.chat.completions.create(
-        model=MODEL,
-        messages=[{"role": "user", "content": prompt}],
-        max_tokens=4000,
-        temperature=0.3
-    ).choices[0].message.content.strip()
 
     try:
-        data = json.loads(resp.replace("```json", "").replace("```", ""))
-        paper_id = str(uuid.uuid4())[:8]
+        resp = client.chat.completions.create(
+            model=MODEL,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=4000,
+            temperature=0.2
+        ).choices[0].message.content.strip()
+
+        data = json.loads(resp.replace("```json", "").replace("```", "").strip())
         added = 0
-        for q in data["questions"]:
+        paper_id = str(uuid.uuid4())[:8]
+
+        for q in data.get("questions", []):
             qid = str(uuid.uuid4())[:6]
-            q["id"] = qid
-            q["paper_id"] = paper_id
-            q["source"] = title
-            topic = q["topic"]
+            topic = q.get("topic", "General")
             if topic not in questions_db:
                 questions_db[topic] = []
-            questions_db[topic].append(q)
+            questions_db[topic].append({
+                "id": qid,
+                "text": q.get("text", "").strip(),
+                "marks": q.get("marks", 1),
+                "year": q.get("year", "Unknown"),
+                "source": title,
+                "topic": topic
+            })
             added += 1
 
         papers_db.append({
             "id": paper_id,
             "title": title,
             "subject": subject,
-            "uploaded_at": datetime.now().strftime("%b %d, %Y"),
-            "questions": added
+            "questions": added,
+            "date": datetime.now().strftime("%b %d")
         })
-        return f"Success: {added} questions added from **{title}**!", gr.update(value=list_papers())
+
+        return f"Uploaded: {added} questions added from **{title}**!", refresh_papers()
     except Exception as e:
-        return f"Error: {e}", gr.update()
+        return f"Error: {str(e)}", gr.update()
 
-# ---------- 6. Real Question Generator ----------
-def get_real_question(subject, topic):
+# ---------- 6. Real Question ----------
+def get_question(subject, topic):
     if topic not in questions_db or not questions_db[topic]:
-        return "No real questions yet. Ask admin to upload papers!", "", ""
+        return "No questions yet! Ask admin to upload papers.", "", ""
     
     import random
     q = random.choice(questions_db[topic])
     return (
-        f"**[{q['year'] or 'Past'} | {q['marks']} marks]**\n\n{q['text']}",
-        f"Expected: {q['type']} answer worth {q['marks']} marks.",
+        f"**{q['year']} | {q['marks']} marks**\n\n{q['text']}",
+        f"Write a full answer worth {q['marks']} marks.",
         q["id"]
     )
 
-# ---------- 7. Answer Checker ----------
-def check_real_answer(qid, user_answer, user_id):
-    if not user_answer.strip():
-        return "Type your answer!"
-    
+# ---------- 7. AI Marking ----------
+def check_answer(qid, answer, user_id):
+    if not answer.strip():
+        return "Write your answer!"
+
     # Find question
-    question = None
+    q = None
     for qs in questions_db.values():
-        for q in qs:
-            if q["id"] == qid:
-                question = q
+        for item in qs:
+            if item["id"] == qid:
+                q = item
                 break
-        if question: break
-    
-    if not question:
+        if q: break
+
+    if not q:
         return "Question not found."
 
     prompt = f"""
-IGCSE {question.get('type','')} Marking:
-Question: {question['text']}
-Marks: {question['marks']}
-Student answer: {user_answer}
+IGCSE Marking:
+Question: {q['text']}
+Marks: {q['marks']}
+Student: {answer}
 
 Reply JSON:
 {{
-  "score": 0-{question['marks']},
-  "feedback": "Clear strengths and errors",
-  "band": "High/Mid/Low",
-  "improvement": "One key tip"
+  "score": 3,
+  "feedback": "You used good vocab but forgot accents.",
+  "tip": "Always check verb endings!"
 }}
 """
-    resp = client.chat.completions.create(
-        model=MODEL,
-        messages=[{"role": "user", "content": prompt}],
-        max_tokens=600
-    ).choices[0].message.content.strip()
-
     try:
+        resp = client.chat.completions.create(
+            model=MODEL,
+            messages=[{"role": "user", "content": prompt}],
+            max_tokens=500
+        ).choices[0].message.content.strip()
+        
         fb = json.loads(resp.replace("```json", "").replace("```", ""))
         score = fb["score"]
-        max_marks = question['marks']
-        percent = int(100 * score / max_marks)
+        percent = int(100 * score / q['marks'])
 
-        # Update progress
+        # Progress
         if user_id not in user_progress:
             user_progress[user_id] = {}
-        if question["topic"] not in user_progress[user_id]:
-            user_progress[user_id][question["topic"]] = {"correct": 0, "total": 0, "streak": 0}
+        if q["topic"] not in user_progress[user_id]:
+            user_progress[user_id][q["topic"]] = {"c": 0, "t": 0, "s": 0}
         
-        prog = user_progress[user_id][question["topic"]]
-        prog["total"] += 1
-        if score >= max_marks * 0.7:
-            prog["correct"] += 1
-            prog["streak"] += 1
+        p = user_progress[user_id][q["topic"]]
+        p["t"] += 1
+        if score >= q['marks'] * 0.7:
+            p["c"] += 1
+            p["s"] += 1
         else:
-            prog["streak"] = 0
-
-        xp = 10 + (5 if prog["streak"] > 2 else 0)
-        streak_emoji = "Fire" if prog["streak"] > 2 else "Checkmark"
+            p["s"] = 0
 
         return f"""
-**Score: {score}/{max_marks} ({percent}%)**  
-Band: **{fb['band']}**
+**Score: {score}/{q['marks']} ({percent}%)**
 
 **Feedback:**  
 {fb['feedback']}
 
-**Improvement:**  
-{fb['improvement']}
+**Tip:** {fb['tip']}
 
-**+{xp} XP** | Streak: {prog['streak']} {streak_emoji}
+**Streak: {p['s']}** {'Fire' if p['s'] > 2 else 'Checkmark'} | +10 XP
 """
     except:
-        return resp
-
-# ---------- 8. Dashboard ----------
-def get_progress(user_id):
-    if not user_id or user_id not in user_progress:
-        return "Start practicing to see progress!"
-    lines = ["### Your Progress"]
-    for topic, data in user_progress[user_id].items():
-        acc = data["correct"]/data["total"] if data["total"] else 0
-        lines.append(f"- **{topic}**: {data['correct']}/{data['total']} ({acc:.0%}) | Streak: {data['streak']}")
-    return "\n".join(lines)
+        return "AI marking busy — try again!"
 
-# ---------- 9. Admin List ----------
-def list_papers():
+# ---------- 8. UI Helpers ----------
+def refresh_papers():
     if not papers_db:
-        return "No papers uploaded yet."
+        return "No papers uploaded."
     return "\n".join(
-        f"**{p['title']}** ({p['subject']}) – {p['questions']} questions – {p['uploaded_at']}"
-        for p in papers_db[-10:]
+        f"- **{p['title']}** ({p['subject']}) — {p['questions']} Qs — {p['date']}"
+        for p in papers_db[-8:]
     )
 
-# ---------- 10. UI ----------
+def show_progress(uid):
+    if uid not in user_progress or not user_progress[uid]:
+        return "Answer questions to see progress!"
+    lines = [f"### {uid}'s Progress"]
+    for topic, d in user_progress[uid].items():
+        acc = d["c"]/d["t"] if d["t"] else 0
+        lines.append(f"- **{topic}**: {d['c']}/{d['t']} ({acc:.0%}) | Streak: {d['s']}")
+    return "\n".join(lines)
+
+# ---------- 9. GRADIO APP ----------
 with gr.Blocks(theme=gr.themes.Soft(), title="IGCSE Language Pro") as app:
-    gr.Markdown("""
-    # IGCSE Language Pro
-    **Real Past-Paper Questions • AI Tutor • Track Progress**
-    """)
-    user_id = gr.Textbox(label="Your Name/ID", placeholder="e.g. Alex2025", value="guest")
+    gr.Markdown("# IGCSE Language Pro\n**Real Past-Paper Questions • AI Tutor • Zero Install**")
+
+    user = gr.Textbox(label="Your Name", placeholder="e.g. Sarah2025", value="student")
 
     with gr.Tabs():
-        # STUDENT
         with gr.Tab("Practice"):
-            gr.Markdown("### Real IGCSE Questions")
+            gr.Markdown("### Get Real Exam Questions")
             with gr.Row():
-                subj = gr.Dropdown(["French", "EFL"], label="Subject", value="French")
-                topic = gr.Dropdown(TOPICS["French"], label="Topic")
-            def update_topics(s):
-                return gr.Dropdown(choices=TOPICS[s], value=TOPICS[s][0])
-            subj.change(update_topics, subj, topic)
-
-            q_out = gr.Markdown()
-            exp = gr.Textbox(visible=False)
-            qid_hidden = gr.Textbox(visible=False)
-            ans = gr.Textbox(lines=6, label="Your Answer", placeholder="Write in full sentences...")
+                sub = gr.Dropdown(["French", "EFL"], label="Subject", value="French")
+                top = gr.Dropdown(TOPICS["French"], label="Topic")
+            sub.change(lambda s: gr.Dropdown(TOPICS[s]), sub, top)
+
+            question = gr.Markdown()
+            hidden_qid = gr.Textbox(visible=False)
+            answer = gr.Textbox(lines=7, label="Your Answer", placeholder="Write in full...")
             feedback = gr.Markdown()
 
-            gr.Button("Generate Real Question").click(
-                get_real_question, [subj, topic], [q_out, exp, qid_hidden]
-            )
-            gr.Button("Check Answer").click(
-                check_real_answer, [qid_hidden, ans, user_id], feedback
-            )
+            gr.Button("Generate Question").click(get_question, [sub, top], [question, gr.Textbox(), hidden_qid])
+            gr.Button("Check Answer").click(check_answer, [hidden_qid, answer, user], feedback)
 
-            gr.Markdown("### Your Dashboard")
-            dash = gr.Markdown()
-            gr.Button("Refresh Progress").click(get_progress, user_id, dash)
+            gr.Markdown("### Your Stats")
+            stats = gr.Markdown()
+            gr.Button("Refresh").click(show_progress, user, stats)
 
         with gr.Tab("AI Tutor"):
-            chatbot = gr.Chatbot(height=500)
-            msg = gr.Textbox(placeholder="Ask about passé composé, idioms, or essay structure...")
-            def tutor_resp(message, history):
-                system = f"You are a fun, expert IGCSE tutor. Use examples from real past papers."
-                resp = client.chat.completions.create(
+            chat = gr.Chatbot(height=500)
+            msg = gr.Textbox(placeholder="Ask: How to use subjunctive?")
+            msg.submit(
+                lambda m, h: h + [[m, client.chat.completions.create(
                     model=MODEL,
-                    messages=[{"role": "system", "content": system}] + 
-                             [{"role": "user" if i%2==0 else "assistant", "content": turn}
-                              for pair in history for i, turn in enumerate(pair)] +
-                             [{"role": "user", "content": message}],
-                    max_tokens=800,
-                    temperature=0.8
-                ).choices[0].message.content
-                return history + [[message, resp]]
-            msg.submit(tutor_resp, [msg, chatbot], chatbot)
-
-        with gr.Tab("Dictionary & Translator"):
-            with gr.Tabs():
-                with gr.Tab("Translate"):
-                    dir = gr.Radio(["EN to FR", "FR to EN"], value="EN to FR")
-                    txt = gr.Textbox(lines=3)
-                    out = gr.Textbox(lines=3)
-                    gr.Button("Translate").click(
-                        lambda t, d: client.translation(t, src_lang="en" if "EN" in d else "fr", tgt_lang="fr" if "EN" in d else "en").translation,
-                        [txt, dir], out
-                    )
-                with gr.Tab("Dictionary"):
-                    word = gr.Textbox(placeholder="e.g. magnifique")
-                    defn = gr.Markdown()
-                    gr.Button("Lookup").click(
-                        lambda w: client.text_generation(
-                            f"French dictionary entry for '{w}':\n- Meaning\n- Gender\n- 2 sentences",
-                            model=MODEL, max_new_tokens=400
-                        ), word, defn
-                    )
-
-        # ADMIN
+                    messages=[{"role": "user", "content": m}],
+                    max_tokens=600
+                ).choices[0].message.content]],
+                [msg, chat], chat
+            )
+
         with gr.Tab("Admin Upload"):
-            gr.Markdown("### Upload Past Paper + Insert")
-            with gr.Row():
-                title = gr.Textbox(label="Paper Title", placeholder="June 2023 Paper 2")
-                sub = gr.Radio(["French", "EFL"], label="Subject", value="French")
-            pdf = gr.File(label="Question Paper (PDF)", file_types=[".pdf"])
-            insert = gr.File(label="Insert/Listening Script (Optional)", file_types=[".pdf"])
+            gr.Markdown("### Upload Past Paper (PDF)")
+            title = gr.Textbox(label="Title", placeholder="June 2023 Paper 21")
+            subj = gr.Radio(["French", "EFL"], value="French")
+            paper = gr.File(label="Question Paper PDF", file_types=[".pdf"])
+            insert = gr.File(label="Insert (Optional)", file_types=[".pdf"])
             status = gr.Markdown()
-            papers_list = gr.Markdown(value=list_papers())
+            list_box = gr.Markdown(value=refresh_papers())
 
-            gr.Button("Process Paper").click(
-                process_past_paper,
-                [title, sub, pdf, insert],
-                [status, papers_list]
+            gr.Button("Upload & Extract").click(
+                process_past_paper, [title, subj, paper, insert], [status, list_box]
             )
 
     gr.Markdown("""
     ---
-    **Deploy:** Fork → Add `HF_TOKEN` → Done!  
-    **Tip:** Upload 2020–2024 papers → instant 1000+ real questions!
+    **Deploy in 30 seconds:**
+    1. Click "Duplicate Space"
+    2. Settings → Secrets → Add `HF_TOKEN`
+    3. Restart → Done!
     """)
 
-app.launch(share=True)
+app.launch()