aicoach backend 2

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/face_landmarker.task filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,34 @@
+# Use a Python 3.10 slim image
+FROM python:3.10-slim
+
+ENV TZ=UTC
+
+# Install system dependencies
+# libgl1 replaces libgl1-mesa-glx in newer Debian versions for OpenCV/MediaPipe
+RUN apt-get update && apt-get install -y \
+    espeak \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set up a new user named "user" with user ID 1000 (Required by Hugging Face)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+# 1. Copy requirements first to leverage Docker caching
+# If your requirements.txt is inside a 'backend' folder, change this to: COPY --chown=user backend/requirements.txt .
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# 2. Copy the rest of the files
+COPY --chown=user . .
+
+# 3. Start the application
+# If main.py is in the root of your Space, use:
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "2"]
+
+# IF main.py is inside a 'backend' folder, use this instead:
+# CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,12 @@
 ---
-title: Aicoach2
-emoji: 🌍
-colorFrom: yellow
-colorTo: purple
+title: Aicoach
+emoji: 💻
+colorFrom: purple
+colorTo: blue
 sdk: docker
 pinned: false
+license: mit
+short_description: InterviewMinutes Dockerized Backend
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/auth.py

@@ -0,0 +1,30 @@
+import bcrypt
+import hashlib
+from jose import jwt
+from datetime import datetime, timedelta, timezone
+from .core.config import settings
+
+ALGORITHM = "HS256"
+
+def normalize_password(password: str):
+    return hashlib.sha256(password.encode()).hexdigest()
+
+def hash_password(password: str):
+    password_bytes = normalize_password(password).encode('utf-8')
+    salt = bcrypt.gensalt()
+    hashed = bcrypt.hashpw(password_bytes, salt)
+    return hashed.decode('utf-8')
+
+def verify_password(plain: str, hashed: str):
+    password_bytes = normalize_password(plain).encode('utf-8')
+    hashed_bytes = hashed.encode('utf-8')
+    try:
+        return bcrypt.checkpw(password_bytes, hashed_bytes)
+    except Exception:
+        return False
+
+def create_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.now(timezone.utc) + timedelta(days=1)
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM)

app/core/config.py

@@ -0,0 +1,27 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import Optional
+
+class Settings(BaseSettings):
+    # Database Config
+    MYSQL_USER: str
+    MYSQL_PASSWORD: str
+    MYSQL_HOST: str
+    MYSQL_DB: str
+    
+    # Auth Config
+    SECRET_KEY: str
+    GOOGLE_CLIENT_ID: Optional[str] = None
+    GOOGLE_CLIENT_SECRET: Optional[str] = None
+    
+    # External APIs
+    GEMINI_API_KEY: str
+
+    @property
+    def DATABASE_URL(self) -> str:
+        return f"mysql+pymysql://{self.MYSQL_USER}:{self.MYSQL_PASSWORD}@{self.MYSQL_HOST}/{self.MYSQL_DB}"
+
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+settings = Settings()
+
+

app/database.py

