added modular functions, config, model

ai_model.py

@@ -0,0 +1,13 @@
+import requests
+import json
+from config import HUGGINGFACE_API_URL, HUGGINGFACE_API_KEY
+
+HEADERS = {"Authorization": f"Bearer {HUGGINGFACE_API_KEY}"}
+
+def analyze_resume(text):
+    """Send resume text to Google Gemini model via Hugging Face API."""
+    data = {"inputs": text}
+    response = requests.post(HUGGINGFACE_API_URL, headers=HEADERS, data=json.dumps(data))
+    if response.status_code == 200:
+        return response.json()["output"]
+    return {"score": 0, "summary": "Error processing resume"}

app.py

@@ -1,24 +1,36 @@
 import streamlit as st
-import requests
-from database import save_resume_data
-from crewai import ResumeAgents
+from database import get_db, Candidate
+from resume_parser import extract_text_from_pdf
+from ai_model import analyze_resume
+from pdf_generator import generate_summary_pdf
+from sqlalchemy.orm import Session
 
 st.title("AI-Powered Resume Screening")
 
-uploaded_files = st.file_uploader("Upload Resumes", accept_multiple_files=True, type=["pdf", "txt"])
+uploaded_files = st.file_uploader("Upload Resumes", type=["pdf"], accept_multiple_files=True)
 
-job_description = st.text_area("Enter Job Description")
-
-if st.button("Process Resumes"):
-    results = []
+if uploaded_files:
+    db: Session = next(get_db())
+    candidates = []
     
-    for uploaded_file in uploaded_files:
-        resume_text = uploaded_file.read().decode("utf-8")
-        parsed_details = ResumeAgents.parse_resume(resume_text)
-        ranking_score = ResumeAgents.rank_resume(parsed_details, job_description)
-        
-        save_resume_data(resume_text, parsed_details, ranking_score)
+    for file in uploaded_files:
+        resume_text = extract_text_from_pdf(file)
+        analysis_result = analyze_resume(resume_text)
+        score = int(analysis_result.get("score", 0))
+        summary = analysis_result.get("summary", "No summary available")
         
-        results.append(f"Resume: {uploaded_file.name}\nRank: {ranking_score}\nDetails: {parsed_details}")
+        new_candidate = Candidate(name=file.name, score=score, summary=summary, resume_text=resume_text)
+        db.add(new_candidate)
+        candidates.append(new_candidate)
+    
+    db.commit()
+    
+    # Generate shortlist
+    shortlisted = sorted(candidates, key=lambda x: x.score, reverse=True)[:5]
+    pdf_path = generate_summary_pdf(shortlisted)
+    
+    st.success("Top candidates shortlisted!")
+    st.download_button("Download Shortlist PDF", open(pdf_path, "rb"), file_name="shortlisted_candidates.pdf")
 
-    st.write("\n\n".join(results))
+    # the link expiration time is set to 24 hours
+    # file format output to pdf.

config.py

@@ -0,0 +1,12 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Retrieve environment variables
+DATABASE_URL = os.getenv(postgresql://@localhost:5433/candidate)
+HUGGINGFACE_API_URL = os.getenv("HUGGINGFACE_API_URL")
+HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY")
+if not DATABASE_URL or not HUGGINGFACE_API_URL or not HUGGINGFACE_API_KEY:
+    raise ValueError("One or more environment variables are missing. Please check your .env file.")

crewai.py

@@ -1,30 +0,0 @@
-from crewai import Crew, Agent, Task
-from huggingface_hub import InferenceClient
-import os
-
-HF_API_URL = "https://api-inference.huggingface.co/models/YOUR_MODEL"
-HF_API_KEY = "your_api_key"
-
-client = InferenceClient(token=HF_API_KEY)
-
-class ResumeAgents:
-    @staticmethod
-    def parse_resume(resume_text):
-        """Agent to extract key resume details"""
-        prompt = f"Extract skills, experience, and education from this resume:\n{resume_text}"
-        response = client.text_generation(prompt)
-        return response
-
-    @staticmethod
-    def rank_resume(resume_details, job_description):
-        """Agent to rank the resume against the job description"""
-        prompt = f"Rank this resume based on the job description:\nJob: {job_description}\nResume: {resume_details}"
-        response = client.text_generation(prompt)
-        return response
-
-    @staticmethod
-    def recommend_candidates(resume_rankings):
-        """Agent to recommend the best candidates"""
-        prompt = f"Recommend the top candidates based on rankings:\n{resume_rankings}"
-        response = client.text_generation(prompt)
-        return response

database.py

@@ -1,14 +1,21 @@
-import psycopg2
-from sqlalchemy import create_engine
-
-DATABASE_URL = "postgresql://user:password@localhost:5432/resumes_db"
+from sqlalchemy import create_engine, Column, Integer, String, Text
+from sqlalchemy.orm import sessionmaker, declarative_base
+from config import DATABASE_URL  # Import from config.py
 
+# Set up SQLAlchemy
+Base = declarative_base()
 engine = create_engine(DATABASE_URL)
+SessionLocal = sessionmaker(bind=engine)
+
+# Define Candidate Model
+class Candidate(Base):
+    __tablename__ = "candidates"
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, index=True)
+    score = Column(Integer)
+    summary = Column(Text)
+    resume_text = Column(Text)
+    pdf_link = Column(String)
 
-def save_resume_data(resume_text, parsed_details, ranking_score):
-    """Save parsed resume details and ranking score to DB"""
-    with engine.connect() as conn:
-        conn.execute(
-            "INSERT INTO resumes (resume_text, parsed_details, ranking_score) VALUES (%s, %s, %s)",
-            (resume_text, parsed_details, ranking_score)
-        )
+# Create tables
+Base.metadata.create_all(bind=engine)

pdf_generator.py

@@ -0,0 +1,16 @@
+from reportlab.pdfgen import canvas
+import tempfile
+
+def generate_summary_pdf(candidates):
+    """Generate a PDF report for shortlisted candidates."""
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+    c = canvas.Canvas(temp_file.name)
+    
+    c.drawString(100, 800, "Shortlisted Candidates")
+    y = 780
+    for candidate in candidates:
+        y -= 20
+        c.drawString(100, y, f"{candidate.name} - Score: {candidate.score}")
+    
+    c.save()
+    return temp_file.name  # Return path to the PDF

resume_parser.py

@@ -0,0 +1,9 @@
+import fitz  # PyMuPDF
+
+def extract_text_from_pdf(pdf_file):
+    """Extract text from a given PDF file."""
+    text = ""
+    with fitz.open(pdf_file) as doc:
+        for page in doc:
+            text += page.get_text()
+    return text