chore: code cleanup

Backend/app/api/v1/api.py

@@ -1,5 +1,5 @@
 from fastapi import APIRouter
-from app.api.v1.endpoints import auth, students, quiz
+from app.api.v1.endpoints import auth, quiz
 
 api_router = APIRouter()
 
@@ -10,14 +10,8 @@ api_router.include_router(
     tags=["Authentication"]
 )
 
-# Include student routes
-api_router.include_router(
-    students.router,
-    prefix="/students",
-    tags=["Students"]
-)
 
-# Include student routes
+# Include quiz routes
 api_router.include_router(
     quiz.router,
     prefix="/quiz",

Backend/app/api/v1/endpoints/notes.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from chromadb import AsyncHttpClient
+from app.models import User
+from app.api.deps import get_db, get_current_user, get_chroma_client
+from app.schema import Quiz_input, QuizOutput, IngestRequest
+from .prompts import SYSTEM_PROMPT
+from fastapi import APIRouter, Depends, HTTPException
+from chromadb.api.models.Collection import Collection # Import Collection type
+from app.api.deps import get_chroma_collection
+from app.llm import call_llm
+import uuid

Backend/app/api/v1/endpoints/students.py

@@ -1,178 +0,0 @@
-from fastapi import APIRouter, HTTPException, Depends, status
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select
-from typing import List
-from app.schema import StudentCreate, StudentUpdate, StudentResponse
-from app.models import Student, User
-from app.api.deps import get_db, get_current_user
-
-router = APIRouter()
-
-@router.post("/", response_model=StudentResponse, status_code=status.HTTP_201_CREATED)
-async def create_student(
-    student: StudentCreate,
-    db:AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    try:
-        result = await db.execute(select(Student).filter(Student.email == student.email))
-        existing_user = result.scalar_one_or_none()
-
-        if existing_user:
-            raise HTTPException(
-                status_code= status.HTTP_400_BAD_REQUEST,
-                detail=f'student with email {student.email} already exists'
-            )
-        
-        new_student = Student(**student.model_dump())
-        db.add(new_student)
-        await db.commit()
-        await db.refresh(new_student)
-
-        return new_student
-    except HTTPException:
-        raise
-    except Exception as e :
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f'failed to create student: {str(e)}'
-        )
-@router.get("/", response_model=List[StudentResponse])
-async def get_all_students(
-    skip: int = 0,
-    limit: int = 100,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """Get all students with pagination (Protected)"""
-    try:
-        result = await db.execute(
-            select(Student).offset(skip).limit(limit)
-        )
-        students = result.scalars().all()
-        return students
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to fetch students: {str(e)}"
-        )
-
-
-@router.get("/{student_id}", response_model=StudentResponse)
-async def get_student(
-    student_id: int,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """Get a specific student by ID (Protected)"""
-    try:
-        result = await db.execute(select(Student).filter(Student.id == student_id))
-        student = result.scalar_one_or_none()
-        
-        if not student:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Student with ID {student_id} not found"
-            )
-        
-        return student
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to fetch student: {str(e)}"
-        )
-
-
-@router.put("/{student_id}", response_model=StudentResponse)
-async def update_student(
-    student_id: int,
-    student_update: StudentUpdate,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """Update a student's information (Protected)"""
-    try:
-        result = await db.execute(select(Student).filter(Student.id == student_id))
-        student = result.scalar_one_or_none()
-        
-        if not student:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Student with ID {student_id} not found"
-            )
-        
-        # Update only provided fields
-        update_data = student_update.model_dump(exclude_unset=True)
-        
-        # Check email uniqueness if email is being updated
-        if "email" in update_data:
-            result = await db.execute(
-                select(Student).filter(
-                    Student.email == update_data["email"],
-                    Student.id != student_id
-                )
-            )
-            existing = result.scalar_one_or_none()
-            if existing:
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail=f"Email {update_data['email']} is already in use"
-                )
-        
-        for key, value in update_data.items():
-            setattr(student, key, value)
-        
-        await db.commit()
-        await db.refresh(student)
-        
-        return student
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to update student: {str(e)}"
-        )
-
-
-@router.patch("/{student_id}", response_model=StudentResponse)
-async def partial_update_student(
-    student_id: int,
-    student_update: StudentUpdate,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """Partially update a student (same as PUT for this implementation) (Protected)"""
-    return await update_student(student_id, student_update, db, current_user)
-
-
-@router.delete("/{student_id}", status_code=status.HTTP_204_NO_CONTENT)
-async def delete_student(
-    student_id: int,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """Delete a student (Protected)"""
-    try:
-        result = await db.execute(select(Student).filter(Student.id == student_id))
-        student = result.scalar_one_or_none()
-        
-        if not student:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Student with ID {student_id} not found"
-            )
-        
-        await db.delete(student)
-        await db.commit()
-        
-        return None
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to delete student: {str(e)}"
-        )