@@ -0,0 +1,19 @@
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+from .core.config import settings
+
+DATABASE_URL = f"mysql+pymysql://{settings.MYSQL_USER}:{settings.MYSQL_PASSWORD}@{settings.MYSQL_HOST}/{settings.MYSQL_DB}"
+
+engine = create_engine(
+    DATABASE_URL,
+    pool_size=10,          
+    max_overflow=20,       
+    pool_recycle=3600,     
+    pool_pre_ping=True,
+    connect_args={"init_command": "SET time_zone='+00:00'"}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()

app/models.py

@@ -0,0 +1,65 @@
+
+from sqlalchemy import Column, Integer, String, TIMESTAMP, ForeignKey, Float, Text, Boolean, func
+from .database import Base
+from sqlalchemy.orm import relationship
+from datetime import datetime, timezone
+
+class InterviewSlot(Base):
+    __tablename__ = "interview_slots"
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=True)
+    # Use timezone=True to help SQLAlchemy handle the UTC conversion
+    start_time = Column(TIMESTAMP(timezone=True), nullable=True)
+    is_active = Column(Boolean, default=False)
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String(255))
+    password_hash = Column(String(255))
+    full_name = Column(String(100), nullable=False)
+    google_id = Column(String(255))
+    # FIX: Use func.now() so MySQL generates the timestamp at insertion
+    created_at = Column(TIMESTAMP, server_default=func.now())
+    
+    interviews = relationship("InterviewSession", back_populates="user")
+
+class InterviewSession(Base):
+    __tablename__ = "interview_sessions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    session_uuid = Column(String(255), unique=True) 
+    # FIX: Removed parentheses from datetime.now
+    created_at = Column(TIMESTAMP, default=func.now())
+    
+    user = relationship("User", back_populates="interviews")
+    turns = relationship("InterviewTurn", back_populates="session")
+
+class InterviewTurn(Base):
+    __tablename__ = "interview_turns"
+
+    id = Column(Integer, primary_key=True, index=True)
+    session_id = Column(Integer, ForeignKey("interview_sessions.id"))
+    question = Column(Text)
+    answer = Column(Text)
+    wpm = Column(Integer)
+    accuracy = Column(Float)
+    fillers = Column(String(255))
+    dominant_behavior = Column(String(50))
+    
+    session = relationship("InterviewSession", back_populates="turns")
+
+# ... repeat for Resume class ...
+class Resume(Base):
+    __tablename__ = "resumes"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    file_name = Column(String(255))
+    file_path = Column(String(355))
+    # FIX: Use func.now()
+    uploaded_at = Column(TIMESTAMP, server_default=func.now())
+    
+    user = relationship("User")

app/oauth.py

@@ -0,0 +1,12 @@
+from authlib.integrations.starlette_client import OAuth
+from .core.config import settings
+
+oauth = OAuth()
+
+oauth.register(
+    name="google",
+    client_id=settings.GOOGLE_CLIENT_ID,
+    client_secret=settings.GOOGLE_CLIENT_SECRET,
+    server_metadata_url="https://accounts.google.com/.well-known/openid-configuration",
+    client_kwargs={"scope": "openid email profile"}
+)

app/routes/analysis_routes.py

