Initial deploy: ATS Score Analyzer API

app.py

@@ -1,9 +1,13 @@
 import os
 import time
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, UploadFile, File, Form
 from pydantic import BaseModel
-from ats_core import ats_score, extract_text_from_pdf, ROLE_TEMPLATES
 
+from ats_core import (
+    ats_score,
+    extract_text_from_pdf,
+    ROLE_TEMPLATES
+)
 
 PORT = int(os.environ.get("PORT", 7860))
 
@@ -13,14 +17,10 @@ app = FastAPI(
     version="1.0.0"
 )
 
+# ---------------- Rate Limiting ----------------
 USAGE_LIMIT = 5
 usage_tracker = {}
 
-class ATSRequest(BaseModel):
-    resume_text: str
-    job_description: str
-
-
 def check_rate_limit(request: Request):
     ip = request.client.host
     today = time.strftime("%Y-%m-%d")
@@ -33,19 +33,17 @@ def check_rate_limit(request: Request):
 
     usage_tracker[ip][today] = usage_tracker[ip].get(today, 0) + 1
 
-
-from fastapi import UploadFile, File, Form
-
+# ---------------- API ----------------
 @app.post("/ats-score")
 async def compute_ats(
+    request: Request,
     resume_file: UploadFile = File(...),
     job_description: str = Form(""),
-    role: str = Form(""),
-    request: Request = None
+    role: str = Form("")
 ):
     check_rate_limit(request)
 
-    # Read resume PDF
+    # Validate resume
     if resume_file.content_type != "application/pdf":
         raise HTTPException(status_code=400, detail="Resume must be a PDF")
 