Backend/app/config.py

@@ -6,7 +6,7 @@ class Settings(BaseSettings):
     ALGORITHM: str = "HS256"
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
 
-    APP_NAME: str = "Student Management API"
+    APP_NAME: str = "prepAI"
     APP_VERSION: str = "1.0.0"
     APP_DESCRIPTION: str = "FastAPI + PostgreSQL with SQLAlchemy async"
 

Backend/app/models/__init__.py

@@ -1,4 +1,4 @@
-from app.models.tables import Student, User
+from app.models.tables import User
 
 
-__all__ = ["Student", "User"]
+__all__ = [ "User"]

Backend/app/models/tables.py

@@ -4,14 +4,6 @@ from datetime import datetime
 from app.database import Base
 
 
-class Student(Base):
-    __tablename__ = "students"
-
-    id: Mapped[int] = mapped_column(primary_key=True, index= True)
-    name: Mapped[str] = mapped_column(String(100))
-    email: Mapped[str] = mapped_column(String(100), unique=True, index=True)
-    created_at: Mapped[datetime] = mapped_column(default=datetime.now())
-
 class User(Base):
     __tablename__ = "users"
 

Backend/app/schema/__init__.py

@@ -1,3 +1,3 @@
-from app.schema.models import StudentCreate, StudentUpdate, StudentResponse, UserCreate, Token, LoginRequest, Quiz_input, QuizOutput, IngestRequest
+from app.schema.models import UserCreate, Token, LoginRequest, Quiz_input, QuizOutput, IngestRequest
 
-__all__ = ["StudentCreate", "StudentUpdate", "StudentResponse", "UserCreate", "Token", "LoginRequest", "Quiz_input", "QuizOutput", "IngestRequest"]
+__all__ = ["UserCreate", "Token", "LoginRequest", "Quiz_input", "QuizOutput", "IngestRequest"]

Backend/app/schema/models.py

@@ -2,30 +2,6 @@ from pydantic import BaseModel, EmailStr, Field, field_validator, ConfigDict
 from typing import  Optional, Literal, List
 from datetime import datetime
 
-class StudentBase(BaseModel):
-    name: str = Field(..., min_length=2, max_length=100)
-    email: EmailStr = Field(...)
-
-    @field_validator("name")
-    def validate_name(cls, v):
-        if not v.strip():
-            raise ValueError('Name cannot be empty or just whitespace')
-        return v.strip()
-
-class StudentCreate(StudentBase):
-    pass
-
-class StudentUpdate(BaseModel):
-    name: Optional[str] = Field(None, min_length=2, max_length=100)
-    email: Optional[EmailStr] = None
-
-class StudentResponse(StudentBase):
-    id: int
-    created_at: datetime
-
-    model_config = ConfigDict(from_attributes=True)
-
-
 class UserCreate(BaseModel):
     username: str = Field(..., min_length=3, max_length=50)
     email: EmailStr = Field(...)