saving

.gitignore

@@ -219,4 +219,4 @@ playground/psql_driver.ipynb
 Backend/Time complexity cheatsheet.pdf
 test/1000-data-science-questions-answers.json
 
-test/test.ipynb
+test/test.ipynb

Backend/app/api/deps.py

@@ -6,6 +6,8 @@ from jose import JWTError, jwt
 from app.database import async_session_maker
 from app.models import User
 from app.config import settings
+from fastapi import Request
+from chromadb import AsyncHttpClient
 
 security  = HTTPBearer()
 
@@ -48,3 +50,10 @@ async def get_current_user(
     
     return user
 
+
+
+async def get_chroma_client(request: Request) -> AsyncHttpClient:
+    client = getattr(request.app.state, "chroma_client", None)
+    if client is None:
+        raise RuntimeError("ChromaDB client is not initialized in App State.")
+    return client

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

@@ -0,0 +1,50 @@
+
+
+SYSTEM_PROMPT = """
+You are an AI question-generation agent.
+Your task is to generate a batch of 10 high-quality MCQ questions strictly based on the following inputs:
+
+- {parsed_info}
+- {user_prompt}
+- {mcq_style}
+- {retrieved_docs}
+
+-----------------------
+GENERATION RULES
+-----------------------
+1. Generate exactly 10 MCQs.
+2. Use only information from the provided inputs.
+3. Each question must be unambiguous, factual, and supported by the given data.
+4. Each MCQ MUST have exactly four options.
+5. Only one correct answer is allowed.
+6. Explanations must be short and directly justify the answer.
+7. `User_response` must ALWAYS remain an empty string.
+8. Output MUST be a valid JSON array containing 10 objects.
+9. Output MUST contain nothing except the JSON array (no commentary or markdown).
+
+-----------------------
+REQUIRED JSON FORMAT FOR EACH QUESTION
+-----------------------
+{
+    "question": "Which of the following CLI command can also be used to rename files?",
+    "options": [
+        "rm",
+        "mv",
+        "rm -r",
+        "none of the mentioned"
+    ],
+    "answer": "b",
+    "explanation": "Explanation: mv stands for move.",
+    "User_response": ""
+}
+
+-----------------------
+ANSWER KEY RULES
+-----------------------
+- 'a' -> options[0]
+- 'b' -> options[1]
+- 'c' -> options[2]
+- 'd' -> options[3]
+
+Strictly follow the JSON structure and generate exactly 10 MCQs.
+"""

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

@@ -1,24 +1,37 @@
-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
+from fastapi import APIRouter, Depends, HTTPException
+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
+from prompts import SYSTEM_PROMPT
 
 router = APIRouter()
 
+
+
+
+
+
 # @router.post("/", response_model=StudentResponse, status_code=status.HTTP_201_CREATED)
 # async def generate_quiz(
 #     Input_model: Quiz_input, db: AsyncSession = Depends(get_db), 
 #     current_user: User = Depends(get_current_user)):
 
-#     try:
-#         if Input_model.parsed_doc and Input_model.user_prompt and Input_model.choice:
+    
+#     if Input_model.parsed_doc and Input_model.user_prompt and Input_model.choice:
+#         prompt = prompt_builder(Input_model.parsed_doc, Input_model.user_prompt, Input_model.choice)
+
 
 
+# #--------Helper Functions--------#
 
-#--------Helper Functions--------#
+# def get_embed()
 
-def prompt_builder()
+# def prompt_builder(parsed_doc:str, user_prompt:str, choice:str):
+#     retrieved_docs = get_embed()
+#     prompt = SYSTEM_PROMPT.format(
+#         parsed_info=parsed_doc,
+#         user_prompt=user_prompt,
+#         mcq_style=choice,
+#         # retrieved_docs=
+#     )

Backend/app/config.py

@@ -12,6 +12,10 @@ class Settings(BaseSettings):
 
     CORS_ORIGINS: list = ["*"]
 
+    chroma_host: str
+    chroma_port: int
+    chroma_collection: str
+
     class Config:
         env_file = ".env"
         extra = "ignore"  # quiz

Backend/app/main.py

@@ -5,6 +5,8 @@ from datetime import datetime
 from app.config import settings
 from app.database import engine, Base
 from app.api.v1.api import api_router
+import chromadb
+
 
 
 @asynccontextmanager
@@ -16,6 +18,11 @@ async def lifespan(app: FastAPI):
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
     
+    app.state.chroma_client = await chromadb.AsyncHttpClient(
+        host=settings.chroma_host,
+        port=settings.chroma_port
+    )
+
     print("✅ Tables ready!")
     yield
     print("🧹 Server shutting down:", datetime.now())

Backend/app/services/inital_data.py

@@ -0,0 +1,14 @@
+from chromadb import AsyncHttpClient
+from chromadb.utils import embedding_functions
+
+async def ingest_start(client: AsyncHttpClient, collection_name:str):
+
+    try:
+        await client.get_collection(name=collection_name)
+        print(f"Collection '{collection_name}' already exists. Skipping initial ingestion.")
+        return
+    except Exception:
+        print(f"Collection '{collection_name}' not found. Starting initial ingestion...")
+        pass
+
+

Backend/app/vector_db.py

@@ -0,0 +1,4 @@
+import chromadb
+from chromadb.config import Settings
+
+chroma_client = None

test/db CRUD.py

@@ -1,88 +0,0 @@
-import asyncio
-from datetime import datetime
-from sqlalchemy import String, Integer, DateTime
-from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
-from sqlalchemy.orm  import DeclarativeBase, Mapped, mapped_column
-from sqlalchemy import select
-
-DATABASE_URL = "postgresql+asyncpg://postgres:690869@localhost:5432/studentdb"
-
-engine = create_async_engine(DATABASE_URL, echo=True)
-async_session = async_sessionmaker(engine, expire_on_commit=False)
-
-class Base(DeclarativeBase):
-    pass
-
-class Student(Base):
-    __tablename__ = "students"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    name: Mapped[str] = mapped_column(String(100))
-    email: Mapped[str] = mapped_column(String(100))
-    age: Mapped[int]
-    grade: Mapped[str] = mapped_column(String(5))
-    created_at : Mapped[datetime] = mapped_column(default=datetime.utcnow)
-
-async def create_table():
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-    print('Tables created successfully !')
-
-async def add_student(name:str, email: str, age: int, grade: str):
-    async with async_session() as session:
-        async with session.begin():
-            student = Student( name = name, email= email, age=age, grade=grade)
-            session.add(student)
-    print(f"added student{name}")
-
-async def list_students():
-    async with  async_session() as session:
-        result = await session.execute(select(Student))
-        students = result.scalars().all()
-
-        for s in students:
-            print(f" - {s.id}: {s.name}, {s.email}, Grade: {s.grade}, {s.age}")
-
-async def update_student(student_id: int, new_name: str = None, new_age : int = None, new_grade : int = None ):
-    async with async_session() as session:
-        async with session.begin():
-            student = await session.get(Student, student_id)
-            if not student:
-                print(f"❌ Student with id {student_id} not found.")
-                return
-            if new_name: 
-                student.name = new_name
-            if new_grade:
-                student.grade = new_grade
-            if new_age:
-                student.age = new_age
-
-            # await session.commit()  ## no need
-    print(f"✏️ Updated student ID {student_id}")
-
-async def delete_student(student_id: int):
-    async with async_session() as session:
-        async with session.begin():
-            student = await session.get(Student, student_id)
-            if not student:
-                print(f"❌ Student with id {student_id} not found.")
-                return
-            
-            await session.delete(student)
-            # await session.commit()  ## no need
-    print(f"🗑️ Deleted student ID {student_id}")
-
-
-async def main():
-    await create_table()
-    await add_student("Akshat Mehta", "akshat@example.com", 21, "A+")
-    await add_student("Nikhil Sharma", "nikhil@example.com", 22, "B")
-    await list_students()
-
-    await update_student(1, new_age=52)
-    await delete_student(2)
-    print('-'*100)
-    await list_students()
-
-if __name__ == "__main__":
-    asyncio.run(main())

test/db_fastapi_CRUD.py

@@ -1,127 +0,0 @@
-import asyncio
-from typing import List, Optional
-from contextlib import asynccontextmanager
-from datetime import datetime
-from fastapi import FastAPI, HTTPException, status
-from sqlalchemy import String, Integer, DateTime, select
-from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
-from sqlalchemy.orm  import DeclarativeBase, Mapped, mapped_column
-from pydantic import BaseModel, ConfigDict
-
-
-DATABASE_URL = "postgresql+asyncpg://postgres:690869@localhost:5432/studentdb"
-
-engine = create_async_engine(DATABASE_URL, echo=True)
-async_session = async_sessionmaker(engine, expire_on_commit=False)
-
-class Base(DeclarativeBase):
-    pass
-
-class Student(Base):
-    __tablename__ = "students"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    name: Mapped[str] = mapped_column(String(100))
-    email: Mapped[str] = mapped_column(String(100))
-    age: Mapped[int]
-    grade: Mapped[str] = mapped_column(String(5))
-    created_at : Mapped[datetime] = mapped_column(default=datetime.utcnow)
-
-class StudentCreate(BaseModel):
-    name: str
-    email: str 
-    age: int
-    grade: str
-
-class StudentUpdate(BaseModel):
-    name: Optional[str] = None
-    email: Optional[str] = None
-    age: Optional[int] = None
-    grade: Optional[str] = None
-
-class StudentOut(BaseModel):
-    id: int
-    name: str
-    email: str 
-    age: int
-    grade: str
-    created_at: datetime
-
-    model_config = ConfigDict(from_attributes=True)
-
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)
-        print("Tables created !!!!")
-    yield
-    await engine.dispose()
-    print("🔻 Database connection closed.")
-
-app = FastAPI(title="Async student CRUD API", lifespan=lifespan)
-
-@app.post("/students/", response_model=StudentOut, status_code=status.HTTP_201_CREATED)
-async def create_student(student: StudentCreate):
-    async with async_session() as session:
-        async with session.begin():
-            student = Student(**student.model_dump())
-            session.add(student)
-        await session.refresh(student)
-        return student
-
-@app.get("/students/", response_model=List[StudentOut])
-async def list_students():
-    async with  async_session() as session:
-        result = await session.execute(select(Student))
-        students = result.scalars().all()
-        return students
-
-@app.get("/students/{id}", response_model=StudentOut)
-async def get_student(id: int):
-    async with async_session() as session:
-        student = await session.get(Student, id)
-        if not student:
-            raise HTTPException(status_code=404, detail="Student not found")
-        return student
-
-@app.put("/students/{id}/", response_model=StudentOut)
-async def update_student(id: int, update_data: StudentUpdate):
-    async with async_session() as session:
-        async with session.begin():
-            student = await session.get(Student, id)
-            if not student:
-                raise HTTPException(status_code=404, detail="student not found")
-            
-            update_dict = update_data.model_dump(exclude_unset=True)
-            for key , value in update_dict.items():
-                setattr(student, key , value)
-        
-        await session.refresh(student)
-        return student
-
-@app.delete("/students/{id}", status_code=status.HTTP_204_NO_CONTENT)
-async def delete_student(id: int):
-    async with async_session() as session:
-        async with session.begin():
-            student = await session.get(Student, id)
-            if not student:
-                raise HTTPException(status_code=404, detail="student not found")
-            await session.delete(student)
-    return None
-
-
-# async def main():
-#     # await create_table()
-#     await add_student("Akshat Mehta", "akshat@example.com", 21, "A+")
-#     await add_student("Nikhil Sharma", "nikhil@example.com", 22, "B")
-#     await list_students()
-
-#     await update_student(1, new_age=52)
-#     await delete_student(2)
-#     print('-'*100)
-#     await list_students()
-
-# if __name__ == "__main__":
-#     asyncio.run(main())

