Update app.py

app.py

@@ -1,146 +1,127 @@
 import gradio as gr
 import os
-from openai import OpenAI
-import PyPDF2
 import docx2txt
+import PyPDF2
 import json
+from openai import OpenAI
 
-# Initialize OpenAI client (for AI/ML API)
+# Replace this with your actual API key
 client = OpenAI(
-    api_key=os.environ.get("OPENAI_API_KEY"),
-    base_url="https://api.aimlapi.com/v1"
+    base_url="https://api.aimlapi.com/v1",
+    api_key=os.getenv("AIML_API_KEY")
 )
 
-# Helper functions
-def read_pdf(file_obj):
+# -------- Resume Parsing --------
+def extract_text_from_pdf(file):
     try:
-        reader = PyPDF2.PdfReader(file_obj)
-        text = ""
-        for page in reader.pages:
-            page_text = page.extract_text()
-            if page_text:
-                text += page_text + "\n"
-        return text
-    except Exception as e:
+        reader = PyPDF2.PdfReader(file)
+        return "\n".join([page.extract_text() or "" for page in reader.pages])
+    except Exception:
         return ""
 
-def read_docx(file_obj):
+def extract_text_from_docx(file):
     try:
-        return docx2txt.process(file_obj)
-    except Exception as e:
+        return docx2txt.process(file)
+    except Exception:
         return ""
 
