Update app.py

app.py

@@ -1,18 +1,26 @@
 """
-StudyFlow Backend - Lightweight API for Hugging Face
+StudyFlow Backend API for Hugging Face Spaces
+Complete implementation with PDF processing and content generation
 """
 
-from fastapi import FastAPI, File, UploadFile, Form
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, HTMLResponse
 from datetime import datetime
 import json
 import PyPDF2
 import io
+import re
+from typing import List, Dict, Any
+import os
 
-app = FastAPI(title="StudyFlow API")
+app = FastAPI(
+    title="StudyFlow API",
+    description="AI-powered learning assistant backend",
+    version="1.0.0"
+)
 
-# CORS
+# Enable CORS for frontend
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -21,128 +29,507 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Store for user sessions (in production, use database)
+user_sessions = {}
+
+def extract_key_concepts(text: str, max_concepts: int = 5) -> List[str]:
+    """Extract key concepts from text using simple NLP techniques"""
+    words = re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', text)
+    word_freq = {}
+    
+    for word in words:
+        if len(word) > 3:  # Ignore short words
+            word_freq[word] = word_freq.get(word, 0) + 1
+    
+    # Sort by frequency and get top concepts
+    sorted_concepts = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
+    return [concept for concept, _ in sorted_concepts[:max_concepts]]
+
+def generate_question_from_concept(concept: str, difficulty: str, question_type: str = "multiple_choice") -> Dict[str, Any]:
+    """Generate a question based on a concept"""
+    question_id = f"q_{datetime.now().timestamp()}"
+    
+    if question_type == "multiple_choice":
+        return {
+            "id": question_id,
+            "type": "multiple_choice",
+            "question": f"What is the significance of {concept}?",
+            "options": [
+                f"{concept} is a fundamental concept in this field",
+                f"{concept} represents a technical specification",
+                f"{concept} is a historical figure",
+                f"{concept} is a recent development"
+            ],
+            "correct_answer": 0,
+            "explanation": f"{concept} is mentioned throughout the text as a key concept.",
+            "difficulty": difficulty,
+            "concept": concept
+        }
+    else:  # short_answer
+        return {
+            "id": question_id,
+            "type": "short_answer",
+            "question": f"Explain {concept} in your own words.",
+            "correct_answer": f"{concept} is an important concept discussed in the material.",
+            "explanation": f"This requires understanding of {concept} from the context.",
+            "difficulty": difficulty,
+            "concept": concept
+        }
+
+def generate_flashcard_from_concept(concept: str) -> Dict[str, Any]:
+    """Generate a flashcard from a concept"""
+    return {
+        "id": f"f_{datetime.now().timestamp()}",
+        "front": f"What is {concept}?",
+        "back": f"{concept} is a key concept discussed in the material.",
+        "category": "Key Concepts",
+        "difficulty": "medium",
+        "lastReviewed": None,
+        "nextReview": None,
+        "easeFactor": 2.5
+    }
+
 @app.get("/")
 async def root():
-    return {"service": "StudyFlow API", "status": "healthy"}
+    """Root endpoint with API information"""
+    return {
+        "service": "StudyFlow API",
+        "version": "1.0.0",
+        "status": "running",
+        "endpoints": {
+            "generate_questions": "POST /api/generate-questions",
+            "generate_flashcards": "POST /api/generate-flashcards",
+            "summarize": "POST /api/summarize",
+            "explain": "POST /api/explain",
+            "upload_pdf": "POST /api/upload-pdf",
+            "health": "GET /health"
+        },
+        "documentation": "/docs"
+    }
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy", "timestamp": datetime.now().isoformat()}
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "sessions": len(user_sessions)
+    }
 
 @app.post("/api/generate-questions")
 async def generate_questions(
     text: str = Form(...),
     difficulty: str = Form("medium"),
-    mode: str = Form("mixed")
+    mode: str = Form("mixed"),
+    num_questions: int = Form(5)
 ):