test/main.py

@@ -1,445 +0,0 @@
-"""
-FastAPI + PostgreSQL Student Management System
-Complete async implementation with SQLAlchemy, authentication, and validation
-
-Requirements:
-pip install fastapi uvicorn sqlalchemy asyncpg psycopg2-binary python-jose[cryptography] passlib[bcrypt] python-multipart
-"""
-
-from fastapi import FastAPI, HTTPException, Depends, status
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from fastapi.middleware.cors import CORSMiddleware
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
-from sqlalchemy import select, String
-from pydantic import BaseModel, EmailStr, Field, field_validator,  ConfigDict
-from typing import Optional, List
-from datetime import datetime, timedelta
-from jose import JWTError, jwt
-from passlib.context import CryptContext
-import os
-from contextlib import asynccontextmanager
-# ======================== CONFIGURATION ========================
-DATABASE_URL = os.getenv(
-    "DATABASE_URL", 
-    "postgresql+asyncpg://postgres:690869@172.26.157.164:5432/studentdb"
-)
-SECRET_KEY = os.getenv("SECRET_KEY", "production")
-ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
-
-# ======================== DATABASE SETUP ========================
-engine = create_async_engine(DATABASE_URL, echo=True)
-async_session_maker = async_sessionmaker(engine, expire_on_commit=False)
-
-class Base(DeclarativeBase):
-    pass
-
-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)
-    age: Mapped[int]
-    grade: Mapped[str] = mapped_column(String(5))
-    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
-
-class User(Base):
-    __tablename__ = "users"
-    
-    id: Mapped[int] = mapped_column(primary_key=True, index=True)
-    username: Mapped[str] = mapped_column(String(50), unique=True, index=True)
-    hashed_password: Mapped[str] = mapped_column(String(255))
-
-# ======================== PYDANTIC MODELS ========================
-class StudentBase(BaseModel):
-    name: str = Field(..., min_length=2, max_length=100, description="Student full name")
-    email: EmailStr = Field(..., description="Student email address")
-    age: int = Field(..., ge=5, le=100, description="Student age (5-100)")
-    grade: str = Field(..., pattern="^[A-F][+-]?$", description="Grade (A-F with optional + or -)")
-    
-    @field_validator('name')
-    def validate_name(cls, v):
-        if not v.strip():
-            raise ValueError('Name cannot be empty or just whitespace')
-        return v.strip()
-    
-    @field_validator('grade')
-    def validate_grade(cls, v):
-        v = v.upper()
-        if v not in ['A+', 'A', 'A-', 'B+', 'B', 'B-', 'C+', 'C', 'C-', 'D+', 'D', 'D-', 'F']:
-            raise ValueError('Invalid grade format')
-        return v
-
-class StudentCreate(StudentBase):
-    pass
-
-class StudentUpdate(BaseModel):
-    name: Optional[str] = Field(None, min_length=2, max_length=100)
-    email: Optional[EmailStr] = None
-    age: Optional[int] = Field(None, ge=5, le=100)
-    grade: Optional[str] = Field(None, pattern="^[A-F][+-]?$")
-    
-    @field_validator('grade')
-    def validate_grade(cls, v):
-        if v is not None:
-            v = v.upper()
-            if v not in ['A+', 'A', 'A-', 'B+', 'B', 'B-', 'C+', 'C', 'C-', 'D+', 'D', 'D-', 'F']:
-                raise ValueError('Invalid grade format')
-        return v
-
-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)
-    password: str = Field(..., min_length=6, max_length=72)
-    
-    @field_validator('password')
-    def validate_password(cls, v):
-        if len(v.encode('utf-8')) > 72:
-            raise ValueError('Password cannot exceed 72 bytes')
-        return v
-
-class Token(BaseModel):
-    access_token: str
-    token_type: str
-
-# ======================== SECURITY ========================
-pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
-security = HTTPBearer()
-
-def verify_password(plain_password: str, hashed_password: str) -> bool:
-    # Truncate password to 72 bytes for bcrypt compatibility
-    password_bytes = plain_password.encode('utf-8')[:72]
-    plain_password_truncated = password_bytes.decode('utf-8', errors='ignore')
-    return pwd_context.verify(plain_password_truncated, hashed_password)
-
-def get_password_hash(password: str) -> str:
-    # Truncate password to 72 bytes for bcrypt compatibility
-    password_bytes = password.encode('utf-8')[:72]
-    password_truncated = password_bytes.decode('utf-8', errors='ignore')
-    return pwd_context.hash(password_truncated)
-
-def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
-    to_encode = data.copy()
-    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15))
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return encoded_jwt
-
-async def get_current_user(
-    credentials: HTTPAuthorizationCredentials = Depends(security),
-    db: AsyncSession = Depends(lambda: async_session_maker())
-):
-    credentials_exception = HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Could not validate credentials",
-        headers={"WWW-Authenticate": "Bearer"},
-    )
-    try:
-        token = credentials.credentials
-        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-        username: str = payload.get("sub")
-        if username is None:
-            raise credentials_exception
-    except JWTError:
-        raise credentials_exception
-    
-    result = await db.execute(select(User).filter(User.username == username))
-    user = result.scalar_one_or_none()
-    if user is None:
-        raise credentials_exception
-    return user
-
-# ======================== DATABASE DEPENDENCY ========================
-async def get_db():
-    async with async_session_maker() as session:
-        try:
-            yield session
-            await session.commit()
-        except Exception:
-            await session.rollback()
-            raise
-        finally:
-            await session.close()
-
-# new on event alternative 
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    print("🏗️ Server starting:", datetime.now())
-    print("🔧 Creating tables if they don't exist...")
-
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)        # Create tables
-
-    print("✅ Tables ready!")
-    yield
-    print("🧹 Server shutting down:", datetime.now())
-
-# ======================== FASTAPI APP ========================
-app = FastAPI(
-    title="Student Management API",
-    description="FastAPI + PostgreSQL with SQLAlchemy async",
-    version="1.0.0",
-    lifespan=lifespan
-
-)
-
-# CORS Configuration
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # In production, specify allowed origins
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-# ======================== AUTHENTICATION ROUTES ========================
-@app.post("/auth/register", response_model=dict, tags=["Authentication"])
-async def register(user: UserCreate, db: AsyncSession = Depends(get_db)):
-    """Register a new user"""
-    try:
-        result = await db.execute(select(User).filter(User.username == user.username))
-        existing_user = result.scalar_one_or_none()
-        
-        if existing_user:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Username already registered"
-            )
-        
-        new_user = User(
-            username=user.username,
-            hashed_password=get_password_hash(user.password)
-        )
-        db.add(new_user)
-        await db.commit()
-        
-        return {"message": "User registered successfully", "username": user.username}
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Registration failed: {str(e)}"
-        )
-
-@app.post("/auth/login", response_model=Token, tags=["Authentication"])
-async def login(username: str, password: str, db: AsyncSession = Depends(get_db)):
-    """Login and get access token"""
-    try:
-        result = await db.execute(select(User).filter(User.username == username))
-        user = result.scalar_one_or_none()
-        
-        if not user or not verify_password(password, user.hashed_password):
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Incorrect username or password",
-                headers={"WWW-Authenticate": "Bearer"},
-            )
-        
-        access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
-        access_token = create_access_token(
-            data={"sub": user.username},
-            expires_delta=access_token_expires
-        )
-        
-        return {"access_token": access_token, "token_type": "bearer"}
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Login failed: {str(e)}"
-        )
-
-# ======================== STUDENT CRUD ROUTES ========================
-@app.post("/students/", response_model=StudentResponse, status_code=status.HTTP_201_CREATED, tags=["Students"])
-async def create_student(
-    student: StudentCreate,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """Create a new student (Protected)"""
-    try:
-        # Check if email already exists
-        result = await db.execute(select(Student).filter(Student.email == student.email))
-        existing_student = result.scalar_one_or_none()
-        
-        if existing_student:
-            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)}"
-        )
-
-@app.get("/students/", response_model=List[StudentResponse], tags=["Students"])
-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)}"
-        )
-
-@app.get("/students/{student_id}", response_model=StudentResponse, tags=["Students"])
-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)}"
-        )
-
-@app.put("/students/{student_id}", response_model=StudentResponse, tags=["Students"])
-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)}"
-        )
-
-@app.patch("/students/{student_id}", response_model=StudentResponse, tags=["Students"])
-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)
-
-@app.delete("/students/{student_id}", status_code=status.HTTP_204_NO_CONTENT, tags=["Students"])
-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)}"
-        )
-
-# ======================== HEALTH CHECK ========================
-@app.get("/", tags=["Health"])
-async def root():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "message": "Student Management API is running",
-        "version": "1.0.0"
-    }
-
-# ======================== RUN APPLICATION ========================
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