@@ -56,17 +54,29 @@ async def compute_ats(
         raise HTTPException(status_code=400, detail="Could not extract text from resume")
 
     # Decide JD source
-    if job_description.strip():
+    use_provided_jd = bool(job_description.strip())
+
+    if use_provided_jd:
         jd_text = job_description
-    elif role.lower() in ROLE_TEMPLATES:
-        jd_text = ROLE_TEMPLATES[role.lower()]
+        role_context = ROLE_TEMPLATES.get(role.lower(), "")
+        jd_weight = 0.85
+        role_weight = 0.15
+        role_only = False
     else:
-        raise HTTPException(
-            status_code=400,
-            detail="Provide job description text or select a valid role"
-        )
+        if role.lower() not in ROLE_TEMPLATES:
+            raise HTTPException(
+                status_code=400,
+                detail="Provide a job description or select a valid role"
+            )
+        jd_text = ROLE_TEMPLATES[role.lower()]
+        role_context = ""
+        jd_weight = 1.0
+        role_weight = 0.0
+        role_only = True
+
+    combined_jd = jd_text * int(jd_weight * 10) + role_context * int(role_weight * 10)
 
-    return ats_score(resume_text, jd_text)
+    return ats_score(resume_text, combined_jd, role_only=role_only)
 
 @app.get("/health")
 def health():

ats_core.py

@@ -1,40 +1,104 @@
-from sentence_transformers import SentenceTransformer
-from sklearn.metrics.pairwise import cosine_similarity
-import nltk
 import re
+import nltk
 import pdfplumber
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
 
 nltk.download("stopwords")
 from nltk.corpus import stopwords
 
+STOPWORDS = set(stopwords.words("english"))
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+GENERIC_WORDS = {
+    "looking", "engineer", "developer", "role",
+    "experience", "skills", "responsibilities"
+}
+
+# ---------------- Role-based Expanded JDs ----------------
 ROLE_TEMPLATES = {
     "backend": """
-    Backend Engineer with experience in Python, APIs, databases,
-    system design, REST services, Docker, and scalable backend systems.
-    """,
+Role: Backend Engineer
+
+Responsibilities:
+Design and build scalable backend systems, REST APIs, and services.
+Work with databases, authentication, performance optimization, and security.
+
+Required Skills:
+Python or similar backend language, API development, backend frameworks,
+authentication mechanisms, and system design concepts.
+
+Tools & Technologies:
+Python, FastAPI/Flask/Django, SQL/NoSQL databases, Docker, Git, Linux.
+
+Experience Expectations:
+Building and deploying backend services, maintaining APIs, and debugging systems.
+
+Nice to Have:
+Cloud platforms, scalability, and distributed systems experience.
+""",
+
     "frontend": """
-    Frontend Developer skilled in JavaScript, React, HTML, CSS,
-    responsive design, UI/UX, and modern frontend frameworks.
-    """,
+Role: Frontend Developer
+
+Responsibilities:
+Build responsive and accessible user interfaces.
+Integrate frontend with backend APIs and manage application state.
+
+Required Skills:
+JavaScript, HTML, CSS, React or similar frameworks, UI/UX understanding.
+
+Tools & Technologies:
+React, Next.js, CSS frameworks, browser dev tools, Git.
+
+Experience Expectations:
+Building real-world frontend applications and handling user interactions.
+
+Nice to Have:
+Performance optimization and design systems.
+""",
+
     "ml": """
-    Machine Learning Engineer with experience in Python, data analysis,
-    machine learning models, feature engineering, evaluation metrics,
-    and deployment of ML systems.
-    """,
+Role: Machine Learning Engineer
+
+Responsibilities:
+Develop, train, evaluate, and deploy machine learning models.
+Perform data preprocessing and feature engineering.
+
+Required Skills:
+Python, ML algorithms, data preprocessing, model evaluation techniques.
+
+Tools & Technologies:
+Scikit-learn, PyTorch/TensorFlow, data pipelines, APIs.
+
+Experience Expectations:
+Working with real datasets and deploying ML systems.
+
+Nice to Have:
+NLP, computer vision, and MLOps experience.
+""",
+
     "data": """
-    Data Analyst with experience in SQL, Python, data visualization,
-    statistics, dashboards, and business insights.
-    """
-}
+Role: Data Analyst
 
-model = SentenceTransformer("all-MiniLM-L6-v2")
-STOPWORDS = set(stopwords.words("english"))
+Responsibilities:
+Analyze datasets, create dashboards, and communicate insights.
 
-GENERIC_WORDS = {
-    "looking", "engineer", "developer", "role",
-    "experience", "skills", "responsibilities"
+Required Skills:
+SQL, Python, statistics, data visualization.
+
+Tools & Technologies:
+Pandas, NumPy, BI tools, Excel, databases.
+
+Experience Expectations:
+Cleaning and analyzing datasets to derive insights.
+
+Nice to Have:
+A/B testing and predictive analytics.
+"""
 }
 
+# ---------------- Utilities ----------------
 def to_float(x):
     return float(x)
 
@@ -53,6 +117,11 @@ def embedding_similarity(text1, text2):
     emb = model.encode([text1, text2])
     return cosine_similarity([emb[0]], [emb[1]])[0][0]
 
+def extract_experience(text):
+    lines = text.lower().split("\n")
+    exp_lines = [l for l in lines if "experience" in l or "-" in l]
+    return " ".join(exp_lines) if exp_lines else text
+
 def formatting_score(resume_text):
     score = 0
     text = resume_text.lower()
@@ -65,47 +134,59 @@ def formatting_score(resume_text):
     wc = len(resume_text.split())
     if 300 <= wc <= 900: score += 2
 
-    return score  # max 10
-
-def extract_experience(text):
-    lines = text.lower().split("\n")
-    exp_lines = [l for l in lines if "experience" in l or "-" in l]
-    return " ".join(exp_lines) if exp_lines else text
+    return score / 10
 
-def ats_score(resume_text, jd_text):
+def extract_text_from_pdf(file_bytes):
+    text = ""
+    with pdfplumber.open(file_bytes) as pdf:
+        for page in pdf.pages:
+            if page.extract_text():
+                text += page.extract_text() + "\n"
+    return text.strip()
+
+def ats_verdict(score):
+    if score < 40:
+        return "Poor Fit"
+    elif score < 60:
+        return "Average Fit"
+    elif score < 75:
+        return "Good Fit"
+    else:
+        return "Excellent Fit"
+
+# ---------------- Core Scoring ----------------
+def ats_score(resume_text, jd_text, role_only=False):
     skill_sim = embedding_similarity(resume_text, jd_text)
 
     jd_keywords = extract_keywords(jd_text)
     resume_keywords = extract_keywords(resume_text)
-
-    matched = set(jd_keywords) & set(resume_keywords)
-    keyword_score = len(matched) / max(len(jd_keywords), 1)
+    keyword_score = len(set(jd_keywords) & set(resume_keywords)) / max(len(jd_keywords), 1)
 
     exp_text = extract_experience(resume_text)
     exp_sim = embedding_similarity(exp_text, jd_text)
 
-    format_score = formatting_score(resume_text) / 10
+    format_score = formatting_score(resume_text)
+
+    if role_only:
+        skill_w, keyword_w, exp_w, format_w = 0.45, 0.25, 0.20, 0.10
+    else:
+        skill_w, keyword_w, exp_w, format_w = 0.40, 0.30, 0.20, 0.10
 
     final_score = (
-        0.4 * skill_sim +
-        0.3 * keyword_score +
-        0.2 * exp_sim +
-        0.1 * format_score
+        skill_w * skill_sim +
+        keyword_w * keyword_score +
+        exp_w * exp_sim +
+        format_w * format_score
     ) * 100
 
+    final = to_float(round(final_score, 2))
+
     return {
-        "ats_score": to_float(round(final_score, 2)),
+        "ats_score": final,
+        "verdict": ats_verdict(final),
         "skill_score": to_float(round(skill_sim * 40, 2)),
         "keyword_score": to_float(round(keyword_score * 30, 2)),
         "experience_score": to_float(round(exp_sim * 20, 2)),
         "formatting_score": to_float(round(format_score * 10, 2)),
         "missing_keywords": list(set(jd_keywords) - set(resume_keywords))[:10]
     }
-
-def extract_text_from_pdf(file_bytes):
-    text = ""
-    with pdfplumber.open(file_bytes) as pdf:
-        for page in pdf.pages:
-            if page.extract_text():
-                text += page.extract_text() + "\n"
-    return text.strip()