-    """Generate questions based on text and user preferences"""
-    
-    # Simple question generation logic
-    words = text.split()
-    if len(words) < 50:
-        return {"error": "Text too short. Please provide more content."}
-    
-    # Extract key terms (simple implementation)
-    key_terms = [word for word in words if len(word) > 5][:5]
+    """
+    Generate educational questions from text
     
-    # Generate questions based on mode
-    questions = []
-    
-    if mode in ["practice", "mixed"]:
-        questions.extend([
-            {
-                "id": "q1",
-                "type": "multiple_choice",
-                "question": "What is the main topic discussed?",
-                "options": [
-                    "General introduction and overview",
-                    "Technical specifications",
-                    "Historical context",
-                    "Future applications"
-                ],
-                "correct_answer": 0,
-                "explanation": "The text provides a foundational overview of the subject.",
-                "difficulty": difficulty,
-                "concept": "Main Topic"
-            }
-        ])
-    
-    if mode in ["theory", "mixed"]:
-        questions.append({
-            "id": "q2",
-            "type": "short_answer",
-            "question": "Summarize the key point in one sentence.",
-            "correct_answer": "The material introduces important concepts for understanding the subject.",
-            "explanation": "This captures the essential purpose of the text.",
+    Args:
+        text: Input text to analyze
+        difficulty: Difficulty level (easy, medium, hard)
+        mode: Question type (theory, practice, mixed, flashcards)
+        num_questions: Number of questions to generate
+    """
+    try:
+        if not text or len(text.strip()) < 100:
+            raise HTTPException(
+                status_code=400,
+                detail="Text too short. Please provide at least 100 characters."
+            )
+        
+        # Validate inputs
+        if difficulty not in ["easy", "medium", "hard"]:
+            difficulty = "medium"
+        
+        if mode not in ["theory", "practice", "mixed", "flashcards"]:
+            mode = "mixed"
+        
+        num_questions = max(1, min(num_questions, 20))  # Limit to 1-20 questions
+        
+        # Extract key concepts from text
+        key_concepts = extract_key_concepts(text, max_concepts=min(num_questions, 10))
+        
+        # Generate questions based on mode
+        questions = []
+        concept_index = 0
+        
+        while len(questions) < num_questions and concept_index < len(key_concepts):
+            if mode == "theory" or mode == "mixed":
+                # Generate theory questions (short answer)
+                questions.append(generate_question_from_concept(
+                    key_concepts[concept_index],
+                    difficulty,
+                    "short_answer"
+                ))
+                concept_index += 1
+                
+                if len(questions) >= num_questions:
+                    break
+            
+            if mode == "practice" or mode == "mixed":
+                # Generate practice questions (multiple choice)
+                questions.append(generate_question_from_concept(
+                    key_concepts[concept_index],
+                    difficulty,
+                    "multiple_choice"
+                ))
+                concept_index += 1
+                
+                if len(questions) >= num_questions:
+                    break
+        
+        # If we don't have enough concepts, add generic questions
+        while len(questions) < num_questions:
+            generic_concept = "the main topic" if len(questions) % 2 == 0 else "key concepts"
+            questions.append(generate_question_from_concept(
+                generic_concept,
+                difficulty,
+                "multiple_choice" if len(questions) % 2 == 0 else "short_answer"
+            ))
+        
+        return {
+            "success": True,
+            "questions": questions[:num_questions],
+            "concepts": key_concepts,
+            "count": len(questions[:num_questions]),
             "difficulty": difficulty,
-            "concept": "Summary"
-        })
-    
-    return {
-        "questions": questions,
-        "concepts": ["Main Topic", "Key Concepts"],
-        "generated_at": datetime.now().isoformat()
-    }
+            "mode": mode,
+            "generated_at": datetime.now().isoformat()
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to generate questions: {str(e)}"
+        )
 
 @app.post("/api/generate-flashcards")