test/test.ipynb

@@ -1,189 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "d0e4e192",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import asyncio\n",
-    "from datetime import datetime\n",
-    "from sqlalchemy import String, Integer, DateTime\n",
-    "from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession\n",
-    "from sqlalchemy.orm  import DeclarativeBase, Mapped, mapped_column\n",
-    "from sqlalchemy import select\n",
-    "\n",
-    "DATABASE_URL = \"postgresql+asyncpg://postgres:690869@localhost:5432/studentdb\"\n",
-    "\n",
-    "engine = create_async_engine(DATABASE_URL, echo=True)\n",
-    "async_session = async_sessionmaker(engine, expire_on_commit=False)\n",
-    "\n",
-    "# class Base(DeclarativeBase):\n",
-    "#     pass\n",
-    "Base = DeclarativeBase()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "f2813d66",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<sqlalchemy.orm.decl_api.DeclarativeBase at 0x7df42272b620>"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Base\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "52154570",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ValidationError",
-     "evalue": "4 validation errors for Quiz_input\nparsed_doc\n  Field required [type=missing, input_value={}, input_type=dict]\n    For further information visit https://errors.pydantic.dev/2.12/v/missing\nuser_prompt\n  Field required [type=missing, input_value={}, input_type=dict]\n    For further information visit https://errors.pydantic.dev/2.12/v/missing\nmcq_choice\n  Field required [type=missing, input_value={}, input_type=dict]\n    For further information visit https://errors.pydantic.dev/2.12/v/missing\ncode_choice\n  Field required [type=missing, input_value={}, input_type=dict]\n    For further information visit https://errors.pydantic.dev/2.12/v/missing",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mValidationError\u001b[39m                           Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 6\u001b[39m\n\u001b[32m      3\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mlength\u001b[39m(\u001b[38;5;28minput\u001b[39m: Quiz_input):\n\u001b[32m      4\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28minput\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m6\u001b[39m data = \u001b[43mQuiz_input\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m      8\u001b[39m data.parsed_doc = \u001b[33m\"\u001b[39m\u001b[33mhello\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m      9\u001b[39m result = length(data)\n",
-      "\u001b[36mFile \u001b[39m\u001b[32m~/miniforge3/envs/prep/lib/python3.13/site-packages/pydantic/main.py:250\u001b[39m, in \u001b[36mBaseModel.__init__\u001b[39m\u001b[34m(self, **data)\u001b[39m\n\u001b[32m    248\u001b[39m \u001b[38;5;66;03m# `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks\u001b[39;00m\n\u001b[32m    249\u001b[39m __tracebackhide__ = \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m250\u001b[39m validated_self = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m__pydantic_validator__\u001b[49m\u001b[43m.\u001b[49m\u001b[43mvalidate_python\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mself_instance\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m    251\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m validated_self:\n\u001b[32m    252\u001b[39m     warnings.warn(\n\u001b[32m    253\u001b[39m         \u001b[33m'\u001b[39m\u001b[33mA custom validator is returning a value other than `self`.\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33m'\u001b[39m\n\u001b[32m    254\u001b[39m         \u001b[33m\"\u001b[39m\u001b[33mReturning anything other than `self` from a top level model validator isn\u001b[39m\u001b[33m'\u001b[39m\u001b[33mt supported when validating via `__init__`.\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m    255\u001b[39m         \u001b[33m'\u001b[39m\u001b[33mSee the `model_validator` docs (https://docs.pydantic.dev/latest/concepts/validators/#model-validators) for more details.\u001b[39m\u001b[33m'\u001b[39m,\n\u001b[32m    256\u001b[39m         stacklevel=\u001b[32m2\u001b[39m,\n\u001b[32m    257\u001b[39m     )\n",
-      "\u001b[31mValidationError\u001b[39m: 4 validation errors for Quiz_input\nparsed_doc\n  Field required [type=missing, input_value={}, input_type=dict]\n    For further information visit https://errors.pydantic.dev/2.12/v/missing\nuser_prompt\n  Field required [type=missing, input_value={}, input_type=dict]\n    For further information visit https://errors.pydantic.dev/2.12/v/missing\nmcq_choice\n  Field required [type=missing, input_value={}, input_type=dict]\n    For further information visit https://errors.pydantic.dev/2.12/v/missing\ncode_choice\n  Field required [type=missing, input_value={}, input_type=dict]\n    For further information visit https://errors.pydantic.dev/2.12/v/missing"
-     ]
-    }
-   ],
-   "source": [
-    "from app.schema.models import Quiz_input\n",
-    "\n",
-    "def length(input: Quiz_input):\n",
-    "    return len(input)\n",
-    "\n",
-    "data = Quiz_input()\n",
-    "hello = \"hello\"\n",
-    "data.parsed_doc = hello\n",
-    "result = length(data)\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "f0dac635",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'parsed_doc': 'hello'}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "data"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "b964b9c3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "\n",
-    "with open(\"1000-data-science-questions-answers.json\", \"r\") as f:\n",
-    "    data = json.load(f)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "f2579e63",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "500"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "005c0e97",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'question': 'Which of the following CLI command can also be used to rename files?',\n",
-       " 'options': ['rm', 'mv', 'rm -r', 'none of the mentioned'],\n",
-       " 'answer': 'b',\n",
-       " 'explanation': 'Explanation: mv stands for move.'}"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "data[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8222408a",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "prep",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.13.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

test/test.py

@@ -1,445 +0,0 @@
-"""
-FastAPI + PostgreSQL Student Management System
-Complete async implementation with SQLAlchemy, authentication, and validation
-
-Requirements:
-pip install fastapi uvicorn sqlalchemy asyncpg psycopg2-binary python-jose[cryptography] passlib[bcrypt] python-multipart
-"""
-
-from fastapi import FastAPI, HTTPException, Depends, status
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from fastapi.middleware.cors import CORSMiddleware
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
-from sqlalchemy import select, String
-from pydantic import BaseModel, EmailStr, Field, field_validator,  ConfigDict
-from typing import Optional, List
-from datetime import datetime, timedelta
-from jose import JWTError, jwt
-from passlib.context import CryptContext
-import os
-from contextlib import asynccontextmanager
-# ======================== CONFIGURATION ========================
-DATABASE_URL = os.getenv(
-    "DATABASE_URL", 
-    "postgresql+asyncpg://postgres:690869@172.26.157.164:5432/studentdb"
-)
-SECRET_KEY = os.getenv("SECRET_KEY", "production")
-ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
-
-# ======================== DATABASE SETUP ========================
-engine = create_async_engine(DATABASE_URL, echo=True)
-async_session_maker = async_sessionmaker(engine, expire_on_commit=False)
-
-class Base(DeclarativeBase):
-    pass
-
-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)
-    age: Mapped[int]
-    grade: Mapped[str] = mapped_column(String(5))
-    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
-
-class User(Base):
-    __tablename__ = "users"
-    
-    id: Mapped[int] = mapped_column(primary_key=True, index=True)
-    username: Mapped[str] = mapped_column(String(50), unique=True, index=True)
-    hashed_password: Mapped[str] = mapped_column(String(255))
-
-# ======================== PYDANTIC MODELS ========================
-class StudentBase(BaseModel):
-    name: str = Field(..., min_length=2, max_length=100, description="Student full name")
-    email: EmailStr = Field(..., description="Student email address")
-    age: int = Field(..., ge=5, le=100, description="Student age (5-100)")
-    grade: str = Field(..., pattern="^[A-F][+-]?$", description="Grade (A-F with optional + or -)")
-    
-    @field_validator('name')
-    def validate_name(cls, v):
-        if not v.strip():
-            raise ValueError('Name cannot be empty or just whitespace')
-        return v.strip()
-    
-    @field_validator('grade')
-    def validate_grade(cls, v):
-        v = v.upper()
-        if v not in ['A+', 'A', 'A-', 'B+', 'B', 'B-', 'C+', 'C', 'C-', 'D+', 'D', 'D-', 'F']:
-            raise ValueError('Invalid grade format')
-        return v
-
-class StudentCreate(StudentBase):
-    pass
-
-class StudentUpdate(BaseModel):
-    name: Optional[str] = Field(None, min_length=2, max_length=100)
-    email: Optional[EmailStr] = None
-    age: Optional[int] = Field(None, ge=5, le=100)
-    grade: Optional[str] = Field(None, pattern="^[A-F][+-]?$")
-    
-    @field_validator('grade')
-    def validate_grade(cls, v):
-        if v is not None:
-            v = v.upper()
-            if v not in ['A+', 'A', 'A-', 'B+', 'B', 'B-', 'C+', 'C', 'C-', 'D+', 'D', 'D-', 'F']:
-                raise ValueError('Invalid grade format')
-        return v
-
-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)
-    password: str = Field(..., min_length=6, max_length=72)
-    
-    @field_validator('password')
-    def validate_password(cls, v):
-        if len(v.encode('utf-8')) > 72:
-            raise ValueError('Password cannot exceed 72 bytes')
-        return v
-
-class Token(BaseModel):
-    access_token: str
-    token_type: str
-
-# ======================== SECURITY ========================
-pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
-security = HTTPBearer()
-
-def verify_password(plain_password: str, hashed_password: str) -> bool:
-    # Truncate password to 72 bytes for bcrypt compatibility
-    password_bytes = plain_password.encode('utf-8')[:72]
-    plain_password_truncated = password_bytes.decode('utf-8', errors='ignore')
-    return pwd_context.verify(plain_password_truncated, hashed_password)
-
-def get_password_hash(password: str) -> str:
-    # Truncate password to 72 bytes for bcrypt compatibility
-    password_bytes = password.encode('utf-8')[:72]
-    password_truncated = password_bytes.decode('utf-8', errors='ignore')
-    return pwd_context.hash(password_truncated)
-
-def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
-    to_encode = data.copy()
-    expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15))
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return encoded_jwt
-
-async def get_current_user(
-    credentials: HTTPAuthorizationCredentials = Depends(security),
-    db: AsyncSession = Depends(lambda: async_session_maker())
-):
-    credentials_exception = HTTPException(
-        status_code=status.HTTP_401_UNAUTHORIZED,
-        detail="Could not validate credentials",
-        headers={"WWW-Authenticate": "Bearer"},
-    )
-    try:
-        token = credentials.credentials
-        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-        username: str = payload.get("sub")
-        if username is None:
-            raise credentials_exception
-    except JWTError:
-        raise credentials_exception
-    
-    result = await db.execute(select(User).filter(User.username == username))
-    user = result.scalar_one_or_none()
-    if user is None:
-        raise credentials_exception
-    return user
-
-# ======================== DATABASE DEPENDENCY ========================
-async def get_db():
-    async with async_session_maker() as session:
-        try:
-            yield session
-            await session.commit()
-        except Exception:
-            await session.rollback()
-            raise
-        finally:
-            await session.close()
-
-# new on event alternative 
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    print("🏗️ Server starting:", datetime.now())
-    print("🔧 Creating tables if they don't exist...")
-
-    async with engine.begin() as conn:
-        await conn.run_sync(Base.metadata.create_all)        # Create tables
-
-    print("✅ Tables ready!")
-    yield
-    print("🧹 Server shutting down:", datetime.now())
-
-# ======================== FASTAPI APP ========================
-app = FastAPI(
-    title="Student Management API",
-    description="FastAPI + PostgreSQL with SQLAlchemy async",
-    version="1.0.0",
-    lifespan=lifespan
-
-)
-
-# CORS Configuration
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # In production, specify allowed origins
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-# ======================== AUTHENTICATION ROUTES ========================
-@app.post("/auth/register", response_model=dict, tags=["Authentication"])
-async def register(user: UserCreate, db: AsyncSession = Depends(get_db)):
-    """Register a new user"""
-    try:
-        result = await db.execute(select(User).filter(User.username == user.username))
-        existing_user = result.scalar_one_or_none()
-        
-        if existing_user:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Username already registered"
-            )
-        
-        new_user = User(
-            username=user.username,
-            hashed_password=get_password_hash(user.password)
-        )
-        db.add(new_user)
-        await db.commit()
-        
-        return {"message": "User registered successfully", "username": user.username}
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Registration failed: {str(e)}"
-        )
-
-@app.post("/auth/login", response_model=Token, tags=["Authentication"])
-async def login(username: str, password: str, db: AsyncSession = Depends(get_db)):
-    """Login and get access token"""
-    try:
-        result = await db.execute(select(User).filter(User.username == username))
-        user = result.scalar_one_or_none()
-        
-        if not user or not verify_password(password, user.hashed_password):
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Incorrect username or password",
-                headers={"WWW-Authenticate": "Bearer"},
-            )
-        
-        access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
-        access_token = create_access_token(
-            data={"sub": user.username},
-            expires_delta=access_token_expires
-        )
-        
-        return {"access_token": access_token, "token_type": "bearer"}
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Login failed: {str(e)}"
-        )
-
-# ======================== STUDENT CRUD ROUTES ========================
-@app.post("/students/", response_model=StudentResponse, status_code=status.HTTP_201_CREATED, tags=["Students"])
-async def create_student(
-    student: StudentCreate,
-    db: AsyncSession = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """Create a new student (Protected)"""
-    try:
-        # Check if email already exists
-        result = await db.execute(select(Student).filter(Student.email == student.email))
-        existing_student = result.scalar_one_or_none()
-        
-        if existing_student:
-            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)}"
-        )
-
-@app.get("/students/", response_model=List[StudentResponse], tags=["Students"])
-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)}"
-        )
-
-@app.get("/students/{student_id}", response_model=StudentResponse, tags=["Students"])
-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)}"
-        )
-
-@app.put("/students/{student_id}", response_model=StudentResponse, tags=["Students"])
-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)}"
-        )
-
-@app.patch("/students/{student_id}", response_model=StudentResponse, tags=["Students"])
-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)
-
-@app.delete("/students/{student_id}", status_code=status.HTTP_204_NO_CONTENT, tags=["Students"])
-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)}"
-        )
-
-# ======================== HEALTH CHECK ========================
-@app.get("/", tags=["Health"])
-async def root():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "message": "Student Management API is running",
-        "version": "1.0.0"
-    }
-
-# ======================== RUN APPLICATION ========================
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

