Update app.py

app.py

@@ -1,5 +1,5 @@
 """
-StudyFlow AI Backend - Lightweight Version for Hugging Face Spaces
+StudyFlow AI Backend - Complete Working Version for Hugging Face Spaces
 """
 import os
 import json
@@ -12,7 +12,6 @@ from pathlib import Path
 from fastapi import FastAPI, UploadFile, File, Form, HTTPException
 from fastapi.responses import JSONResponse, FileResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
 import PyPDF2
 from youtube_transcript_api import YouTubeTranscriptApi
 import requests
@@ -143,81 +142,140 @@ def extract_text_from_pdf(file_path: str) -> str:
             pdf_reader = PyPDF2.PdfReader(file)
             text = ""
             for page in pdf_reader.pages:
-                text += page.extract_text() + "\n"
-        return text
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text + "\n"
+        return text[:5000]  # Limit text length
     except Exception as e:
-        return f"Error extracting PDF: {str(e)}"
+        return f"PDF text extraction error: {str(e)}"
 
 def extract_text_from_youtube(url: str) -> str:
     """Extract transcript from YouTube video"""
     try:
-        video_id = url.split("v=")[-1].split("&")[0]
+        # Extract video ID from URL
+        if "youtube.com/watch?v=" in url:
+            video_id = url.split("v=")[-1].split("&")[0]
+        elif "youtu.be/" in url:
+            video_id = url.split("/")[-1].split("?")[0]
+        else:
+            return "Invalid YouTube URL"
+        
         transcript = YouTubeTranscriptApi.get_transcript(video_id)
         text = " ".join([entry['text'] for entry in transcript])
-        return text
+        return text[:5000]  # Limit text length
     except Exception as e:
-        return f"Error extracting YouTube transcript: {str(e)}"
+        return f"YouTube transcript error: {str(e)}"
 
 def generate_questions(text: str, difficulty: str, count: int = 5) -> list:
-    """Generate questions from text (simplified for demo)"""
-    sentences = [s.strip() for s in text.split('.') if len(s.strip()) > 50]
-    sentences = sentences[:10]  # Take first 10 meaningful sentences
+    """Generate questions from text"""
+    # Split text into sentences
+    import re
+    sentences = re.split(r'[.!?]+', text)
+    sentences = [s.strip() for s in sentences if len(s.strip()) > 30]
+    
+    if not sentences:
+        sentences = [text[:200]]  # Use first 200 chars as fallback
     
     questions = []
     for i, sentence in enumerate(sentences[:count]):
+        if not sentence:
+            continue
+            
         qid = generate_id(f"q_{i}_{sentence[:20]}")
         