-async def generate_flashcards(text: str = Form(...)):
-    """Generate flashcards from text"""
-    
-    # Simple flashcard generation
-    words = text.split()
-    key_terms = [word for word in words if word[0].isupper() and len(word) > 3][:3]
-    
-    flashcards = []
-    for i, term in enumerate(key_terms, 1):
-        flashcards.append({
-            "id": f"f{i}",
-            "front": f"What is {term}?",
-            "back": f"A key concept mentioned in the text",
-            "category": "Terminology"
-        })
+async def generate_flashcards(
+    text: str = Form(...),
+    difficulty: str = Form("medium")
+):
+    """
+    Generate flashcards from text
     
-    return {
-        "flashcards": flashcards,
-        "generated_at": datetime.now().isoformat()
-    }
+    Args:
+        text: Input text to analyze
+        difficulty: Difficulty level for flashcards
+    """
+    try:
+        if not text or len(text.strip()) < 100:
+            raise HTTPException(
+                status_code=400,
+                detail="Text too short. Please provide at least 100 characters."
+            )
+        
+        # Extract key concepts
+        key_concepts = extract_key_concepts(text, max_concepts=10)
+        
+        # Generate flashcards
+        flashcards = []
+        for i, concept in enumerate(key_concepts):
+            if i >= 10:  # Limit to 10 flashcards
+                break
+                
+            flashcard = generate_flashcard_from_concept(concept)
+            
+            # Adjust based on difficulty
+            if difficulty == "easy":
+                flashcard["difficulty"] = "easy"
+                flashcard["back"] = f"{concept} is a basic concept mentioned in the text."
+            elif difficulty == "hard":
+                flashcard["difficulty"] = "hard"
+                flashcard["back"] = f"{concept} represents a complex concept requiring deeper understanding."
+            
+            flashcards.append(flashcard)
+        
+        # Add some generic flashcards if we don't have enough concepts
+        generic_flashcards = [
+            {
+                "id": f"f_gen_{i}",
+                "front": "What is the main topic of this material?",
+                "back": "The text discusses key concepts and principles.",
+                "category": "Overview",
+                "difficulty": difficulty,
+                "lastReviewed": None,
+                "nextReview": None,
+                "easeFactor": 2.5
+            }
+            for i in range(max(0, 5 - len(flashcards)))
+        ]
+        
+        flashcards.extend(generic_flashcards)
+        
+        return {
+            "success": True,
+            "flashcards": flashcards,
+            "count": len(flashcards),
+            "generated_at": datetime.now().isoformat()
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to generate flashcards: {str(e)}"
+        )
 
 @app.post("/api/summarize")
