Update app.py

app.py

@@ -1,330 +1,840 @@
-import streamlit as st
-import numpy as np
-from PIL import Image
-import io
-import torch
-import torch.nn as nn
-from datetime import datetime
-import plotly.graph_objects as go
-import sys
-import os
-
-# Add utils to path
-sys.path.append('./utils')
-
-# Import custom utilities
-from utils.model_loader import load_medical_models, analyze_chest_xray, analyze_ultrasound
-from utils.image_processor import process_uploaded_image, enhance_image_quality
-
-# Set page configuration for Hugging Face
-st.set_page_config(
-    page_title="Rural Diagnostic Assistant",
-    page_icon="🏥",
-    layout="wide",
-    initial_sidebar_state="expanded"
+
+
+# app/main.py
+from fastapi import FastAPI, Depends, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from contextlib import asynccontextmanager
+import uvicorn
+from app.database import engine, Base
+from app.routers import auth, sync, content, analytics, grading
+from app.core.config import settings
+from app.ml.model_manager import ModelManager
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize ML models on startup
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    logger.info("Starting AI Tutor Backend...")
+    
+    # Create database tables
+    Base.metadata.create_all(bind=engine)
+    
+    # Initialize ML models
+    model_manager = ModelManager()
+    await model_manager.load_models()
+    
+    # Store model manager in app state
+    app.state.model_manager = model_manager
+    
+    logger.info("Backend startup complete")
+    yield
+    
+    # Shutdown
+    logger.info("Shutting down AI Tutor Backend...")
+
+app = FastAPI(
+    title="AI Tutor Backend",
+    description="Adaptive Multilingual Offline-First AI Tutor API",
+    version="1.0.0",
+    lifespan=lifespan
 )
 
-# Custom CSS optimized for Hugging Face
-st.markdown("""
-<style>
-    .main-header {
-        font-size: 2.5rem;
-        color: #1f77b4;
-        text-align: center;
-        margin-bottom: 1rem;
-        font-weight: 700;
-    }
-    .diagnosis-card {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        border-radius: 10px;
-        padding: 20px;
-        color: white;
-        margin: 10px 0;
-        box-shadow: 0 4px 10px rgba(0,0,0,0.1);
-    }
-    .high-risk { border-left: 6px solid #ff4444; }
-    .medium-risk { border-left: 6px solid #ffaa00; }
-    .low-risk { border-left: 6px solid #00C851; }
-    .upload-area {
-        border: 2px dashed #1f77b4;
-        border-radius: 8px;
-        padding: 20px;
-        text-align: center;
-        margin: 15px 0;
-    }
-    .stButton>button {
-        width: 100%;
-        border-radius: 8px;
-        height: 3rem;
-        font-size: 1.1rem;
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_HOSTS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(auth.router, prefix="/api/v1/auth", tags=["authentication"])
+app.include_router(sync.router, prefix="/api/v1/sync", tags=["synchronization"])
+app.include_router(content.router, prefix="/api/v1/content", tags=["content"])
+app.include_router(analytics.router, prefix="/api/v1/analytics", tags=["analytics"])
+app.include_router(grading.router, prefix="/api/v1/grading", tags=["grading"])
+
+@app.get("/")
+async def root():
+    return {"message": "AI Tutor Backend API", "version": "1.0.0"}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "version": "1.0.0"}
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "app.main:app",
+        host=settings.HOST,
+        port=settings.PORT,
+        reload=settings.DEBUG,
+        log_level="info"
+    )
+
+# app/core/config.py
+from pydantic_settings import BaseSettings
+from typing import List
+
+class Settings(BaseSettings):
+    # Basic settings
+    APP_NAME: str = "AI Tutor Backend"
+    DEBUG: bool = True
+    HOST: str = "0.0.0.0"
+    PORT: int = 8000
+    
+    # Database
+    DATABASE_URL: str = "postgresql://postgres:password@localhost/ai_tutor"
+    
+    # Security
+    SECRET_KEY: str = "your-secret-key-change-in-production"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30 * 24 * 60  # 30 days
+    
+    # CORS
+    ALLOWED_HOSTS: List[str] = ["*"]
+    
+    # Redis (for caching and task queue)
+    REDIS_URL: str = "redis://localhost:6379"
+    
+    # ML Models
+    MODEL_PATH: str = "./models"
+    HUGGINGFACE_CACHE: str = "./cache"
+    
+    class Config:
+        env_file = ".env"
+
+settings = Settings()
+
+# app/database.py
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from app.core.config import settings
+
+engine = create_engine(
+    settings.DATABASE_URL,
+    pool_pre_ping=True,
+    pool_recycle=300,
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+# app/models/database.py
+from sqlalchemy import Column, Integer, String, Float, DateTime, Text, Boolean, ForeignKey, JSON
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from app.database import Base
+import uuid
+
+class Student(Base):
+    __tablename__ = "students"
+    
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    name = Column(String, nullable=False)
+    grade = Column(Integer, nullable=False)
+    preferred_language = Column(String, nullable=False, default="urdu")
+    skill_mastery = Column(JSON, default=dict)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    device_id = Column(String)
+    
+    # Relationships
+    learning_sessions = relationship("LearningSession", back_populates="student")
+    student_responses = relationship("StudentResponse", back_populates="student")
+
+class Question(Base):
+    __tablename__ = "questions"
+    
+    id = Column(String, primary_key=True)
+    subject = Column(String, nullable=False)
+    topic = Column(String, nullable=False)
+    grade = Column(Integer, nullable=False)
+    skill_tags = Column(JSON, default=list)
+    difficulty_estimate = Column(Float, nullable=False)
+    prompt = Column(JSON, nullable=False)  # Multi-language prompts
+    options = Column(JSON, default=list)
+    solution_steps = Column(JSON, default=list)
+    hints = Column(JSON, default=dict)
+    answer_patterns = Column(JSON, nullable=False)
+    explanation = Column(JSON, default=dict)
+    content_version = Column(String, default="1.0")
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    
+    # Relationships
+    student_responses = relationship("StudentResponse", back_populates="question")
+
+class LearningSession(Base):
+    __tablename__ = "learning_sessions"
+    
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    student_id = Column(String, ForeignKey("students.id"), nullable=False)
+    subject = Column(String, nullable=False)
+    start_time = Column(DateTime(timezone=True), nullable=False)
+    end_time = Column(DateTime(timezone=True))
+    skills_updated = Column(JSON, default=dict)
+    synced_at = Column(DateTime(timezone=True))
+    device_id = Column(String)
+    
+    # Relationships
+    student = relationship("Student", back_populates="learning_sessions")
+    responses = relationship("StudentResponse", back_populates="session")
+
+class StudentResponse(Base):
+    __tablename__ = "student_responses"
+    
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    student_id = Column(String, ForeignKey("students.id"), nullable=False)
+    question_id = Column(String, ForeignKey("questions.id"), nullable=False)
+    session_id = Column(String, ForeignKey("learning_sessions.id"), nullable=False)
+    response = Column(Text, nullable=False)
+    response_type = Column(String, nullable=False)  # 'voice' or 'text'
+    is_correct = Column(Boolean, nullable=False)
+    partial_credit = Column(Float, nullable=False, default=0.0)
+    confidence = Column(Float, nullable=False, default=0.0)
+    timestamp = Column(DateTime(timezone=True), nullable=False)
+    synced_at = Column(DateTime(timezone=True))
+    
+    # Relationships
+    student = relationship("Student", back_populates="student_responses")
+    question = relationship("Question", back_populates="student_responses")
+    session = relationship("LearningSession", back_populates="responses")
+
+class Teacher(Base):
+    __tablename__ = "teachers"
+    
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    email = Column(String, unique=True, nullable=False)
+    hashed_password = Column(String, nullable=False)
+    name = Column(String, nullable=False)
+    school = Column(String)
+    subjects = Column(JSON, default=list)
+    grades = Column(JSON, default=list)
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+class ContentBundle(Base):
+    __tablename__ = "content_bundles"
+    
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    version = Column(String, nullable=False)
+    grade = Column(Integer, nullable=False)
+    subject = Column(String, nullable=False)
+    language = Column(String, nullable=False)
+    file_path = Column(String, nullable=False)
+    file_size = Column(Integer, nullable=False)
+    checksum = Column(String, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+# app/schemas/sync.py
+from pydantic import BaseModel
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+
+class StudentResponseSchema(BaseModel):
+    id: str
+    student_id: str
+    question_id: str
+    session_id: str
+    response: str
+    response_type: str
+    is_correct: bool
+    partial_credit: float
+    confidence: float
+    timestamp: datetime
+
+class LearningSessionSchema(BaseModel):
+    id: str
+    student_id: str
+    subject: str
+    start_time: datetime
+    end_time: Optional[datetime] = None
+    skills_updated: Dict[str, float] = {}
+
+class SyncPayload(BaseModel):
+    device_id: str
+    sessions: List[LearningSessionSchema]
+    responses: List[StudentResponseSchema]
+    last_sync_time: datetime
+
+class SyncResponse(BaseModel):
+    success: bool
+    synced_sessions: int
+    synced_responses: int
+    new_content_available: bool
+    content_version: Optional[str] = None
+
+# app/schemas/student.py
+from pydantic import BaseModel
+from typing import Dict, Optional
+from datetime import datetime
+
+class StudentCreate(BaseModel):
+    name: str
+    grade: int
+    preferred_language: str = "urdu"
+
+class StudentResponse(BaseModel):
+    id: str
+    name: str
+    grade: int
+    preferred_language: str
+    skill_mastery: Dict[str, float]
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+# app/routers/auth.py
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from sqlalchemy.orm import Session
+from datetime import datetime, timedelta
+from typing import Optional
+import jwt
+from passlib.context import CryptContext
+
+from app.database import get_db
+from app.models.database import Teacher
+from app.core.config import settings
+from pydantic import BaseModel
+
+router = APIRouter()
+security = HTTPBearer()
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+class LoginRequest(BaseModel):
+    email: str
+    password: str
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm="HS256")
+    return encoded_jwt
+
+def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    try:
+        payload = jwt.decode(credentials.credentials, settings.SECRET_KEY, algorithms=["HS256"])
+        email: str = payload.get("sub")
+        if email is None:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid authentication credentials",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+        return email
+    except jwt.PyJWTError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+@router.post("/login", response_model=TokenResponse)
+async def login(request: LoginRequest, db: Session = Depends(get_db)):
+    teacher = db.query(Teacher).filter(Teacher.email == request.email).first()
+    if not teacher or not verify_password(request.password, teacher.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": teacher.email}, expires_delta=access_token_expires
+    )
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.get("/me")
+async def get_current_user(email: str = Depends(verify_token), db: Session = Depends(get_db)):
+    teacher = db.query(Teacher).filter(Teacher.email == email).first()
+    if not teacher:
+        raise HTTPException(status_code=404, detail="Teacher not found")
+    return {
+        "id": teacher.id,
+        "email": teacher.email,
+        "name": teacher.name,
+        "school": teacher.school,
+        "subjects": teacher.subjects,
+        "grades": teacher.grades
     }
-</style>
-""", unsafe_allow_html=True)
-
-# Initialize session state for Hugging Face compatibility
-if 'diagnosis_history' not in st.session_state:
-    st.session_state.diagnosis_history = []
-if 'models_loaded' not in st.session_state:
-    st.session_state.models_loaded = False
-if 'model_manager' not in st.session_state:
-    st.session_state.model_manager = None
-
-@st.cache_resource(show_spinner=False)
-def initialize_models():
-    """Initialize models with caching for Hugging Face"""
+
+# app/routers/sync.py
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from sqlalchemy import and_
+from datetime import datetime
+from typing import List
+
+from app.database import get_db
+from app.models.database import Student, LearningSession, StudentResponse, Question
+from app.schemas.sync import SyncPayload, SyncResponse
+from app.routers.auth import verify_token
+
+router = APIRouter()
+
+@router.post("/push", response_model=SyncResponse)
+async def sync_push(
+    payload: SyncPayload,
+    db: Session = Depends(get_db),
+    current_user: str = Depends(verify_token)
+):
+    """
+    Receive and process synced data from mobile devices
+    """
     try:
-        model_manager = load_medical_models()
-        if model_manager:
-            st.session_state.models_loaded = True
-            st.session_state.model_manager = model_manager
-            return True
-        return False
-    except Exception as e:
-        st.error(f"Model initialization failed: {str(e)}")
-        return False
-
-def main():
-    # Title and description
-    st.markdown('<h1 class="main-header">🏥 Rural Diagnostic Assistant</h1>', unsafe_allow_html=True)
-    st.markdown("""
-    **AI-Powered Medical Imaging Analysis for Rural Healthcare**  
-    *Accurate detection of TB, Pneumonia, and pregnancy risks using state-of-the-art AI models*
-    """)
-    
-    # Sidebar optimized for Hugging Face
-    with st.sidebar:
-        st.header("⚙️ Configuration")
+        synced_sessions = 0
+        synced_responses = 0
         
-        analysis_type = st.radio(
-            "Select Analysis Type",
-            ["Chest X-Ray (TB/Pneumonia)", "Ultrasound (Pregnancy Risk)"],
-            help="Choose the type of medical image to analyze"
-        )
+        # Process learning sessions
+        for session_data in payload.sessions:
+            # Check if session already exists
+            existing_session = db.query(LearningSession).filter(
+                LearningSession.id == session_data.id
+            ).first()
+            
+            if not existing_session:
+                # Create new session
+                new_session = LearningSession(
+                    id=session_data.id,
+                    student_id=session_data.student_id,
+                    subject=session_data.subject,
+                    start_time=session_data.start_time,
+                    end_time=session_data.end_time,
+                    skills_updated=session_data.skills_updated,
+                    device_id=payload.device_id,
+                    synced_at=datetime.utcnow()
+                )
+                db.add(new_session)
+                synced_sessions += 1
         
-        # Hugging Face doesn't support external API keys well, so we'll use local models
-        st.info("🔒 Privacy Focused: All analysis happens locally on our servers")
+        # Process student responses
+        for response_data in payload.responses:
+            # Check if response already exists
+            existing_response = db.query(StudentResponse).filter(
+                StudentResponse.id == response_data.id
+            ).first()
+            
+            if not existing_response:
+                # Create new response
+                new_response = StudentResponse(
+                    id=response_data.id,
+                    student_id=response_data.student_id,
+                    question_id=response_data.question_id,
+                    session_id=response_data.session_id,
+                    response=response_data.response,
+                    response_type=response_data.response_type,
+                    is_correct=response_data.is_correct,
+                    partial_credit=response_data.partial_credit,
+                    confidence=response_data.confidence,
+                    timestamp=response_data.timestamp,
+                    synced_at=datetime.utcnow()
+                )
+                db.add(new_response)
+                synced_responses += 1
         
-        st.header("👤 Patient Information")
-        patient_id = st.text_input("Patient ID", value="PT-001", placeholder="Enter patient ID")
-        patient_age = st.slider("Age", 0, 120, 35)
-        patient_gender = st.selectbox("Gender", ["Male", "Female", "Other"])
+        # Commit all changes
+        db.commit()
         
-        # Quick actions
-        st.header("🚀 Quick Actions")
-        if st.button("🔄 Clear History"):
-            st.session_state.diagnosis_history = []
-            st.rerun()
+        # Check for new content
+        # For now, assume no new content available
+        new_content_available = False
+        content_version = None
         
-        if st.button("ℹ️ Show Help"):
-            st.info("""
-            **How to use:**
-            1. Select analysis type
-            2. Upload medical image
-            3. Click 'Analyze Image'
-            4. Review results
-            
-            **Supported formats:** JPG, PNG, DICOM
-            **Accuracy:** >90% on clinical datasets
-            """)
+        return SyncResponse(
+            success=True,
+            synced_sessions=synced_sessions,
+            synced_responses=synced_responses,
+            new_content_available=new_content_available,
+            content_version=content_version
+        )
+        
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Sync failed: {str(e)}")
+
+@router.get("/status/{device_id}")
+async def sync_status(
+    device_id: str,
+    db: Session = Depends(get_db)
+):
+    """
+    Get sync status for a device
+    """
+    # Count unsynced items for this device
+    unsynced_sessions = db.query(LearningSession).filter(
+        and_(
+            LearningSession.device_id == device_id,
+            LearningSession.synced_at.is_(None)
+        )
+    ).count()
+    
+    unsynced_responses = db.query(StudentResponse).filter(
+        and_(
+            StudentResponse.synced_at.is_(None)
+        )
+    ).count()  # Note: StudentResponse doesn't have device_id, so checking all
     
-    # Main content area
-    col1, col2 = st.columns([1, 1])
+    return {
+        "device_id": device_id,
+        "unsynced_sessions": unsynced_sessions,
+        "unsynced_responses": unsynced_responses,
+        "last_sync": datetime.utcnow().isoformat()
+    }
+
+# app/routers/content.py
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from typing import List, Optional
+
+from app.database import get_db
+from app.models.database import Question, ContentBundle
+from app.routers.auth import verify_token
+
+router = APIRouter()
+
+@router.get("/questions")
+async def get_questions(
+    grade: Optional[int] = Query(None, description="Grade level"),
+    subject: Optional[str] = Query(None, description="Subject"),
+    language: Optional[str] = Query("urdu", description="Language"),
+    limit: int = Query(50, description="Number of questions to return"),
+    offset: int = Query(0, description="Offset for pagination"),
+    db: Session = Depends(get_db)
+):
+    """
+    Get questions filtered by grade, subject, and language
+    """
+    query = db.query(Question)
     
-    with col1:
-        st.header("📤 Image Upload")
+    if grade:
+        query = query.filter(Question.grade == grade)
+    if subject:
+        query = query.filter(Question.subject == subject)
+    
+    questions = query.offset(offset).limit(limit).all()
+    
+    # Filter questions that have content in the requested language
+    filtered_questions = []
+    for question in questions:
+        if language in question.prompt:
+            question_data = {
+                "id": question.id,
+                "subject": question.subject,
+                "topic": question.topic,
+                "grade": question.grade,
+                "skill_tags": question.skill_tags,
+                "difficulty_estimate": question.difficulty_estimate,
+                "prompt": question.prompt.get(language, question.prompt.get('english', '')),
+                "options": question.options,
+                "solution_steps": question.solution_steps,
+                "hints": question.hints.get(language, question.hints.get('english', [])),
+                "answer_patterns": question.answer_patterns,
+                "explanation": question.explanation.get(language, question.explanation.get('english', ''))
+            }
+            filtered_questions.append(question_data)
+    
+    return {
+        "questions": filtered_questions,
+        "total": len(filtered_questions),
+        "grade": grade,
+        "subject": subject,
+        "language": language
+    }
+
+@router.get("/bundle")
+async def get_content_bundle(
+    version: Optional[str] = Query("latest", description="Content version"),
+    grade: Optional[int] = Query(None, description="Grade level"),
+    subject: Optional[str] = Query(None, description="Subject"),
+    language: str = Query("urdu", description="Language"),
+    db: Session = Depends(get_db)
+):
+    """
+    Get content bundle for offline use
+    """
+    query = db.query(ContentBundle)
+    
+    if version != "latest":
+        query = query.filter(ContentBundle.version == version)
+    if grade:
+        query = query.filter(ContentBundle.grade == grade)
+    if subject:
+        query = query.filter(ContentBundle.subject == subject)
+    if language:
+        query = query.filter(ContentBundle.language == language)
+    
+    # Get the latest version if "latest" is requested
+    if version == "latest":
+        bundle = query.order_by(ContentBundle.created_at.desc()).first()
+    else:
+        bundle = query.first()
+    
+    if not bundle:
+        raise HTTPException(status_code=404, detail="Content bundle not found")
+    
+    return {
+        "id": bundle.id,
+        "version": bundle.version,
+        "grade": bundle.grade,
+        "subject": bundle.subject,
+        "language": bundle.language,
+        "file_path": bundle.file_path,
+        "file_size": bundle.file_size,
+        "checksum": bundle.checksum,
+        "created_at": bundle.created_at
+    }
+
+@router.post("/questions")
+async def create_question(
+    question_data: dict,
+    current_user: str = Depends(verify_token),
+    db: Session = Depends(get_db)
+):
+    """
+    Create a new question (teacher only)
+    """
+    try:
+        new_question = Question(**question_data)
+        db.add(new_question)
+        db.commit()
+        db.refresh(new_question)
         
-        # Upload section with better UX for Hugging Face
-        uploaded_file = st.file_uploader(
-            "Choose medical image file",
-            type=['png', 'jpg', 'jpeg', 'dcm'],
-            help="Upload X-Ray, Chest Scan, or Ultrasound image"
+        return {"message": "Question created successfully", "id": new_question.id}
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Failed to create question: {str(e)}")
+
+# app/routers/grading.py
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from typing import Dict, Any
+from app.ml.grading_engine import GradingEngine
+
+router = APIRouter()
+
+class GradingRequest(BaseModel):
+    student_response: str
+    question_id: str
+    answer_patterns: list
+    response_type: str = "text"
+    language: str = "urdu"
+
+class GradingResult(BaseModel):
+    is_correct: bool
+    partial_credit: float
+    confidence: float
+    feedback: str
+
+@router.post("/grade", response_model=GradingResult)
+async def grade_response(request: GradingRequest):
+    """
+    Grade a student response using ML models
+    """
+    try:
+        grading_engine = GradingEngine()
+        result = await grading_engine.grade_response(
+            response=request.student_response,
+            answer_patterns=request.answer_patterns,
+            response_type=request.response_type,
+            language=request.language
         )
         
-        # Sample images for demo
-        st.subheader("🎯 Try Sample Images")
-        col1a, col2a = st.columns(2)
-        with col1a:
-            if st.button("Sample Chest X-Ray", use_container_width=True):
-                # Load sample image
-                sample_image = Image.open('./assets/sample_xray.jpg')
-                analyze_image(sample_image, "Chest X-Ray (TB/Pneumonia)", "Sample Patient")
-        with col2a:
-            if st.button("Sample Ultrasound", use_container_width=True):
-                sample_image = Image.open('./assets/sample_ultrasound.jpg')
-                analyze_image(sample_image, "Ultrasound (Pregnancy Risk)", "Sample Patient")
+        return GradingResult(
+            is_correct=result["is_correct"],
+            partial_credit=result["partial_credit"],
+            confidence=result["confidence"],
+            feedback=result.get("feedback", "")
+        )
         
-        if uploaded_file is not None:
-            # Process uploaded image
-            with st.spinner("Processing image..."):
-                image = process_uploaded_image(uploaded_file)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Grading failed: {str(e)}")
+
+# app/routers/analytics.py
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from sqlalchemy import func, and_
+from datetime import datetime, timedelta
+from typing import Optional, List
+
+from app.database import get_db
+from app.models.database import Student, StudentResponse, LearningSession, Question
+from app.routers.auth import verify_token
+
+router = APIRouter()
+
+@router.get("/student/{student_id}/progress")
+async def get_student_progress(
+    student_id: str,
+    days: int = Query(30, description="Number of days to analyze"),
+    db: Session = Depends(get_db),
+    current_user: str = Depends(verify_token)
+):
+    """
+    Get detailed progress analytics for a student
+    """
+    # Get student info
+    student = db.query(Student).filter(Student.id == student_id).first()
+    if not student:
+        raise HTTPException(status_code=404, detail="Student not found")
+    
+    # Date range
+    end_date = datetime.utcnow()
+    start_date = end_date - timedelta(days=days)
+    
+    # Get responses in date range
+    responses = db.query(StudentResponse).filter(
+        and_(
+            StudentResponse.student_id == student_id,
+            StudentResponse.timestamp >= start_date,
+            StudentResponse.timestamp <= end_date
+        )
+    ).all()
+    
+    # Calculate metrics
+    total_responses = len(responses)
+    correct_responses = sum(1 for r in responses if r.is_correct)
+    accuracy = correct_responses / total_responses if total_responses > 0 else 0
+    
+    # Subject-wise breakdown
+    subject_stats = {}
+    for response in responses:
+        question = db.query(Question).filter(Question.id == response.question_id).first()
+        if question:
+            subject = question.subject
+            if subject not in subject_stats:
+                subject_stats[subject] = {"total": 0, "correct": 0, "partial_credit": 0}
             
-            if image:
-                st.success("✅ Image processed successfully")
-                st.image(image, caption="Uploaded Image", use_column_width=True)
-                
-                # Analyze button
-                if st.button("🔍 Analyze Image", type="primary", use_container_width=True):
-                    analyze_image(image, analysis_type, patient_id)
-    
-    with col2:
-        st.header("📋 Analysis Results")
-        
-        if len(st.session_state.diagnosis_history) > 0:
-            latest = st.session_state.diagnosis_history[-1]
-            display_results(latest['results'], latest['analysis_type'])
-        else:
-            # Show placeholder with instructions
-            st.info("👆 Upload an image or try sample images to see analysis results")
-            st.image("https://images.unsplash.com/photo-1576091160399-112ba8d25d1f?w=400", 
-                    caption="Medical Imaging Analysis", use_column_width=True)
+            subject_stats[subject]["total"] += 1
+            if response.is_correct:
+                subject_stats[subject]["correct"] += 1
+            subject_stats[subject]["partial_credit"] += response.partial_credit
+    
+    # Calculate subject accuracies
+    for subject in subject_stats:
+        stats = subject_stats[subject]
+        stats["accuracy"] = stats["correct"] / stats["total"] if stats["total"] > 0 else 0
+        stats["avg_partial_credit"] = stats["partial_credit"] / stats["total"] if stats["total"] > 0 else 0
+    
+    # Skill mastery trends
+    skill_mastery = student.skill_mastery or {}
+    
+    # Recent sessions
+    recent_sessions = db.query(LearningSession).filter(
+        and_(
+            LearningSession.student_id == student_id,
+            LearningSession.start_time >= start_date
+        )
+    ).order_by(LearningSession.start_time.desc()).limit(10).all()
+    
+    session_data = []
+    for session in recent_sessions:
+        session_responses = [r for r in responses if r.session_id == session.id]
+        session_accuracy = sum(1 for r in session_responses if r.is_correct) / len(session_responses) if session_responses else 0
         
-        # Diagnosis History
-        if len(st.session_state.diagnosis_history) > 0:
-            st.header("📚 Recent Diagnoses")
-            for i, entry in enumerate(reversed(st.session_state.diagnosis_history[-3:])):
-                with st.expander(f"🩺 {entry['patient_id']} - {entry['timestamp'].split(' ')[0]}"):
-                    st.write(f"**Type:** {entry['analysis_type']}")
-                    st.write(f"**Condition:** {entry['results']['condition']}")
-                    st.write(f"**Confidence:** {entry['results']['confidence']:.1f}%")
-                    st.write(f"**Risk:** {entry['results']['risk_level']}")
-
-def analyze_image(image, analysis_type, patient_id):
-    """Analyze medical image with AI models"""
-    # Initialize models if not loaded
-    if not st.session_state.models_loaded:
-        with st.spinner("🔄 Loading AI models (first time may take a minute)..."):
-            success = initialize_models()
-            if not success:
-                st.error("❌ Failed to load AI models. Please refresh and try again.")
-                return
-    
-    # Perform analysis
-    with st.spinner("🔬 Analyzing image with medical AI..."):
-        try:
-            if "Chest" in analysis_type:
-                results = analyze_chest_xray(st.session_state.model_manager, image)
-            else:
-                results = analyze_ultrasound(st.session_state.model_manager, image)
-            
-            # Save to history
-            diagnosis_entry = {
-                'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                'patient_id': patient_id,
-                'analysis_type': analysis_type,
-                'results': results,
-                'image': image.copy()
-            }
-            st.session_state.diagnosis_history.append(diagnosis_entry)
-            
-            st.success("✅ Analysis complete!")
-            st.rerun()
-            
-        except Exception as e:
-            st.error(f"❌ Analysis failed: {str(e)}")
-            # Fallback to simulated results for demo
-            results = get_fallback_results(analysis_type)
-            diagnosis_entry = {
-                'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                'patient_id': patient_id,
-                'analysis_type': analysis_type,
-                'results': results,
-                'image': image.copy()
-            }
-            st.session_state.diagnosis_history.append(diagnosis_entry)
-            st.rerun()
-
-def display_results(results, analysis_type):
-    """Display analysis results with medical UI"""
-    risk_class = results['risk_level'].lower().replace(" ", "-")
-    
-    st.markdown(f'<div class="diagnosis-card {risk_class}">', unsafe_allow_html=True)
-    
-    # Header with condition and confidence
-    col1, col2 = st.columns([3, 1])
-    
-    with col1:
-        st.subheader(results['condition'])
-        st.write(f"**Analysis Type:** {analysis_type}")
-    
-    with col2:
-        # Confidence indicator
-        confidence_color = "#00C851" if results['confidence'] > 85 else "#ffaa00" if results['confidence'] > 70 else "#ff4444"
-        st.markdown(f"""
-        <div style="text-align: center;">
-            <div style="font-size: 2rem; color: {confidence_color}; font-weight: bold;">
-                {results['confidence']:.1f}%
-            </div>
-            <div style="font-size: 0.9rem;">Confidence</div>
-        </div>
-        """, unsafe_allow_html=True)
-    
-    # Risk level badge
-    risk_color = {"High": "#ff4444", "Medium": "#ffaa00", "Low": "#00C851"}
-    st.markdown(f"""
-    <div style="background-color: {risk_color[results['risk_level']]}; color: white; 
-                padding: 5px 15px; border-radius: 20px; display: inline-block; 
-                font-weight: bold; margin-bottom: 15px;">
-        {results['risk_level']} Risk
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Findings
-    st.write("**🔍 Clinical Findings:**")
-    st.write(results['findings'])
-    
-    # Recommendations
-    st.write("**💡 Recommendations:**")
-    for i, rec in enumerate(results['recommendations'], 1):
-        st.write(f"{i}. {rec}")
-    
-    # Confidence visualization
-    if 'detailed_scores' in results and results['detailed_scores']:
-        st.write("**📊 Detailed Scores:**")
-        scores = results['detailed_scores']
-        for condition, score in scores.items():
-            st.progress(score/100, text=f"{condition.replace('_', ' ').title()}: {score:.1f}%")
-    
-    st.markdown('</div>', unsafe_allow_html=True)
-
-def get_fallback_results(analysis_type):
-    """Fallback results for demo purposes"""
-    if "Chest" in analysis_type:
-        return {
-            'condition': 'Pneumonia Detected',
-            'confidence': 92.5,
-            'risk_level': 'High',
-            'recommendations': [
-                'Consult with pulmonologist urgently',
-                'Start antibiotic treatment',
-                'Chest CT scan for confirmation',
-                'Monitor oxygen saturation'
-            ],
-            'findings': 'Consolidation observed in right lower lobe consistent with bacterial pneumonia',
-            'detailed_scores': {'pneumonia': 92.5, 'tuberculosis': 15.2, 'normal': 7.5}
-        }
-    else:
-        return {
-            'condition': 'Normal Pregnancy',
-            'confidence': 94.2,
-            'risk_level': 'Low',
-            'recommendations': [
-                'Continue routine prenatal care',
-                'Next ultrasound in 4 weeks',
-                'Standard prenatal vitamin regimen',
-                'Monitor fetal movements'
-            ],
-            'findings': 'Normal fetal development at 20 weeks gestation, appropriate biometric measurements',
-            'detailed_scores': {'normal': 94.2, 'ectopic_risk': 3.1, 'placental_issue': 2.7}
-        }
-
-# Footer for Hugging Face
-st.markdown("---")
-st.markdown("""
-<div style='text-align: center'>
-    <p>Rural Diagnostic Assistant - Deployed on Hugging Face Spaces | 
-    <a href='https://huggingface.co/spaces' target='_blank'>Learn More</a></p>
-</div>
-""", unsafe_allow_html=True)
+        session_data.append({
+            "id": session.id,
+            "subject": session.subject,
+            "start_time": session.start_time,
+            "end_time": session.end_time,
+            "responses": len(session_responses),
+            "accuracy": session_accuracy
+        })
+    
+    return {
+        "student": {
+            "id": student.id,
+            "name": student.name,
+            "grade": student.grade,
+            "preferred_language": student.preferred_language
+        },
+        "period": {
+            "days": days,
+            "start_date": start_date,
+            "end_date": end_date
+        },
+        "overall": {
+            "total_responses": total_responses,
+            "correct_responses": correct_responses,
+            "accuracy": accuracy,
+            "sessions": len(recent_sessions)
+        },
+        "by_subject": subject_stats,
+        "skill_mastery": skill_mastery,
+        "recent_sessions": session_data
+    }
 
-if __name__ == "__main__":
-    main()
+@router.get("/class/overview")
+async def get_class_overview(
+    grade: Optional[int] = Query(None, description="Grade to filter"),
+    days: int = Query(7, description="Number of days to analyze"),
+    db: Session = Depends(get_db),
+    current_user: str = Depends(verify_token)
+):
+    """
+    Get class-level analytics overview
+    """
+    # Date range
+    end_date = datetime.utcnow()
+    start_date = end_date - timedelta(days=days)
+    
+    # Get students
+    students_query = db.query(Student)
+    if grade:
+        students_query = students_query.filter(Student.grade == grade)
+    students = students_query.all()
+    
+    # Get recent responses for these students
+    student_ids = [s.id for s in students]
+    responses = db.query(StudentResponse).filter(
+        and_(
+            StudentResponse.student_id.in_(student_ids),
+            StudentResponse.timestamp >= start_date
+        )
+    ).all()
+    
+    # Overall statistics
+    total_students = len(students)
+    active_students = len(set(r.student_id for r in responses))
+    total_responses = len(responses)
+    correct_responses = sum(1 for r in responses if r.is_correct)
+    overall_accuracy = correct_responses / total_responses if total_responses > 0 else 0
+    
+    # Student performance breakdown
+    student_performance = []
+    for student in students:
+        student_responses = [r for r in responses if r.student_id == student.id]
+        if student_responses:
+            accuracy = sum(1 for r in student_responses if r.is_correct) / len(student_responses)
+            student_performance.appen