-        # Simple question generation logic
-        words = sentence.split()
-        if len(words) > 8:
-            # Create a fill-in-the-blank question
-            blank_word = words[len(words)//2]
-            question_text = sentence.replace(blank_word, "_____")
+        # Simple question generation
+        if difficulty == "easy":
+            # Fill in the blank
+            words = sentence.split()
+            if len(words) > 3:
+                blank_index = len(words) // 2
+                blank_word = words[blank_index]
+                question_text = sentence.replace(blank_word, "_____", 1)
+                questions.append({
+                    "id": qid,
+                    "question_text": question_text,
+                    "question_type": "fill_blank",
+                    "correct_answer": blank_word,
+                    "difficulty": difficulty,
+                    "explanation": f"The missing word is '{blank_word}' which completes the sentence."
+                })
+            else:
+                # Multiple choice for short sentences
+                question_text = f"What is the meaning of: '{sentence}'?"
+                options = ["A factual statement", "An opinion", "A question", "A command"]
+                questions.append({
+                    "id": qid,
+                    "question_text": question_text,
+                    "question_type": "multiple_choice",
+                    "options": json.dumps(options),
+                    "correct_answer": "0",
+                    "difficulty": difficulty,
+                    "explanation": "This appears to be a factual statement."
+                })
+        
+        elif difficulty == "medium":
+            # True/False question
+            question_text = f"Is the following statement true? '{sentence}'"
             questions.append({
                 "id": qid,
                 "question_text": question_text,
-                "question_type": "fill_blank",
-                "correct_answer": blank_word,
+                "question_type": "true_false",
+                "correct_answer": "0",  # True
                 "difficulty": difficulty,
-                "explanation": f"The missing word is '{blank_word}', which fits grammatically and contextually."
+                "explanation": "This statement appears to be true based on the context."
             })
-        else:
-            # Create a multiple choice question
-            question_text = f"What is the main idea of: '{sentence[:100]}...'?"
+        
+        else:  # hard
+            # Multiple choice with context
+            question_text = f"What is the main idea of: '{sentence[:150]}...'?"
             options = [
-                "It describes a process",
-                "It states a fact",
-                "It presents an argument",
-                "It asks a question"
+                "It describes a specific detail",
+                "It presents a general concept", 
+                "It asks a rhetorical question",
+                "It provides an example"
             ]
             questions.append({
                 "id": qid,
                 "question_text": question_text,
                 "question_type": "multiple_choice",
                 "options": json.dumps(options),
-                "correct_answer": "0",  # Default to first option
+                "correct_answer": "1",
                 "difficulty": difficulty,
-                "explanation": "This sentence appears to describe a process or sequence of events."
+                "explanation": "This sentence appears to present a general concept rather than specific details."
             })
     
     return questions
 
 def generate_flashcards(text: str, count: int = 3) -> list:
     """Generate flashcards from text"""
-    sentences = [s.strip() for s in text.split('.') if len(s.strip()) > 30]
-    sentences = sentences[:count * 2]  # Take pairs for front/back
+    import re
+    sentences = re.split(r'[.!?]+', text)
+    sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
     
     flashcards = []
-    for i in range(0, min(len(sentences), count * 2), 2):
-        if i + 1 < len(sentences):
-            fcid = generate_id(f"fc_{i}")
-            flashcards.append({
-                "id": fcid,
-                "front": sentences[i][:100],
-                "back": sentences[i + 1][:200],
-                "category": "General",
-                "difficulty": "medium"
-            })
+    for i in range(min(len(sentences), count)):
+        sentence = sentences[i]
+        if not sentence:
+            continue
+            
+        fcid = generate_id(f"fc_{i}_{sentence[:20]}")
+        
+        # Create flashcard with term and definition
+        words = sentence.split()
+        if len(words) > 5:
+            term = " ".join(words[:3]) + "..."
+            definition = sentence
+        else:
+            term = sentence
+            definition = "Key concept from the study material"
+        
+        flashcards.append({
+            "id": fcid,
+            "front": term[:100],
+            "back": definition[:200],
+            "category": "Study Material",
+            "difficulty": "medium"
+        })
     
     return flashcards
 
@@ -236,28 +294,23 @@ async def process_content(
     # Extract text based on content type
     text_content = ""
     if content_type == "text" and content:
-        text_content = content
+        text_content = content[:10000]  # Limit length
     elif content_type == "pdf" and file:
         # Save uploaded file temporarily
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
-        content_bytes = await file.read()
-        temp_file.write(content_bytes)
-        temp_file.close()
-        text_content = extract_text_from_pdf(temp_file.name)
-        os.unlink(temp_file.name)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_file:
+            content_bytes = await file.read()
+            temp_file.write(content_bytes)
+            temp_file_path = temp_file.name
+        
+        text_content = extract_text_from_pdf(temp_file_path)
+        os.unlink(temp_file_path)
     elif content_type == "youtube" and youtube_url:
         text_content = extract_text_from_youtube(youtube_url)
     else:
-        return JSONResponse(
-            status_code=400,
-            content={"error": "Invalid content type or missing content"}
-        )
+        raise HTTPException(status_code=400, detail="Invalid content type or missing content")
     
-    if len(text_content) < 100:
-        return JSONResponse(
-            status_code=400,
-            content={"error": "Content too short (minimum 100 characters)"}
-        )
+    if len(text_content) < 50:
+        raise HTTPException(status_code=400, detail="Content too short (minimum 50 characters)")
     
     # Generate content hash
     content_hash = hashlib.md5(text_content.encode()).hexdigest()
@@ -300,7 +353,7 @@ async def process_content(
             VALUES (?, ?, ?, ?, ?, ?, ?, ?)
         ''', (
             q["id"], session_id, q["question_text"], q["question_type"],
-            q.get("options"), q["correct_answer"], q["difficulty"], q.get("explanation")
+            q.get("options"), q["correct_answer"], q["difficulty"], q.get("explanation", "")
         ))
     
     # Save flashcards
@@ -313,15 +366,16 @@ async def process_content(
             fc["category"], fc["difficulty"]
         ))
     
-    # Create initial notes
+    # Create initial note
+    note_id = generate_id(f"note_{session_id}")
     cursor.execute('''
         INSERT INTO notes (id, session_id, title, content)
         VALUES (?, ?, ?, ?)
     ''', (
-        generate_id("note1"),
+        note_id,
         session_id,
-        "Key Concepts",
-        "Here are the key concepts from your study material..."
+        "Study Notes",
+        f"Key points from: {title}\n\nSummary: {text_content[:500]}..."
     ))
     
     conn.commit()
@@ -350,6 +404,12 @@ async def get_session(session_id: str):
         conn.close()
         raise HTTPException(status_code=404, detail="Session not found")
     
+    # Update last accessed
+    cursor.execute(
+        "UPDATE sessions SET last_accessed = CURRENT_TIMESTAMP WHERE id = ?",
+        (session_id,)
+    )
+    
     # Get questions
     cursor.execute("SELECT * FROM questions WHERE session_id = ?", (session_id,))
     questions = [dict(row) for row in cursor.fetchall()]
@@ -372,9 +432,10 @@ async def get_session(session_id: str):
     accuracy = round((correct_answers / total_questions * 100) if total_questions > 0 else 0, 1)
     avg_time_spent = round(sum(q.get("time_spent", 0) for q in questions) / total_questions if total_questions > 0 else 0, 1)
     
+    conn.commit()
     conn.close()
     
-    return JSONResponse({
+    return {
         "session": dict(session),
         "materials": {
             "questions": questions,
@@ -394,7 +455,7 @@ async def get_session(session_id: str):
             "accuracy": accuracy,
             "avg_time_spent": avg_time_spent
         }
-    })
+    }
 
 @app.get("/api/user/sessions")
 async def get_user_sessions():
@@ -425,7 +486,7 @@ async def get_user_sessions():
     
     conn.close()
     
-    return JSONResponse({"sessions": sessions})
+    return {"sessions": sessions}
 
 @app.post("/api/submit-answer")
 async def submit_answer(
@@ -450,7 +511,16 @@ async def submit_answer(
         raise HTTPException(status_code=404, detail="Question not found")
     
     correct_answer = result[0]
-    is_correct = 1 if str(user_answer).strip().lower() == str(correct_answer).strip().lower() else 0
+    
+    # Simple answer checking
+    if isinstance(correct_answer, str) and correct_answer.isdigit():
+        # Multiple choice or true/false
+        is_correct = 1 if str(user_answer).strip() == str(correct_answer).strip() else 0
+    else:
+        # Fill in the blank - case insensitive partial match
+        user_ans = str(user_answer).strip().lower()
+        correct_ans = str(correct_answer).strip().lower()
+        is_correct = 1 if user_ans == correct_ans or correct_ans in user_ans or user_ans in correct_ans else 0
     
     # Update question with user answer
     cursor.execute('''
@@ -461,51 +531,59 @@ async def submit_answer(
     
     # Update user profile stats
     cursor.execute('''
-        INSERT OR REPLACE INTO user_profile (id, total_questions, correct_answers, updated_at)
-        VALUES (
-            1,
-            COALESCE((SELECT total_questions FROM user_profile WHERE id = 1), 0) + 1,
-            COALESCE((SELECT correct_answers FROM user_profile WHERE id = 1), 0) + ?,
-            CURRENT_TIMESTAMP
-        )
+        INSERT OR IGNORE INTO user_profile (id) VALUES (1)
+    ''')
+    
+    cursor.execute('''
+        UPDATE user_profile 
+        SET total_questions = total_questions + 1,
+            correct_answers = correct_answers + ?,
+            updated_at = CURRENT_TIMESTAMP
+        WHERE id = 1
     ''', (is_correct,))
     
     conn.commit()
     conn.close()
     
-    return JSONResponse({
+    return {
         "is_correct": bool(is_correct),
         "correct_answer": correct_answer,
-        "message": "Correct!" if is_correct else "Incorrect, try again!"
-    })
+        "message": "Correct! Well done!" if is_correct else "Incorrect. The correct answer was: " + str(correct_answer)
+    }
 
 @app.post("/api/analyze-text")
 async def analyze_text(text: str = Form(...), session_id: str = Form(...)):
-    """Analyze selected text (simplified version)"""
+    """Analyze selected text"""
+    
+    if len(text) < 2 or len(text) > 1000:
+        raise HTTPException(status_code=400, detail="Text must be between 2 and 1000 characters")
     
     # Simple text analysis
     words = text.split()
     definitions = []
     
-    # Simple "definition" generation for demo
-    for i, word in enumerate(words[:5]):  # Analyze first 5 words
-        if len(word) > 4:  # Only "define" longer words
+    # Create simple definitions for longer words
+    for i, word in enumerate(words[:min(5, len(words))]):
+        if len(word) > 4 and word.isalpha():
             definitions.append({
                 "word": word,
-                "definition": f"A term used in this context meaning: '{word}'",
-                "source": "StudyFlow AI",
-                "example": f"In the sentence: '{' '.join(words[max(0,i-2):min(len(words),i+3)])}'"
+                "definition": f"'{word}' appears in this context. It's likely a key term in the study material.",
+                "source": "StudyFlow AI Analysis",
+                "example": f"Used in: '{' '.join(words[max(0,i-2):min(len(words),i+3)])}'"
             })
     
-    # Generate simple explanation
+    # Generate explanation based on text length
     word_count = len(words)
-    explanation = f"This text contains {word_count} words. "
-    if word_count < 10:
-        explanation += "It's a short phrase or sentence fragment."
-    elif word_count < 25:
-        explanation += "It's a sentence or two expressing a complete thought."
+    if word_count < 5:
+        explanation = "This is a short phrase or term."
+    elif word_count < 15:
+        explanation = "This appears to be a complete sentence expressing a single idea."
     else:
-        explanation += "It's a paragraph expressing multiple related ideas."
+        explanation = "This text contains multiple ideas or detailed information."
+    
+    # Count unique words
+    unique_words = len(set([w.lower() for w in words if w.isalpha()]))
+    explanation += f"\n\nIt contains {word_count} words with {unique_words} unique terms."
     
     # Save as highlight
     conn = sqlite3.connect(DB_PATH)
@@ -520,16 +598,16 @@ async def analyze_text(text: str = Form(...), session_id: str = Form(...)):
     conn.commit()
     conn.close()
     
-    return JSONResponse({
+    return {
         "text": text,
         "definitions": definitions,
         "explanation": explanation,
         "suggested_actions": [
-            "Add to flashcards",
-            "Create a practice question",
-            "Make a note about this concept"
+            "Create a flashcard for this concept",
+            "Generate a practice question",
+            "Add to study notes"
         ]
-    })
+    }
 
 @app.get("/api/user/profile")
 async def get_user_profile():
@@ -543,8 +621,7 @@ async def get_user_profile():
     if not profile:
         # Create default profile
         cursor.execute('''
-            INSERT INTO user_profile (id, total_questions, correct_answers, total_study_time)
-            VALUES (1, 0, 0, 0)
+            INSERT INTO user_profile (id) VALUES (1)
         ''')
         conn.commit()
         cursor.execute("SELECT * FROM user_profile WHERE id = 1")
@@ -573,14 +650,20 @@ async def get_user_profile():
             elif accuracy > 0.8:
                 strengths.append(f"{diff} difficulty questions")
     
+    # If no data yet
+    if not weak_areas:
+        weak_areas = ["Concepts will appear as you answer questions"]
+    if not strengths:
+        strengths = ["Keep practicing to build your strengths!"]
+    
     conn.close()
     
-    return JSONResponse({
+    return {
         "profile": {
-            "total_questions": profile[1],
-            "correct_answers": profile[2],
-            "total_study_time": profile[3],
-            "accuracy": round((profile[2] / profile[1] * 100) if profile[1] > 0 else 0, 1)
+            "total_questions": profile[1] or 0,
+            "correct_answers": profile[2] or 0,
+            "total_study_time": profile[3] or 0,
+            "accuracy": round((profile[2] / profile[1] * 100) if profile[1] and profile[1] > 0 else 0, 1)
         },
         "insights": {
             "weaknesses": weak_areas,
@@ -588,12 +671,12 @@ async def get_user_profile():
             "recent_performance": [
                 {
                     "date": datetime.now().strftime("%Y-%m-%d"),
-                    "total": profile[1],
-                    "correct": profile[2]
+                    "total": profile[1] or 0,
+                    "correct": profile[2] or 0
                 }
             ]
         }
-    })
+    }
 
 @app.delete("/api/session/{session_id}")
 async def delete_session(session_id: str):
@@ -610,7 +693,7 @@ async def delete_session(session_id: str):
     if affected == 0:
         raise HTTPException(status_code=404, detail="Session not found")
     
-    return JSONResponse({"message": "Session deleted successfully"})
+    return {"message": "Session deleted successfully"}
 
 @app.post("/api/update-study-time")
 async def update_study_time(session_id: str = Form(...), study_time: int = Form(...)):
@@ -624,6 +707,10 @@ async def update_study_time(session_id: str = Form(...), study_time: int = Form(
         WHERE id = ?
     ''', (session_id,))
     
+    cursor.execute('''
+        INSERT OR IGNORE INTO user_profile (id) VALUES (1)
+    ''')
+    
     cursor.execute('''
         UPDATE user_profile 
         SET total_study_time = COALESCE(total_study_time, 0) + ?
@@ -633,9 +720,15 @@ async def update_study_time(session_id: str = Form(...), study_time: int = Form(
     conn.commit()
     conn.close()
     
-    return JSONResponse({"message": "Study time updated"})
+    return {"message": "Study time updated"}
 
-# Serve static files
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+
+# Serve frontend files
 @app.get("/")
 async def serve_frontend():
     """Serve the main frontend page"""
@@ -656,12 +749,6 @@ async def serve_js():
     except FileNotFoundError:
         return HTMLResponse(content="console.error('app.js not found');", media_type="application/javascript")
 
-# Health check endpoint
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return JSONResponse({"status": "healthy", "timestamp": datetime.now().isoformat()})
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)