@@ -0,0 +1,299 @@
+import os
+import io
+import uuid
+import json
+import re
+import numpy as np
+import pypdf
+import docx
+import anyio 
+from fastapi import APIRouter, File, UploadFile, Form, HTTPException, Depends, Request
+from fastapi.responses import FileResponse
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+from google import genai
+from google.genai import types
+from ..core.config import settings
+from sqlalchemy.orm import Session
+from ..database import SessionLocal
+from .. import models
+
+router = APIRouter()
+
+nlp_model = SentenceTransformer('all-mpnet-base-v2', device="cpu")
+client = genai.Client(api_key=settings.GEMINI_API_KEY)
+
+MODEL_ID = "gemini-2.5-flash" 
+chat_sessions = {}
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+def get_embedding(text):
+    words = text.split()
+    chunk_size = 300
+    chunks = [' '.join(words[i:i + chunk_size]) for i in range(0, len(words), chunk_size)]
+    if not chunks: return np.zeros(768)
+    chunk_embeddings = nlp_model.encode(chunks)
+    return np.mean(chunk_embeddings, axis=0)
+
+async def extract_text_from_file(file: UploadFile):
+    content = await file.read()
+    if file.filename.endswith(".pdf"):
+        pdf_reader = pypdf.PdfReader(io.BytesIO(content))
+        return "".join([page.extract_text() or "" for page in pdf_reader.pages])
+    elif file.filename.endswith(".docx"):
+        doc = docx.Document(io.BytesIO(content))
+        return "\n".join([para.text for para in doc.paragraphs])
+    elif file.filename.endswith(".txt"):
+        return content.decode("utf-8")
+    return ""
+
+
+def extract_text_from_path(file_path: str):
+    if not os.path.exists(file_path):
+        return ""
+    
+    if file_path.endswith(".pdf"):
+        with open(file_path, "rb") as f:
+            pdf_reader = pypdf.PdfReader(f)
+            return "".join([page.extract_text() or "" for page in pdf_reader.pages])
+    elif file_path.endswith(".docx"):
+        doc = docx.Document(file_path)
+        return "\n".join([para.text for para in doc.paragraphs])
+    elif file_path.endswith(".txt"):
+        with open(file_path, "r", encoding="utf-8") as f:
+            return f.read()
+    return ""
+
+
+def extract_json(text):
+    match = re.search(r'\{.*\}', text, re.DOTALL)
+    return match.group(0) if match else text
+
+@router.post("/analyze")
+async def analyze_match(resume: UploadFile = File(...), jd_file: UploadFile = File(None), jd_text: str = Form(None)):
+    if not jd_file and not jd_text:
+        raise HTTPException(status_code=400, detail="Provide JD file or text.")
+    
+    resume_content = await extract_text_from_file(resume)
+    jd_content = await extract_text_from_file(jd_file) if jd_file else jd_text
+
+    if not resume_content.strip() or not jd_content.strip():
+        raise HTTPException(status_code=400, detail="Extraction failed.")
+
+    r_emb = await anyio.to_thread.run_sync(get_embedding, resume_content)
+    j_emb = await anyio.to_thread.run_sync(get_embedding, jd_content)
+    
+    score = cosine_similarity([r_emb], [j_emb])[0][0]
+    
+    return {"match_percentage": round(float(score) * 100, 2), "status": "Success"}
+
+
+
+ 
+
+@router.get("/resumes")
+async def get_user_resumes(user_id: int, db: Session = Depends(get_db)):
+    return db.query(models.Resume).filter(models.Resume.user_id == user_id).all()
+
+@router.get("/resumes/download/{resume_id}")
+async def download_resume(resume_id: int, db: Session = Depends(get_db)):
+    res_db = db.query(models.Resume).filter(models.Resume.id == resume_id).first()
+    if not res_db or not os.path.exists(res_db.file_path):
+        raise HTTPException(status_code=404, detail="File not found")
+    return FileResponse(res_db.file_path, filename=res_db.file_name)
+
+@router.post("/upload-resume")
+async def upload_resume(user_id: int = Form(...), file: UploadFile = File(...), db: Session = Depends(get_db)):
+    upload_dir = "uploads/resumes"
+    os.makedirs(upload_dir, exist_ok=True)
+    
+    file_path = os.path.join(upload_dir, f"{uuid.uuid4()}_{file.filename}")
+    with open(file_path, "wb") as buffer:
+        buffer.write(await file.read())
+    
+    new_resume = models.Resume(user_id=user_id, file_name=file.filename, file_path=file_path)
+    db.add(new_resume)
+    db.commit()
+    return {"message": "Resume saved to library"}
+
+@router.delete("/resumes/{resume_id}")
+async def delete_resume(resume_id: int, db: Session = Depends(get_db)):
+    res_db = db.query(models.Resume).filter(models.Resume.id == resume_id).first()
+    if not res_db:
+        raise HTTPException(status_code=404, detail="Resume not found")
+    
+    if os.path.exists(res_db.file_path):
+        os.remove(res_db.file_path)
+        
+    db.delete(res_db)
+    db.commit()
+    return {"message": "Resume deleted successfully"}
+
+
+
+@router.post("/aianalyze")
+async def analyze_match(resume: UploadFile = File(...), jd_file: UploadFile = File(None), jd_text: str = Form(None)):
+    if not jd_file and not jd_text:
+        raise HTTPException(status_code=400, detail="Provide JD file or text.")
+    
+    resume_content = await extract_text_from_file(resume)
+    jd_content = await extract_text_from_file(jd_file) if jd_file else jd_text
+
+    if not resume_content.strip() or not jd_content.strip():
+        raise HTTPException(status_code=400, detail="Extraction failed.")
+    
+    prompt = (
+        f"You are an expert HR recruiter. Analyze the match between the following Resume and Job Description (JD).\n\n"
+        f"### Resume:\n{resume_content}\n\n"
+        f"### Job Description:\n{jd_content}\n\n"
+        "Return a JSON object with the following fields:\n"
+        "- match_percentage (int): overall compatibility score from 0-100\n"
+        "- summary (str): a 2-3 sentence overview of the candidate's fit\n"
+        "- key_matches (list): specific skills or experiences that align with the JD\n"
+        "- missing_skills (list): critical requirements from the JD not found in the resume\n"
+        "- suggestions (list): tips to improve the resume for this specific role\n"
+        "Provide ONLY the JSON object, no introductory text."
+    )
+
+    try:
+        response = client.models.generate_content(
+            model=MODEL_ID,
+            contents=prompt,
+            config=types.GenerateContentConfig(
+                response_mime_type="application/json"
+            )
+        )
+
+        analysis_data = json.loads(extract_json(response.text))
+        return {"match_percentage": round(float(analysis_data["match_percentage"]),2), "status": "Success"}
+        # return {**analysis_data, "status": "Success"}
+
+    except Exception as e:
+        # Fallback if the AI fails or JSON parsing errors out
+        raise HTTPException(status_code=500, detail=f"AI Analysis failed: {str(e)}")
+
+
+
+@router.post("/multiplematch")
+async def match_multiple_resumes(
+    user_id: int = Form(...), 
+    jd_file: UploadFile = File(None), 
+    jd_text: str = Form(None),
+    db: Session = Depends(get_db)
+):
+
+    if not jd_file and not jd_text:
+        raise HTTPException(status_code=400, detail="Provide JD file or text.")
+    
+    jd_content = await extract_text_from_file(jd_file) if jd_file else jd_text
+    if not jd_content.strip():
+        raise HTTPException(status_code=400, detail="JD content is empty.")
+
+    j_emb = await anyio.to_thread.run_sync(get_embedding, jd_content)
+
+    user_resumes = db.query(models.Resume).filter(models.Resume.user_id == user_id).all()
+    
+    if not user_resumes:
+        return {"results": [], "message": "No resumes found for this user."}
+
+    results = []
+    
+    for res in user_resumes:
+        try:
+            resume_text = await anyio.to_thread.run_sync(extract_text_from_path, res.file_path)
+            
+            if not resume_text.strip():
+                results.append({
+                    "resume_id": res.id,
+                    "file_name": res.file_name,
+                    "match_percentage": 0,
+                    "error": "Could not extract text"
+                })
+                continue
+
+            r_emb = await anyio.to_thread.run_sync(get_embedding, resume_text)
+            score = cosine_similarity([r_emb], [j_emb])[0][0]
+            
+            results.append({
+                "resume_id": res.id,
+                "file_name": res.file_name,
+                "match_percentage": round(float(score) * 100, 2)
+            })
+        except Exception as e:
+            results.append({
+                "resume_id": res.id,
+                "file_name": res.file_name,
+                "match_percentage": 0,
+                "error": str(e)
+            })
+
+    return {"results": results, "status": "Success"}
+
+
+@router.post("/aimultianalyse")
+async def ai_multiple_match(
+    user_id: int = Form(...), 
+    jd_file: UploadFile = File(None), 
+    jd_text: str = Form(None),
+    db: Session = Depends(get_db)
+):
+    # 1. Extract JD Text
+    if not jd_file and not jd_text:
+        raise HTTPException(status_code=400, detail="Provide JD file or text.")
+    
+    jd_content = await extract_text_from_file(jd_file) if jd_file else jd_text
+    if not jd_content.strip():
+        raise HTTPException(status_code=400, detail="JD Extraction failed.")
+
+    # 2. Retrieve all resumes for this user from DB
+    user_resumes = db.query(models.Resume).filter(models.Resume.user_id == user_id).all()
+    if not user_resumes:
+        return {"results": [], "message": "No resumes found for this user."}
+
+    # 3. Extract text from all resumes
+    resume_data = []
+    for res in user_resumes:
+        text = await anyio.to_thread.run_sync(extract_text_from_path, res.file_path)
+        if text.strip():
+            resume_data.append({"id": res.id, "name": res.file_name, "content": text})
+
+    if not resume_data:
+        return {"results": [], "message": "No readable resumes found."}
+
+    resumes_prompt = "\n\n".join([f"RESUME ID {r['id']} ({r['name']}):\n{r['content']}" for r in resume_data])
+    
+    prompt = (
+        f"You are an AI Recruitment Assistant. Compare the following list of resumes against the Job Description (JD).\n\n"
+        f"### Job Description:\n{jd_content}\n\n"
+        f"### Candidate Resumes:\n{resumes_prompt}\n\n"
+        "Return a JSON object with a key 'results' containing a list of objects. Each object must have:\n"
+        "- resume_id (int): the ID provided above\n"
+        "- file_name (str): the name of the file provided above\n"
+        "- match_percentage (int): 0-100 score\n"
+        "- brief_reason (str): why this candidate is or isn't a fit\n"
+        "- top_skills (list): matching skills found\n"
+        "- improvement_suggestions (str): suggestions for improving the resume\n"
+        "Sort the list by match_percentage in descending order. Provide ONLY JSON."
+    )
+
+    try:
+        # 5. Call Gemini API
+        response = client.models.generate_content(
+            model=MODEL_ID,
+            contents=prompt,
+            config=types.GenerateContentConfig(response_mime_type="application/json")
+        )
+        
+        analysis_data = json.loads(extract_json(response.text))
+        # return {**analysis_data, "status": "Success"}
+        return {"results": analysis_data.get("results", []), "status": "Success"}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"AI Multiple Analysis failed: {str(e)}")

