Upload 6 files

app.py

@@ -0,0 +1,71 @@
+import os
+import shutil
+import gradio as gr
+from fastapi import FastAPI, UploadFile, File, Form
+
+from resume_parser import parse_resume
+from model_logic import score_resume_by_title
+from logger import log_decision
+
+
+app = FastAPI()
+
+
+UPLOAD_DIR = "uploads"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+
+def process_resume(file, title, level):
+
+    path = os.path.join(UPLOAD_DIR, file.name)
+
+    with open(path, "wb") as f:
+        shutil.copyfileobj(file, f)
+
+    text = parse_resume(path)
+
+    result = score_resume_by_title(text, title, level)
+
+    log_decision(title, result["decision"])
+
+    os.remove(path)
+
+    return result
+
+
+@app.post("/analyze_resume")
+async def analyze_resume(
+    file: UploadFile = File(...),
+    title: str = Form(...),
+    level: str = Form(...)
+):
+
+    result = process_resume(file.file, title, level)
+
+    return result
+
+
+def gradio_interface(file, title, level):
+
+    result = process_resume(file, title, level)
+
+    return result
+
+
+demo = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.File(label="Upload Resume PDF"),
+        gr.Textbox(label="Job Title"),
+        gr.Dropdown(
+            ["entry","junior","mid","senior"],
+            label="Job Level"
+        )
+    ],
+    outputs="json",
+    title="AI Resume Screening System"
+)
+
+
+if __name__ == "__main__":
+    demo.launch()

logger.py

@@ -0,0 +1,22 @@
+import csv
+import uuid
+from datetime import datetime
+
+LOG_FILE = "logs.csv"
+
+
+def log_decision(job_title, decision):
+
+    uid = str(uuid.uuid4())[:8]
+
+    row = [
+        uid,
+        datetime.now().isoformat(),
+        job_title,
+        decision
+    ]
+
+    with open(LOG_FILE, "a", newline="") as f:
+
+        writer = csv.writer(f)
+        writer.writerow(row)

model_logic.py