-async def summarize(text: str = Form(...)):
-    """Generate summary of text"""
+async def summarize(
+    text: str = Form(...),
+    difficulty: str = Form("medium")
+):
+    """
+    Generate a summary of the text
     
-    # Simple summarization (first 200 chars)
-    summary = text[:200] + ("..." if len(text) > 200 else "")
+    Args:
+        text: Text to summarize
+        difficulty: Reading level for summary
+    """
+    try:
+        if not text:
+            raise HTTPException(
+                status_code=400,
+                detail="No text provided."
+            )
+        
+        # Simple summarization - first 200 words
+        words = text.split()
+        word_count = len(words)
+        
+        if word_count < 100:
+            summary = text
+        else:
+            # Take first 10% of text for summary
+            summary_length = max(50, min(500, word_count // 10))
+            summary_words = words[:summary_length]
+            summary = ' '.join(summary_words)
+            if word_count > summary_length:
+                summary += "..."
+        
+        # Adjust summary based on difficulty
+        if difficulty == "easy":
+            intro = "This is a simple summary:\n\n"
+        elif difficulty == "hard":
+            intro = "Detailed analysis:\n\n"
+        else:
+            intro = "Summary:\n\n"
+        
+        # Add metadata
+        reading_time = max(1, word_count // 200)  # 200 words per minute
+        
+        full_summary = f"""{intro}{summary}
+
+Key Information:
+• Word count: {word_count}
+• Estimated reading time: {reading_time} minute{'s' if reading_time != 1 else ''}
+• Key concepts: {', '.join(extract_key_concepts(text, 3))}
+
+Study recommendations:
+1. Read through the summary first
+2. Identify unfamiliar terms
+3. Create flashcards for key concepts
+4. Test your understanding with practice questions"""
+
+        return {
+            "success": True,
+            "summary": full_summary,
+            "word_count": word_count,
+            "reading_time": reading_time,
+            "generated_at": datetime.now().isoformat()
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to generate summary: {str(e)}"
+        )
+
+@app.post("/api/explain")
+async def explain(
+    topic: str = Form(...),
+    context: str = Form("")
+):
+    """
+    Explain a specific topic
     
-    return {
-        "summary": summary,
-        "length": len(text),
-        "generated_at": datetime.now().isoformat()
-    }
+    Args:
+        topic: Topic to explain
+        context: Context from the material
+    """
+    try:
+        if not topic:
+            raise HTTPException(
+                status_code=400,
+                detail="No topic provided."
+            )
+        
+        # Generate explanation based on topic
+        if context and len(context) > 100:
+            # If we have context, create a more specific explanation
+            explanation = f"""**Explanation of {topic}:**
+
+Based on the provided material, {topic} appears to be an important concept. 
+
+The text mentions this in the context of: "{context[:200]}..."
+
+Key points about {topic}:
+• Likely relates to the main themes discussed
+• May be connected to other concepts in the text
+• Understanding this is important for grasping the material
+
+To better understand {topic}, try:
+1. Looking for definitions in the text
+2. Finding examples of how it's used
+3. Creating a flashcard to review later"""
+        else:
+            # Generic explanation
+            explanation = f"""**Explanation of {topic}:**
+
+{topic} is a concept that requires understanding. In learning materials, concepts like this typically:
+
+• Represent important ideas or principles
+• Connect to other topics in meaningful ways
+• Have practical applications or implications
+
+To master {topic}:
+1. Read about it in multiple sources
+2. Try explaining it in your own words
+3. Create practice questions about it
+4. Review it regularly using spaced repetition"""
+
+        return {
+            "success": True,
+            "topic": topic,
+            "explanation": explanation,
+            "generated_at": datetime.now().isoformat()
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to generate explanation: {str(e)}"
+        )
 
 @app.post("/api/upload-pdf")
 async def upload_pdf(file: UploadFile = File(...)):
-    """Extract text from PDF"""
+    """
+    Extract text from uploaded PDF
+    
+    Args:
+        file: PDF file to process
+    """
     try:
+        # Check file type
+        if not file.filename.lower().endswith('.pdf'):
+            raise HTTPException(
+                status_code=400,
+                detail="Only PDF files are supported."
+            )
+        
+        # Read file content
         contents = await file.read()
-        pdf_reader = PyPDF2.PdfReader(io.BytesIO(contents))
         
+        if len(contents) > 10 * 1024 * 1024:  # 10MB limit
+            raise HTTPException(
+                status_code=400,
+                detail="File too large. Maximum size is 10MB."
+            )
+        
+        # Extract text from PDF
+        pdf_file = io.BytesIO(contents)
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        
+        if len(pdf_reader.pages) == 0:
+            raise HTTPException(
+                status_code=400,
+                detail="PDF file appears to be empty or corrupted."
+            )
+        
+        # Extract text from pages (limit to first 10 pages for performance)
         text = ""
-        for page in pdf_reader.pages[:5]:  # Limit to first 5 pages
-            text += page.extract_text() + "\n"
+        pages_to_extract = min(10, len(pdf_reader.pages))
+        
+        for i in range(pages_to_extract):
+            try:
+                page_text = pdf_reader.pages[i].extract_text()
+                if page_text:
+                    text += page_text + "\n\n"
+            except Exception as e:
+                print(f"Error extracting page {i+1}: {e}")
+                continue
+        
+        if not text.strip():
+            raise HTTPException(
+                status_code=400,
+                detail="Could not extract text from PDF. The file might be scanned or image-based."
+            )
+        
+        # Extract metadata
+        word_count = len(text.split())
+        
+        # Store session
+        session_id = f"session_{datetime.now().timestamp()}"
+        user_sessions[session_id] = {
+            "filename": file.filename,
+            "size": len(contents),
+            "pages": len(pdf_reader.pages),
+            "extracted_pages": pages_to_extract,
+            "word_count": word_count,
+            "uploaded_at": datetime.now().isoformat()
+        }
         
         return {
+            "success": True,
+            "session_id": session_id,
             "filename": file.filename,
-            "text_length": len(text),
-            "text_preview": text[:500],
-            "pages": len(pdf_reader.pages)
+            "text": text,
+            "text_preview": text[:1000],
+            "pages": len(pdf_reader.pages),
+            "extracted_pages": pages_to_extract,
+            "word_count": word_count,
+            "file_size": len(contents),
+            "uploaded_at": datetime.now().isoformat()
         }
         
+    except HTTPException:
+        raise
     except Exception as e:
-        return JSONResponse(
-            status_code=400,
-            content={"error": f"Failed to process PDF: {str(e)}"}
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to process PDF: {str(e)}"
         )
 
+@app.get("/api/session/{session_id}")
+async def get_session(session_id: str):
+    """Get information about a session"""
+    if session_id not in user_sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    return {
+        "success": True,
+        "session": user_sessions[session_id]
+    }
+
+@app.delete("/api/session/{session_id}")
+async def delete_session(session_id: str):
+    """Delete a session"""
+    if session_id in user_sessions:
+        del user_sessions[session_id]
+        return {"success": True, "message": "Session deleted"}
+    else:
+        raise HTTPException(status_code=404, detail="Session not found")
+
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    port = int(os.getenv("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)