-# Core logic
-def analyze_resumes(resume_files, job_description, min_years_exp=0):
-    if not resume_files or not job_description:
-        return ["⚠️ Please upload resumes and provide a job description."] * 3
-
-    resumes = []
-    for file in resume_files:
-        if file.name.endswith('.pdf'):
-            text = read_pdf(file)
-        elif file.name.endswith('.docx'):
-            text = read_docx(file)
-        else:
-            text = ""
-        resumes.append({
-            "filename": file.name,
-            "content": text
-        })
-
-    if not resumes:
-        return ["⚠️ No valid resumes found."] * 3
-
-    # Build a clear system prompt
-    system_prompt = f"""
-You are SmartHire, an AI Job Screening Assistant.
-Tasks:
-- Analyze candidate resumes.
-- Match against the job description.
-- Rank candidates.
-- Filter out candidates below {min_years_exp} years of experience.
-Respond in JSON format:
-[
-  {{
-    "name": "Candidate Name (or filename)",
-    "strengths": ["strength1", "strength2"],
-    "risks": ["risk1", "risk2"],
-    "score": number
-  }},
-  ...
-]
+def parse_resume(file):
+    ext = os.path.splitext(file.name)[1].lower()
+    if ext == ".pdf":
+        return extract_text_from_pdf(file)
+    elif ext == ".docx":
+        return extract_text_from_docx(file)
+    else:
+        return None
+
+# -------- AI Screening --------
+def call_ai_screening_agent(resume_texts, job_description, min_experience):
+    prompt = f"""
+You are an AI resume screening assistant. Compare each candidate's resume to the job description below.
+Only include candidates who meet the minimum required years of experience: {min_experience}.
+For each candidate, return:
+- name (from filename or parsed text)
+- strengths (2–5 key strengths)
+- risks (0–3 potential risks)
+- score (from 1 to 10)
+
+Job Description:
+\"\"\"{job_description}\"\"\"
+
+Resumes:
+{resume_texts}
+
+Return a JSON list of candidates as described.
 """
-
-    # Build the user input prompt
-    user_content = f"Job Description:\n{job_description}\n\nResumes:\n"
-    for idx, resume in enumerate(resumes):
-        user_content += f"\n---\nResume {idx+1} ({resume['filename']}):\n{resume['content']}\n"
-
     try:
-        # You may try "gpt-4-turbo" if "gpt-4o" yields no content.
         response = client.chat.completions.create(
-            model="gpt-4o",
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_content}
-            ],
-            temperature=0.2,
-            max_tokens=4096
+            model="gpt-4-turbo",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.2
         )
+        return json.loads(response.choices[0].message.content)
     except Exception as e:
-        return [f"⚠️ AI/ML API Error: {e}"] * 3
+        return {"error": str(e)}
+
+# -------- Main App Logic --------
+def process_resumes(files, job_description, min_experience):
+    if not files:
+        return "⚠️ Please upload at least one resume.", None
+    if not job_description.strip():
+        return "⚠️ Job description cannot be empty.", None
+
+    parsed_resumes = []
+    for file in files:
+        content = parse_resume(file)
+        if not content or len(content.strip()) == 0:
+            continue
+        parsed_resumes.append({"name": os.path.basename(file.name), "text": content})
+
+    if not parsed_resumes:
+        return "⚠️ Could not parse any valid resumes.", None
+
+    resume_texts = "\n\n".join([f"{r['name']}:\n{r['text']}" for r in parsed_resumes])
+    results = call_ai_screening_agent(resume_texts, job_description, min_experience)
+
+    if isinstance(results, dict) and "error" in results:
+        return f"⚠️ API Error: {results['error']}", None
+
+    # Display top 3 candidates
+    top_candidates = sorted(results, key=lambda x: x["score"], reverse=True)[:3]
+    display_md = ""
+    for candidate in top_candidates:
+        display_md += f"### {candidate['name']}  \n"
+        display_md += f"⭐ **Score**: {candidate['score']}  \n"
+        display_md += "✅ **Strengths**:\n"
+        for s in candidate['strengths']:
+            display_md += f"- ✅ {s}\n"
+        if candidate['risks']:
+            display_md += "⚠️ **Risks**:\n"
+            for r in candidate['risks']:
+                display_md += f"- ⚠️ {r}\n"
+        display_md += "\n---\n"
+
+    return None, display_md
+
+# -------- Gradio UI --------
+with gr.Blocks(title="SmartHire - AI Job Screening Assistant") as demo:
+    gr.Markdown("# 🤖 SmartHire — AI Job Screening Assistant")
+    gr.Markdown("Upload resumes and paste a job description to find the best candidates automatically!")
 
-    # Debug: check response message content before parsing as JSON
-    try:
-        resp_content = response.choices[0].message.content.strip()
-        if not resp_content:
-            return ["⚠️ AI response is empty. Please verify your prompt and API usage."] * 3
-        candidates = json.loads(resp_content)
-    except Exception as e:
-        # Optionally, you can print(response) to log the raw output for debugging.
-        return [f"⚠️ AI response parsing error: {e}"] * 3
-
-    try:
-        # Sort candidates by score descending
-        candidates = sorted(candidates, key=lambda x: x["score"], reverse=True)
-    except Exception as e:
-        return [f"⚠️ Sorting error: {e}"] * 3
-
-    # Build candidate cards for display
-    cards = []
-    for idx, candidate in enumerate(candidates[:3]):
-        strengths = "\n".join([f"- ✅ {s}" for s in candidate.get("strengths", [])])
-        risks = "\n".join([f"- ⚠️ {r}" for r in candidate.get("risks", [])])
-        card = f"""
-### {idx+1}. {candidate.get('name', 'Unknown')}
-**Strengths:**
-{strengths}
-**Risks:**
-{risks}
-**Fit Score:** {candidate.get('score', 'N/A')} ⭐
-"""
-        cards.append(card)
-
-    while len(cards) < 3:
-        cards.append("⚠️ Not enough candidates.")
+    with gr.Row():
+        resume_input = gr.File(file_types=[".pdf", ".docx"], file_count="multiple", label="Upload Resumes")
+        experience_input = gr.Number(label="Minimum Years of Experience", value=0)
 
-    return cards
+    job_desc_input = gr.Textbox(lines=8, placeholder="Paste the job description here...", label="Job Description")
+    process_button = gr.Button("Run Screening")
 
-# Gradio UI
-with gr.Blocks() as demo:
-    gr.Markdown("# 📄 SmartHire — AI Job Screening Assistant\nUpload candidate resumes and paste the job description to rank the best fits!")
+    error_output = gr.Textbox(label="Warnings / Errors", visible=False)
+    output_md = gr.Markdown()
 
-    with gr.Row():
-        with gr.Column():
-            resumes = gr.File(file_types=[".pdf", ".docx"], label="Upload Resumes", file_count="multiple")
-            jd = gr.Textbox(lines=8, label="Job Description")
-            min_exp = gr.Number(value=0, label="Minimum Years of Experience (Optional)")
-            submit = gr.Button("Analyze Candidates ✅")
-        with gr.Column():
-            output1 = gr.Markdown()
-            output2 = gr.Markdown()
-            output3 = gr.Markdown()
-
-    submit.click(analyze_resumes, inputs=[resumes, jd, min_exp], outputs=[output1, output2, output3])
+    process_button.click(
+        fn=process_resumes,
+        inputs=[resume_input, job_desc_input, experience_input],
+        outputs=[error_output, output_md]
+    )
 
 demo.launch()