test/voice.py

@@ -1,62 +0,0 @@
-import sounddevice as sd
-import numpy as np
-from faster_whisper import WhisperModel
-import ollama
-import subprocess
-import time
-
-# --- Configuration ---
-# STT Model: 'tiny' or 'base' are fast; 'small' is accurate.
-stt_model = WhisperModel("base.en", device="cuda", compute_type="float16") 
-
-def record_audio(duration=5, samplerate=16000):
-    """Simple recorder - in production, use VAD (Voice Activity Detection) to stop automatically."""
-    print("Listening...")
-    recording = sd.rec(int(duration * samplerate), samplerate=samplerate, channels=1, dtype='float32')
-    sd.wait()
-    return recording.flatten()
-
-def transcribe(audio_data):
-    """Convert Audio to Text"""
-    segments, info = stt_model.transcribe(audio_data, beam_size=5)
-    text = " ".join([segment.text for segment in segments])
-    return text.strip()
-
-def generate_response(prompt):
-    """Send text to Ollama (The Brain)"""
-    response = ollama.chat(model='llama3.2', messages=[
-      {'role': 'user', 'content': prompt},
-    ])
-    return response['message']['content']
-
-def speak(text):
-    """Convert Text to Audio (The Mouth) using Piper"""
-    # Assuming you have the piper binary and a voice model downloaded
-    # Command line: echo "text" | piper --model en_US-lessac-medium.onnx --output_file output.wav
-    
-    # For this example, we'll use a generic speak command for macOS/Linux 
-    # (Replace with Piper or pyttsx3 for true local/cross-platform)
-    subprocess.call(["say", text]) 
-
-# --- Main Loop ---
-def main():
-    print("Voice Agent Started (Ctrl+C to stop)")
-    while True:
-        # 1. Listen
-        audio_data = record_audio(duration=4) # Fixed duration for simplicity
-        
-        # 2. Transcribe
-        user_text = transcribe(audio_data)
-        if not user_text: continue
-        
-        print(f"You: {user_text}")
-        
-        # 3. Think
-        ai_response = generate_response(user_text)
-        print(f"AI: {ai_response}")
-        
-        # 4. Speak
-        speak(ai_response)
-
-if __name__ == "__main__":
-    main()