app/routes/auth_routes.py

@@ -0,0 +1,176 @@
+from fastapi import APIRouter, Depends, Request, HTTPException
+from sqlalchemy.orm import Session
+from ..database import SessionLocal
+from .. import models, schemas, auth
+from ..oauth import oauth
+from fastapi.responses import RedirectResponse, JSONResponse
+from jose import jwt, JWTError
+from ..core.config import settings
+
+
+
+router = APIRouter()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+@router.post("/register")
+def register(user: schemas.UserCreate, db: Session = Depends(get_db)):
+
+    existing = db.query(models.User).filter(
+        models.User.email == user.email
+    ).first()
+
+    if existing:
+        return {"error": "User exists"}
+
+    new_user = models.User(
+        full_name=user.full_name,
+        email=user.email,
+        password_hash=auth.hash_password(user.password)
+    )
+
+    db.add(new_user)
+    db.commit()
+
+    token = auth.create_token({"sub": new_user.email})
+
+    response = JSONResponse({"message": "User registered"})
+
+    response.set_cookie(
+        key="access_token",
+        value=token,
+        httponly=True,
+        secure=True,
+        samesite="none",
+        path="/"
+    )
+
+    return response
+
+
+@router.post("/login")
+def login(user: schemas.UserLogin, db: Session = Depends(get_db)):
+
+    db_user = db.query(models.User).filter(
+        models.User.email == user.email
+    ).first()
+
+    if not db_user:
+        return {"error": "Invalid credentials"}
+    if not auth.verify_password(user.password, db_user.password_hash):
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+
+    token = auth.create_token({"sub": db_user.email})
+
+    response = JSONResponse({"message": "Login success"})
+
+    response.set_cookie(
+        key="access_token",
+        value=token,
+        httponly=True,
+        secure=True,
+        samesite="none",
+        path="/"
+    )
+
+    return response
+
+
+@router.get("/google")
+async def google_login(request: Request):
+    redirect_uri = request.url_for("google_callback")
+    return await oauth.google.authorize_redirect(request, redirect_uri)
+
+
+@router.get("/google/callback")
+async def google_callback(request: Request, db: Session = Depends(get_db)):
+
+    token = await oauth.google.authorize_access_token(request)
+    user_info = token["userinfo"]
+
+    db_user = db.query(models.User).filter(
+        models.User.email == user_info["email"]
+    ).first()
+
+    if not db_user:
+        db_user = models.User(
+            email=user_info["email"],
+            google_id=user_info["sub"]
+        )
+        db.add(db_user)
+        db.commit()
+
+    jwt_token = auth.create_token({"sub": user_info["email"]})
+
+
+    response = RedirectResponse("https://d33paksoni.github.io/aicoach-infosys/dashboard")
+
+    response.set_cookie(
+        key="access_token",
+        value=jwt_token,
+        httponly=True,
+        secure=True,
+        samesite="none",
+        path="/"
+    )
+
+    return response
+
+
+def get_current_user(request: Request):
+
+    token = request.cookies.get("access_token")
+
+    if not token:
+        return None
+
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+        return payload.get("sub")
+
+    except JWTError:
+        return None
+
+
+
+@router.get("/me")
+def get_me(request: Request, db: Session = Depends(get_db)):
+
+    user_email = get_current_user(request)
+
+    if not user_email:
+        raise HTTPException(status_code=401, detail="Not authenticated")
+    
+    db_user = db.query(models.User).filter(models.User.email == user_email).first()
+    
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    return {
+        "full_name": db_user.full_name,
+        "id": db_user.id,
+        "email": user_email
+    }
+
+
+
+@router.post("/logout")
+def logout():
+
+    response = JSONResponse({"message": "Logged out"})
+
+    response.delete_cookie(
+        key="access_token",
+        path="/",
+        samesite="none",  
+        secure=True,       
+        httponly=True
+    )
+
+    return response
+

