removed score and summarization functions until bug is fixed

app.py

@@ -1,5 +1,5 @@
 import streamlit as st
-from utils import evaluate_resumes, generate_pdf_report, store_in_supabase, score_candidate, extract_email, parse_resume
+from utils import evaluate_resumes, generate_pdf_report, store_in_supabase, extract_email, parse_resume #removed score_candidate, summarize_resume
 from config import supabase
 from config import HF_API_TOKEN, HF_HEADERS, HF_MODELS
 import fitz  # PyMuPDF
@@ -25,7 +25,7 @@ def main():
     if st.button("Evaluate Resumes"):
         shortlisted = evaluate_resumes(uploaded_files, job_description)
         for candidate in shortlisted:
-            st.write(f"**{candidate['name']}** - Score: {candidate['score']}")
+            st.write(f"**{candidate['name']}**") # removed - Score: {candidate['score']}
         
         # Generate PDF Report
         pdf_report = generate_pdf_report(shortlisted)

utils.py

@@ -13,24 +13,24 @@ def evaluate_resumes(uploaded_files, job_description):
     candidates = []
     for pdf_file in uploaded_files:
         resume_text = parse_resume(pdf_file)
-        score = score_candidate(resume_text, job_description)
+        #score = score_candidate(resume_text, job_description)
         email = extract_email(resume_text)
 
-        # Generate a summary of the resume
-        summary = summarize_resume(resume_text)
+        # # Generate a summary of the resume
+        # summary = summarize_resume(resume_text)
 
         candidates.append({
             "name": pdf_file.name,
             "resume": resume_text,
-            "score": score,
+            #"score": score,
             "email": email,
-            "summary": summary
+            #"summary": summary
         })
 
         # Store all details including summary in Supabase
-        store_in_supabase(resume_text, score, pdf_file.name, email, summary)
+        store_in_supabase(resume_text, pdf_file.name, email) # removed score, summary
 
-    return sorted(candidates, key=lambda x: x["score"], reverse=True)[:5]  # Return top 5 candidates
+    return candidates  # removed , key=lambda x: x["score"], reverse=True)[:5]
 
 def parse_resume(pdf_file):
     """Extracts text from a resume PDF."""
@@ -43,58 +43,58 @@ def extract_email(resume_text):
     match = re.search(r"[\w\.-]+@[\w\.-]+", resume_text)
     return match.group(0) if match else None
 
-def score_candidate(resume_text, job_description):
-    """
-    Scores the candidate's resume based on the job description using the Hugging Face API.
+# def score_candidate(resume_text, job_description):
+#     """
+#     Scores the candidate's resume based on the job description using the Hugging Face API.
     
-    :param resume_text: The extracted resume text.
-    :param job_description: The job description for comparison.
-    :return: A numerical score (default 0 if scoring fails).
-    """
-    payload = {"inputs": f"Resume: {resume_text}\nJob Description: {job_description}"}
-    response_gemma = query(payload, model="gemma")  # Call Hugging Face API
-
-    if response_gemma is None:
-        print("API response is None")
-        return 0  
-
-    print("API Response:", response_gemma)  # Debugging
-
-    # Handle list response
-    if isinstance(response_gemma, list) and len(response_gemma) > 0:
-        response_gemma = response_gemma[0]  # Extract first item if response is a list
-
-    try:
-        if isinstance(response_gemma, dict) and "score" in response_gemma:
-            return float(response_gemma["score"])
-        else:
-            print("Unexpected API response format:", response_gemma)  # Debugging
-            return 0  # Default if score is missing
-    except (TypeError, ValueError) as e:
-        print(f"Error parsing score: {e}")
-        return 0  
-
-# summarize_resume function will use HuggingFace BART model
-def summarize_resume(resume_text):
-    """
-    Summarizes the resume using Facebook's BART-Large-CNN model.
+#     :param resume_text: The extracted resume text.
+#     :param job_description: The job description for comparison.
+#     :return: A numerical score (default 0 if scoring fails).
+#     """
+#     payload = {"inputs": f"Resume: {resume_text}\nJob Description: {job_description}"}
+#     response_gemma = query(payload, model="gemma")  # Call Hugging Face API
+
+#     if response_gemma is None:
+#         print("API response is None")
+#         return 0  
+
+#     print("API Response:", response_gemma)  # Debugging
+
+#     # Handle list response
+#     if isinstance(response_gemma, list) and len(response_gemma) > 0:
+#         response_gemma = response_gemma[0]  # Extract first item if response is a list
+
+#     try:
+#         if isinstance(response_gemma, dict) and "score" in response_gemma:
+#             return float(response_gemma["score"])
+#         else:
+#             print("Unexpected API response format:", response_gemma)  # Debugging
+#             return 0  # Default if score is missing
+#     except (TypeError, ValueError) as e:
+#         print(f"Error parsing score: {e}")
+#         return 0  
+
+# # summarize_resume function will use HuggingFace BART model
+# def summarize_resume(resume_text):
+#     """
+#     Summarizes the resume using Facebook's BART-Large-CNN model.
     