@@ -0,0 +1,214 @@
+from sentence_transformers import SentenceTransformer, util
+import re
+
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+
+def extract_years_of_experience(text):
+
+    pattern = r"(\d+)\s+years"
+    matches = re.findall(pattern, text.lower())
+
+    if matches:
+        return max([int(x) for x in matches])
+
+    return 0
+
+
+def skills_from_text(text):
+
+    text = text.lower()
+
+    skills = [
+        # programming
+        "python","java","c++","c#","javascript","typescript","go","rust","scala",
+
+        # data science
+        "machine learning","deep learning","data science","data analysis",
+        "data mining","statistical analysis","statistics","predictive modeling",
+
+        # ml / ai frameworks
+        "tensorflow","pytorch","keras","scikit-learn","xgboost","lightgbm",
+
+        # data tools
+        "pandas","numpy","matplotlib","seaborn","plotly",
+
+        # databases
+        "sql","postgresql","mysql","mongodb","redis","oracle",
+
+        # cloud
+        "aws","azure","gcp","docker","kubernetes",
+
+        # backend
+        "fastapi","flask","django","spring","node.js","express",
+
+        # frontend
+        "react","angular","vue","html","css","bootstrap","tailwind",
+
+        # nlp
+        "nlp","natural language processing","transformers","bert","llm",
+
+        # devops
+        "ci/cd","jenkins","git","github","gitlab","terraform",
+
+        # data engineering
+        "spark","hadoop","kafka","airflow","etl","data pipelines",
+
+        # analytics tools
+        "power bi","tableau","excel"
+    ]
+
+    found = []
+
+    for skill in skills:
+        if skill in text:
+            found.append(skill)
+
+    return list(set(found))
+
+
+def get_job_requirements(title):
+
+    title = title.lower()
+
+    mapping = {
+
+        "data scientist": [
+            "python","machine learning","statistics","pandas",
+            "numpy","sql","data visualization","scikit-learn"
+        ],
+
+        "machine learning engineer": [
+            "python","machine learning","deep learning",
+            "pytorch","tensorflow","docker","mlops"
+        ],
+
+        "ml engineer": [
+            "python","machine learning","deep learning",
+            "pytorch","tensorflow","docker"
+        ],
+
+        "data analyst": [
+            "sql","python","excel","tableau",
+            "power bi","data analysis","statistics"
+        ],
+
+        "data engineer": [
+            "python","sql","spark","hadoop",
+            "etl","data pipelines","airflow"
+        ],
+
+        "backend developer": [
+            "python","fastapi","flask","django",
+            "sql","api","docker"
+        ],
+
+        "backend engineer": [
+            "python","fastapi","django",
+            "sql","microservices","docker"
+        ],
+
+        "software engineer": [
+            "python","java","c++","git",
+            "algorithms","data structures"
+        ],
+
+        "frontend developer": [
+            "javascript","react","html",
+            "css","typescript","frontend"
+        ],
+
+        "full stack developer": [
+            "javascript","react","node.js",
+            "sql","html","css","api"
+        ],
+
+        "devops engineer": [
+            "docker","kubernetes","aws",
+            "ci/cd","terraform","linux"
+        ],
+
+        "ai engineer": [
+            "python","deep learning","pytorch",
+            "tensorflow","transformers","nlp"
+        ],
+
+        "nlp engineer": [
+            "python","nlp","transformers",
+            "bert","machine learning"
+        ],
+
+        "cloud engineer": [
+            "aws","azure","gcp",
+            "docker","kubernetes"
+        ]
+    }
+
+    for key in mapping:
+        if key in title:
+            return mapping[key]
+
+    return []
+
+
+def calculate_skills_score(resume_skills, job_skills):
+
+    if not job_skills:
+        return 0
+
+    matches = set(resume_skills).intersection(set(job_skills))
+
+    return len(matches) / len(job_skills)
+
+
+def score_resume_by_title(text, title, level):
+
+    job_skills = get_job_requirements(title)
+
+    resume_skills = skills_from_text(text)
+
+    skill_score = calculate_skills_score(resume_skills, job_skills)
+
+    exp = extract_years_of_experience(text)
+
+    title_embedding = model.encode(title)
+    resume_embedding = model.encode(text[:2000])
+
+    similarity = util.cos_sim(title_embedding, resume_embedding).item()
+
+    # level logic
+    level = level.lower()
+
+    if level == "entry":
+        required_exp = 0
+    elif level == "junior":
+        required_exp = 1
+    elif level == "mid":
+        required_exp = 3
+    else:
+        required_exp = 5
+
+    decision = "ACCEPT"
+    reasons = []
+
+    if skill_score < 0.4:
+        decision = "REJECT"
+        reasons.append("Low skill match")
+
+    if exp < required_exp:
+        decision = "REJECT"
+        reasons.append("Insufficient experience")
+
+    if similarity < 0.3:
+        decision = "REJECT"
+        reasons.append("Low semantic match with job title")
+
+    return {
+        "decision": decision,
+        "skill_score": round(skill_score,3),
+        "similarity": round(similarity,3),
+        "experience_years": exp,
+        "resume_skills": resume_skills,
+        "job_skills": job_skills,
+        "reasons": reasons
+    }

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+gradio
+pandas
+sentence-transformers
+pytesseract
+pypdf2
+pdf2image
+python-docx
+Pillow

resume_parser.py

@@ -0,0 +1,79 @@
+import os
+import re
+import tempfile
+import pytesseract
+import PyPDF2
+import docx
+
+from PIL import Image
+from pdf2image import convert_from_path
+
+
+def clean_text(text):
+    if not text:
+        return ""
+    text = str(text)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def extract_text_from_image(file_path):
+    try:
+        img = Image.open(file_path)
+        text = pytesseract.image_to_string(img)
+        return clean_text(text)
+    except:
+        return ""
+
+
+def extract_text_from_docx(file_path):
+    try:
+        doc = docx.Document(file_path)
+        text = " ".join([p.text for p in doc.paragraphs])
+        return clean_text(text)
+    except:
+        return ""
+
+
+def extract_text_from_pdf(file_path):
+    text = ""
+
+    try:
+        with open(file_path, "rb") as f:
+            reader = PyPDF2.PdfReader(f)
+
+            for page in reader.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text + " "
+    except:
+        pass
+
+    if len(text.strip()) < 100:
+        try:
+            images = convert_from_path(file_path)
+
+            for image in images:
+                with tempfile.NamedTemporaryFile(suffix=".png") as tmp:
+                    image.save(tmp.name)
+                    text += extract_text_from_image(tmp.name)
+        except:
+            pass
+
+    return clean_text(text)
+
+
+def parse_resume(file_path):
+
+    ext = os.path.splitext(file_path)[1].lower()
+
+    if ext == ".pdf":
+        return extract_text_from_pdf(file_path)
+
+    if ext in [".docx", ".doc"]:
+        return extract_text_from_docx(file_path)
+
+    if ext in [".png", ".jpg", ".jpeg"]:
+        return extract_text_from_image(file_path)
+
+    return ""