app/routes/session_routes.py

@@ -0,0 +1,203 @@
+# from fastapi import APIRouter, Depends, HTTPException
+# from sqlalchemy.orm import Session
+# from ..database import SessionLocal
+# from .. import models, schemas
+
+# router = APIRouter()
+
+# def get_db():
+#     db = SessionLocal()
+#     try: yield db
+#     finally: db.close()
+
+# @router.post("/save-session")
+# def save_interview_session(data: schemas.InterviewSaveRequest, db: Session = Depends(get_db)):
+#     try:
+#         session_record = db.query(models.InterviewSession).filter(
+#             models.InterviewSession.session_uuid == data.session_id
+#         ).first()
+
+#         if not session_record:
+#             session_record = models.InterviewSession(session_uuid=data.session_id, user_id=data.user_id)
+#             db.add(session_record)
+#             db.flush()
+
+#         for turn in data.turns:
+#             new_turn = models.InterviewTurn(
+#                 session_id=session_record.id,
+#                 question=turn.question,
+#                 answer=turn.answer,
+#                 wpm=turn.wpm,
+#                 accuracy=turn.accuracy,
+#                 fillers=turn.fillers,
+#                 dominant_behavior=turn.commonBehavior
+#             )
+#             db.add(new_turn)
+        
+#         db.commit()
+#         return {"status": "success"}
+#     except Exception as e:
+#         db.rollback()
+#         raise HTTPException(status_code=500, detail=str(e))
+
+# @router.get("/get-sessions")
+# def get_sessions(user_id: int, db: Session = Depends(get_db)):
+#     sessions = db.query(models.InterviewSession).filter(
+#         models.InterviewSession.user_id == user_id
+#     ).order_by(models.InterviewSession.created_at.desc()).all()
+    
+#     return [{
+#         "id": s.id, "session_uuid": s.session_uuid, "created_at": s.created_at,
+#         "turn_count": db.query(models.InterviewTurn).filter(models.InterviewTurn.session_id == s.id).count()
+#     } for s in sessions]
+
+# @router.get("/session-details/{session_id}")
+# def get_session_details(session_id: int, db: Session = Depends(get_db)):
+#     return db.query(models.InterviewTurn).filter(models.InterviewTurn.session_id == session_id).all()
+
+
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from ..database import SessionLocal
+from .. import models, schemas
+from datetime import datetime, timezone, timedelta
+
+router = APIRouter()
+
+def get_db():
+    db = SessionLocal()
+    try: yield db
+    finally: db.close()
+
+
+
+def refresh_slots(db: Session):
+    expiry_time = datetime.now(timezone.utc) - timedelta(minutes=12)
+    expired_slots = db.query(models.InterviewSlot).filter(
+        models.InterviewSlot.is_active == True,
+        models.InterviewSlot.start_time < expiry_time
+    ).all()
+    
+    for slot in expired_slots:
+        slot.is_active = False
+        slot.user_id = None
+    db.commit()
+
+def available_slots(db: Session):
+    refresh_slots(db)
+    return db.query(models.InterviewSlot).filter(
+        models.InterviewSlot.is_active == False
+    ).first()
+
+
+
+@router.get("/check-slots")
+def check_slots(db: Session = Depends(get_db)):
+
+    available_slot = available_slots(db)
+    if available_slot:
+        return {"status": "available", "slot_id": available_slot.id}
+    
+    
+    earliest_session = db.query(models.InterviewSlot).filter(
+        models.InterviewSlot.is_active == True
+    ).order_by(models.InterviewSlot.start_time.asc()).first()
+
+    if not earliest_session:
+        return {"status": "error", "message": "No slots configured."}
+
+    now = datetime.now(timezone.utc)
+    start_time = earliest_session.start_time
+    if start_time.tzinfo is None:
+        start_time = start_time.replace(tzinfo=timezone.utc)
+        
+    elapsed = now - start_time
+    total_duration_seconds = 15 * 60
+    remaining_seconds = max(0, total_duration_seconds - elapsed.total_seconds())
+
+
+    return {"status": "full", 
+            "wait_time_seconds": int(remaining_seconds),
+            "message": "All interview slots are currently full."}
+
+
+@router.post("/acquire-slot")
+def acquire_slot(data: schemas.SlotRequest, db: Session = Depends(get_db)):
+
+    available_slot = available_slots(db)
+
+    if available_slot:
+        available_slot.user_id = data.user_id
+        available_slot.start_time = datetime.now(timezone.utc)
+        available_slot.is_active = True
+        db.commit()
+        return {"status": "success", "slot_id": available_slot.id}
+    else:
+        return {
+        "status": "full",
+        "message": "All interview slots are currently full. Please wait and try again."}
+
+
+
+
+@router.post("/release-slot/{user_id}")
+def release_slot(user_id: int, db: Session = Depends(get_db)):
+    slot = db.query(models.InterviewSlot).filter(
+        models.InterviewSlot.user_id == user_id
+    ).first()
+    if slot:
+        slot.is_active = False
+        slot.user_id = None
+        db.commit()
+    return {"status": "released"}
+
+
+
+
+
+
+@router.post("/save-session")
+def save_interview_session(data: schemas.InterviewSaveRequest, db: Session = Depends(get_db)):
+    try:
+        session_record = db.query(models.InterviewSession).filter(
+            models.InterviewSession.session_uuid == data.session_id
+        ).first()
+
+        if not session_record:
+            session_record = models.InterviewSession(session_uuid=data.session_id, user_id=data.user_id)
+            db.add(session_record)
+            db.flush()
+
+        for turn in data.turns:
+            new_turn = models.InterviewTurn(
+                session_id=session_record.id,
+                question=turn.question,
+                answer=turn.answer,
+                wpm=turn.wpm,
+                accuracy=turn.accuracy,
+                fillers=turn.fillers,
+                dominant_behavior=turn.commonBehavior
+            )
+            db.add(new_turn)
+        
+        db.commit()
+        return {"status": "success"}
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/get-sessions")
+def get_sessions(user_id: int, db: Session = Depends(get_db)):
+    sessions = db.query(models.InterviewSession).filter(
+        models.InterviewSession.user_id == user_id
+    ).order_by(models.InterviewSession.created_at.desc()).all()
+    
+    return [{
+        "id": s.id, "session_uuid": s.session_uuid, "created_at": s.created_at,
+        "turn_count": db.query(models.InterviewTurn).filter(models.InterviewTurn.session_id == s.id).count()
+    } for s in sessions]
+
+@router.get("/session-details/{session_id}")
+def get_session_details(session_id: int, db: Session = Depends(get_db)):
+    return db.query(models.InterviewTurn).filter(models.InterviewTurn.session_id == session_id).all()