-    :param resume_text: The extracted resume text.
-    :return: A summarized version of the resume or an error message.
-    """
-    payload = {"inputs": resume_text}
-    response_bart = query(payload, model="bart")
-
-    if response_bart is None:
-        return "Summary could not be generated."  # Handle API failures gracefully
-
-    try:
-        summary = response_bart[0].get("summary_text", "Summary not available.")
-        return summary
-    except (IndexError, KeyError):
-        return "Summary not available."
-
-def store_in_supabase(resume_text, score, candidate_name, email, summary):
+#     :param resume_text: The extracted resume text.
+#     :return: A summarized version of the resume or an error message.
+#     """
+#     payload = {"inputs": resume_text}
+#     response_bart = query(payload, model="bart")
+
+#     if response_bart is None:
+#         return "Summary could not be generated."  # Handle API failures gracefully
+
+#     try:
+#         summary = response_bart[0].get("summary_text", "Summary not available.")
+#         return summary
+#     except (IndexError, KeyError):
+#         return "Summary not available."
+
+def store_in_supabase(resume_text, candidate_name, email, ): # removed score, summary
     """
     Stores resume data in Supabase.
 
@@ -104,21 +104,20 @@ def store_in_supabase(resume_text, score, candidate_name, email, summary):
     :param email: Candidate's email address.
     :param summary: A summarized version of the resume.
     """
-    if score is None:
-        score = 0  # Ensure score is never NULL
+    # if score is None:
+    #     score = 0  # Ensure score is never NULL
 
     data = {
         "name": candidate_name,
         "resume": resume_text,
-        "score": score,
+        #"score": score,
         "email": email,
-        "summary": summary
+        #"summary": summary
     }
 
     response = supabase.table("candidates").insert(data).execute()
     return response
 
-# Test with 10 resumes, if they will be shortlisted
 def generate_pdf_report(shortlisted_candidates):
     """Generates a PDF summary of shortlisted candidates."""
     pdf = BytesIO()
@@ -127,15 +126,15 @@ def generate_pdf_report(shortlisted_candidates):
     for candidate in shortlisted_candidates:
         page = doc.new_page()
 
-        # Use the stored summary, or provide a fallback
-        summary = candidate.get("summary", "No summary available")
+        # # Use the stored summary, or provide a fallback
+        # summary = candidate.get("summary", "No summary available")
 
         page.insert_text(
             (50, 50),
             f"Candidate: {candidate['name']}\n"
             f"Email: {candidate['email']}\n"
-            f"Score: {candidate['score']}\n"
-            f"Summary: {summary}"
+            #f"Score: {candidate['score']}\n"
+            #f"Summary: {summary}"
         )
 
     doc.save(pdf)