app/schemas.py

@@ -0,0 +1,39 @@
+from pydantic import BaseModel, EmailStr
+
+class UserCreate(BaseModel):
+    full_name: str
+    email: EmailStr
+    password: str
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+from typing import List, Optional
+
+class TurnData(BaseModel):
+    question: str
+    answer: str
+    wpm: int
+    accuracy: float
+    fillers: str
+    commonBehavior: str
+
+class InterviewSaveRequest(BaseModel):
+    session_id: str
+    user_id: Optional[int] = None
+    turns: List[TurnData]
+
+class SlotRequest(BaseModel):
+    user_id: int
+
+class SlotResponse(BaseModel):
+    status: str
+    slot_id: Optional[int] = None
+    wait_time_seconds: Optional[int] = 0
+    message: Optional[str] = None
+
+class WaitingStatus(BaseModel):
+    active_users: int
+    estimated_wait_minutes: float
+    wait_time_seconds: int

main.py

@@ -0,0 +1,62 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.middleware.sessions import SessionMiddleware
+from contextlib import asynccontextmanager 
+import torch
+
+from app.routes import auth_routes, analysis_routes, vision_routes, session_routes
+from app.core.config import settings
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    from app.database import SessionLocal
+    from app.models import InterviewSlot
+
+    torch.set_num_threads(1)
+    print("AI Interview Coach: Starting up and loading models...")
+    
+    db = SessionLocal()
+    # Check if slots exist, if not, create them
+    if db.query(InterviewSlot).count() == 0:
+        db.add(InterviewSlot(id=1, is_active=False))
+        db.add(InterviewSlot(id=2, is_active=False))
+        db.commit()
+    db.close()
+    
+    yield
+    print("AI Interview Coach: Shutting down...")
+
+app = FastAPI(
+    title="AI Interview Coach",
+    lifespan=lifespan 
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[        
+        "http://localhost:5173",
+        "https://d33paksoni.github.io",
+        "https://www.thedeepaksoni.life"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.add_middleware(
+    SessionMiddleware,
+    secret_key=settings.SECRET_KEY,
+    same_site="none"
+)
+
+app.include_router(auth_routes.router, prefix="/auth", tags=["Authentication"])
+app.include_router(analysis_routes.router, tags=["NLP & AI"])
+app.include_router(session_routes.router, tags=["History"])
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000, workers=2)
+
+
+
+

requirements.txt

@@ -0,0 +1,21 @@
+fastapi 
+uvicorn 
+sqlalchemy 
+pymysql 
+passlib[bcrypt] 
+python-jose 
+authlib 
+python-dotenv
+pydantic[email]
+httpx
+numpy 
+pypdf 
+python-docx 
+sentence-transformers 
+scikit-learn 
+opencv-python 
+pillow 
+python-multipart  
+pydantic-settings 
+google-genai  
+itsdangerous

uploads/resumes/a.txt

@@ -0,0 +1 @@
+a