Update app.py

app.py

@@ -1,9 +1,12 @@
+
 import os
 import re
 import json
 import csv
 import tempfile
 import time
+import subprocess
+import shutil
 from typing import List, Dict, Any, Tuple
 import PyPDF2
 import docx2txt
@@ -11,14 +14,16 @@ import gradio as gr
 import pandas as pd
 import logging
 from openai import OpenAI
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import gradio.themes.soft as SoftTheme # For the UI theme
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
 # Global Configuration
-DEEPINFRA_API_KEY = "kPEm10rrnxXrCf0TuB6Xcd7Y7lp3YgKa" 
+DEEPINFRA_API_KEY = "kPEm10rrnxXrCf0TuB6Xcd7Y7lp3YgKa"
 DEEPINFRA_BASE_URL = "https://api.deepinfra.com/v1/openai"
-DEFAULT_MODEL = "Qwen/Qwen3-32B"
+DEFAULT_MODEL = "openai/gpt-oss-120b"
 REQUEST_TIMEOUT_SECS = 120
 
 # OpenAI client for DeepInfra
@@ -97,6 +102,8 @@ Scoring Guide:
 
 Keep each bullet short (max ~12 words).
 Output ONLY JSON.
+
+
 """
 
 RECOMMEND_SYSTEM = """You are a senior technical recruiter writing a concise recommendation summary for a hiring manager.
@@ -121,6 +128,31 @@ def _txt_to_text(path: str) -> str:
 def _docx_to_text(path: str) -> str:
     return docx2txt.process(path) or ""
 
+def _doc_to_text_using_external_tool(path: str) -> str:
+    if shutil.which("antiword"):
+        try:
+            out = subprocess.check_output(["antiword", path], stderr=subprocess.DEVNULL)
+            return out.decode(errors="ignore")
+        except Exception as e:
+            logging.debug(f"antiword failed for {path}: {e}")
+    if shutil.which("catdoc"):
+        try:
+            out = subprocess.check_output(["catdoc", path], stderr=subprocess.DEVNULL)
+            return out.decode(errors="ignore")
+        except Exception as e:
+            logging.debug(f"catdoc failed for {path}: {e}")
+    if shutil.which("soffice"):
+        try:
+            tmpdir = tempfile.mkdtemp()
+            subprocess.run(["soffice", "--headless", "--convert-to", "txt:Text", "--outdir", tmpdir, path], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            basename = os.path.splitext(os.path.basename(path))[0] + ".txt"
+            txt_path = os.path.join(tmpdir, basename)
+            if os.path.exists(txt_path):
+                return _txt_to_text(txt_path)
+        except Exception as e:
+            logging.debug(f"libreoffice conversion failed for {path}: {e}")
+    return f"[Unsupported or unreadable .doc file: {os.path.basename(path)}. Install antiword/catdoc or libreoffice to enable .doc reading]"
+
 def read_file_safely(path: str) -> str:
     try:
         low = path.lower()
@@ -130,39 +162,32 @@ def read_file_safely(path: str) -> str:
             return _txt_to_text(path)
         if low.endswith(".docx"):
             return _docx_to_text(path)
+        if low.endswith(".doc"):
+            return _doc_to_text_using_external_tool(path)
         return f"[Unsupported file type: {os.path.basename(path)}]"
     except Exception as e:
         logging.error(f"Error reading file {path}: {e}")
         return f"[Error reading file: {e}]"
 
 def safe_json_loads(text: str) -> dict:
-    """
-    Robustly parses JSON from a string, even if it's embedded in other text
-    or a markdown block.
-    """
     text = text or ""
     try:
-        # First, attempt to find a JSON markdown block
         match = re.search(r"```json\s*(.*?)```", text, re.DOTALL | re.IGNORECASE)
         if match:
             block = match.group(1)
         else:
-            # If no markdown, find the outermost curly braces
             start_index = text.find('{')
             end_index = text.rfind('}')
             if start_index != -1 and end_index != -1 and end_index > start_index:
                 block = text[start_index : end_index + 1]
             else:
-                # Fallback if no JSON structure is found at all
                 logging.error(f"Could not find any JSON object in the text: {text[:500]}...")
                 return {}
-
         return json.loads(block)
     except Exception as e:
         logging.error(f"Failed to parse JSON: {e}\nRaw Text: {text[:500]}...")
         return {}
 
-
 # --- LLM Chat Wrapper ---
 def deepinfra_chat(messages: List[Dict[str, str]], api_key: str, model: str, temperature: float = 0.2) -> str:
     try:
@@ -205,10 +230,6 @@ def load_resume(resume_file) -> Tuple[str, str]:
 
 # --- Resume Normalizer ---
 def normalize_resume(raw_resume: Dict) -> Dict:
-    """
-    Normalize a resume dictionary to ensure all expected fields exist,
-    and add 'summary' which can contain candidate's profile, summary, or objective.
-    """
     return {
         "name": raw_resume.get("name", "").strip(),
         "email": raw_resume.get("email", "").strip(),
@@ -220,6 +241,7 @@ def normalize_resume(raw_resume: Dict) -> Dict:
         "languages": raw_resume.get("languages", []) or [],
         "certificates": raw_resume.get("certificates", []) or [],
         "soft_skills": raw_resume.get("soft_skills", []) or [],
+        "Projects": raw_resume.get("Projects", []) or [],
         "summary": raw_resume.get("summary", "") or raw_resume.get("profile", "") or raw_resume.get("objective", "")
     }
 
@@ -269,6 +291,8 @@ def prompt_for_match(jd_struct: Dict[str, Any], cv_structs: List[Dict[str, Any]]
             "experience_titles": [e.get("title","") for e in (c.get("experience") or [])][:30],
             "education": [e.get("degree","") for e in (c.get("education") or [])][:20],
             "languages": c.get("languages", [])[:20],
+            "certificates": c.get("certificates", [])[:20],
+            "Projects": c.get("Projects", [])[:20],
         })
 
     system = (
@@ -304,7 +328,6 @@ def parse_ranked_output(content: str) -> List[Dict[str, Any]]:
                 "justification": str(it.get("justification","")).strip(),
             })
         return rows
-    # Add another check for a list of candidates directly
     if isinstance(parsed, list):
         for it in parsed:
             rows.append({
@@ -313,11 +336,51 @@ def parse_ranked_output(content: str) -> List[Dict[str, Any]]:
                 "justification": str(it.get("justification","")).strip(),
             })
         return rows
-    if not rows: # Fallback for unexpected output
+    if not rows:
         logging.warning(f"Could not parse ranked output as JSON. Raw: {content[:500]}")
         rows = [{"candidate": "RAW_OUTPUT", "score": 0.0, "justification": (content or "")[:2000]}]
     return rows
 
+# --- New: process single resume (for parallel execution) ---
+def process_single_resume(f, jd_struct: Dict, api_key: str, model_name: str) -> Tuple[Dict, str, float]:
+    t0 = time.perf_counter()
+    text, fname = load_resume(f)
+    contacts = quick_contacts(text)
+    try:
+        raw_resume = llm_extract_resume(text, api_key=api_key, model=model_name)
+    except Exception as e:
+        logging.error(f"LLM resume extract failed for {fname}: {e}")
+        raw_resume = {}
+
+    cand_struct = normalize_resume(raw_resume)
+
+    if not cand_struct.get("name"):
+        cand_struct["name"] = os.path.splitext(fname)[0]
+
+    cand_struct.setdefault("email", cand_struct.get("email") or contacts["email_guess"])
+    cand_struct.setdefault("phone", cand_struct.get("phone") or contacts["phone_guess"])
+
+    try:
+        detailed_feedback = llm_detailed_feedback(jd_struct, cand_struct, api_key, model_name)
+    except Exception as e:
+        logging.error(f"LLM detailed feedback failed for {fname}: {e}")
+        detailed_feedback = {}
+        
+    cand_struct['detailed_scores'] = detailed_feedback.get('scores', {})
+    cand_struct['summary_feedback'] = detailed_feedback.get('overall_summary', '')
+    cand_struct['strengths'] = detailed_feedback.get('strengths', [])
+    cand_struct['weaknesses'] = detailed_feedback.get('weaknesses', [])
+    cand_struct['missing_requirements'] = detailed_feedback.get('missing_requirements', [])
+
+    try:
+        cand_struct["recommendation"] = llm_recommend(jd_struct, cand_struct, api_key, model_name)
+    except Exception as e:
+        logging.error(f"LLM recommendation failed for {fname}: {e}")
+        cand_struct["recommendation"] = ""
+
+    t_elapsed = time.perf_counter() - t0
+    return cand_struct, fname, t_elapsed
+
 def process(
     jd_text,
     jd_file,
@@ -333,7 +396,6 @@ def process(
     temperature = 0.2
     top_n = 5
 
-    # --- JD ---
     t_jd_start = time.perf_counter()
     jd_raw = load_job_description(jd_text or "", jd_file)
     if not jd_raw.strip():
@@ -342,45 +404,32 @@ def process(
     t_jd = time.perf_counter() - t_jd_start
     logging.info(f"JD parsing time: {t_jd:.2f}s")
 
-    # --- Resumes parse ---
     if not resume_files or len(resume_files) == 0:
-        raise gr.Error("Please upload at least one resume (PDF or DOCX).")
+        raise gr.Error("Please upload at least one resume (PDF, DOCX, DOC, or TXT).")
+
     parsed_cands = []
     name_to_file = {}
     t_parse_total = 0.0
-    for f in resume_files[:50]: # Limit to 50 resumes
-        t_parse_s = time.perf_counter()
-        text, fname = load_resume(f)
-        contacts = quick_contacts(text)
-        raw_resume = llm_extract_resume(text, api_key=api_key, model=model_name)
-        cand_struct = normalize_resume(raw_resume)
-        
-        # Ensure name is not empty
-        if not cand_struct.get("name"):
-            cand_struct["name"] = os.path.splitext(fname)[0]
-
-        cand_struct.setdefault("email", cand_struct.get("email") or contacts["email_guess"])
-        cand_struct.setdefault("phone", cand_struct.get("phone") or contacts["phone_guess"])
-
-        # Add detailed feedback
-        detailed_feedback = llm_detailed_feedback(jd_struct, cand_struct, api_key, model_name)
-        cand_struct['detailed_scores'] = detailed_feedback.get('scores', {})
-        cand_struct['summary_feedback'] = detailed_feedback.get('overall_summary', '')
-        cand_struct['strengths'] = detailed_feedback.get('strengths', [])
-        cand_struct['weaknesses'] = detailed_feedback.get('weaknesses', [])
-        cand_struct['missing_requirements'] = detailed_feedback.get('missing_requirements', [])
-        
-        # Generate recommendations
-        cand_struct["recommendation"] = llm_recommend(jd_struct, cand_struct, api_key, model_name)
-
-        parsed_cands.append(cand_struct)
-        name_to_file[cand_struct["name"]] = fname
-        t_parse_total += (time.perf_counter() - t_parse_s)
+    files_to_process = resume_files[:50]
+    max_workers = min(8, max(1, len(files_to_process)))
+
+    futures = []
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        for f in files_to_process:
+            futures.append(executor.submit(process_single_resume, f, jd_struct, api_key, model_name))
+
+        for future in as_completed(futures):
+            try:
+                cand_struct, fname, elapsed = future.result()
+                parsed_cands.append(cand_struct)
+                name_to_file[cand_struct["name"]] = fname
+                t_parse_total += elapsed
+            except Exception as e:
+                logging.error(f"Error processing a resume in parallel: {e}")
 
     avg_parse = (t_parse_total / max(1, len(parsed_cands)))
-    logging.info(f"Total resume parsing time: {t_parse_total:.2f}s, avg: {avg_parse:.2f}s")
+    logging.info(f"Total resume parsing time: {t_parse_total:.2f}s, avg per file: {avg_parse:.2f}s")
 
-    # --- Matching ---
     t_match_start = time.perf_counter()
     match_msgs = prompt_for_match(jd_struct, parsed_cands, conditional_req)
     raw_match = deepinfra_chat(match_msgs, api_key=api_key, model=model_name, temperature=temperature)
@@ -413,31 +462,33 @@ def process(
             **detailed_scores,
             "recommendation": c.get("recommendation", ""),
             "summary_feedback": c.get('summary_feedback', ''),
-            "strengths": ", ".join(c.get("strengths", [])),
-            "weaknesses": ", ".join(c.get("weaknesses", [])),
-            "missing_requirements": ", ".join(c.get("missing_requirements", [])),
-            "justification": just
+            "strengths": ", ".join([str(s) for s in c.get("strengths", [])]),
+            "weaknesses": ", ".join([str(s) for s in c.get("weaknesses", [])]),
+            "missing_requirements": ", ".join([str(s) for s in c.get("missing_requirements", [])]),
+            "justification": just,
+            "full_json": json.dumps(c, ensure_ascii=False)
         })
 
-    df_export = pd.DataFrame(export_rows).sort_values("score", ascending=False)
-    df_table = pd.DataFrame(table_rows).sort_values("Score (0-10)", ascending=False)
-    
-    # Prepare top candidates DF for display, including the recommendation
+    df_export = pd.DataFrame(export_rows)
+    if "score" in df_export.columns:
+        df_export = df_export.sort_values("score", ascending=False)
+    df_table = pd.DataFrame(table_rows)
+    if "Score (0-10)" in df_table.columns:
+        df_table = df_table.sort_values("Score (0-10)", ascending=False)
+
     top_candidates_data = []
     for _, row in df_export.head(top_n).iterrows():
         top_candidates_data.append({
-            "Candidate": row["candidate"],
-            "Score": row["score"],
-            "Recommendation": row["recommendation"],
-            "Justification": row["justification"],
+            "Candidate": row.get("candidate", ""),
+            "Score": row.get("score", 0),
+            "Recommendation": row.get("recommendation", ""),
+            "Justification": row.get("justification", ""),
         })
     top_df = pd.DataFrame(top_candidates_data)
 
-
-    # --- Create a temporary file for the CSV export ---
     with tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix='.csv', encoding='utf-8') as tmp_file:
         df_export.to_csv(tmp_file.name, index=False)
-        csv_file_path = tmp_file.name # Get the path of the saved file
+        csv_file_path = tmp_file.name
 
     t_total = time.perf_counter() - t0
     logging.info(f"Total process time: {t_total:.2f}s")
@@ -445,36 +496,111 @@ def process(
     return df_table, csv_file_path, top_df
 
 # --- Gradio App ---
-with gr.Blocks(title="AI Resume Matcher & Ranking") as demo:
-    gr.Markdown("## 🤖 AI Resume Matcher & Ranking")
+
+CUSTOM_CSS = """
+/* Add a subtle background gradient and use a nicer font */
+.gradio-container {
+    background-image: linear-gradient(to top, #f3e7e9 0%, #e3eeff 99%, #e3eeff 100%);
+    font-family: 'IBM Plex Sans', sans-serif;
+}
+/* Style the input/output areas like cards */
+.gradio-row > .gradio-column, .gradio-group {
+    border: 1px solid #E5E7EB;
+    border-radius: 12px;
+    box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1);
+    background-color: white;
+    padding: 15px;
+}
+/* Make the file upload area more prominent */
+.gradio-file {
+    border: 2px dashed #A4B0BE;
+    border-radius: 8px;
+    padding: 20px;
+    transition: all 0.2s ease;
+}
+.gradio-file:hover {
+    border-color: #4A90E2;
+    background-color: #F9FAFB;
+}
+"""
+
+with gr.Blocks(theme=SoftTheme.Soft(), css=CUSTOM_CSS, title="AI Resume Matcher") as demo:
+    gr.Markdown(
+        "<h1 style='text-align: center; color: #1E3A8A;'>🤖 AI Resume Matcher & Ranking</h1>"
+        "<p style='text-align: center; color: #4B5563;'>Upload a job description and resumes to automatically rank candidates.</p>"
+    )
+
     with gr.Row():
-        with gr.Column(scale=1):
-            jd_text = gr.Textbox(label="Paste Job Description", lines=10)
-            jd_file = gr.File(label="Or Upload JD File (.txt, .pdf, .docx)")
-            resume_files = gr.File(label="Upload Resumes (.pdf, .docx, .txt)", file_types=[".pdf", ".docx", ".txt"], file_count="multiple")
-            
-            with gr.Accordion("Advanced Options", open=False):
-                # Note: The sliders are for future use and are not currently wired into the LLM ranking prompt.
-                w_skill = gr.Slider(label="Weight: Skills", minimum=0, maximum=1, value=0.25, interactive=False)
-                w_qual = gr.Slider(label="Weight: Qualifications", minimum=0, maximum=1, value=0.25, interactive=False)
-                w_resp = gr.Slider(label="Weight: Responsibilities", minimum=0, maximum=1, value=0.25, interactive=False)
-                conditional_req = gr.Textbox(label="Conditional Requirement (optional)", placeholder="e.g., 'Must have experience with AWS services'")
+        with gr.Column(scale=2):
+            gr.Markdown("### 📂 Step 1: Provide Inputs")
+            with gr.Group():
+                jd_text = gr.Textbox(label="Paste Job Description", lines=8, placeholder="Paste the full job description here...")
+                jd_file = gr.File(label="Or Upload JD File (.txt, .pdf, .docx)")
             
-            submit_btn = gr.Button("Run Matching & Ranking", variant="primary")
+            resume_files = gr.File(
+                label="📂 Step 2: Upload Resumes (.pdf, .docx, .doc, .txt)",
+                file_types=[".pdf", ".docx", ".doc", ".txt"],
+                file_count="multiple"
+            )
+
+            with gr.Accordion("⚙️ Advanced Options", open=False):
+                conditional_req = gr.Textbox(
+                    label="Conditional Requirement (Optional)",
+                    placeholder="e.g., 'Must have 5+ years of Python experience'"
+                )
+
+            with gr.Row():
+                clear_btn = gr.Button("Clear All")
+                submit_btn = gr.Button("🚀 Run Matching & Ranking", variant="primary", scale=2)
+
+        with gr.Column(scale=3):
+            gr.Markdown("### ✨ Step 3: View Results")
+            status_md = gr.Markdown("Status: Ready. Please provide inputs and click Run.", visible=True)
+
+            with gr.Tabs():
+                with gr.TabItem("🏆 Top Candidates Summary"):
+                    top_table = gr.DataFrame(label="Top 5 Candidates", interactive=False, headers=["Candidate", "Score", "Recommendation", "Justification"])
+                with gr.TabItem("📊 Detailed Ranking"):
+                    results_table = gr.DataFrame(label="Full Candidate Ranking")
+                with gr.TabItem("📥 Download Report"):
+                    gr.Markdown("Click the file below to download the complete analysis, including all extracted data and feedback, in CSV format.")
+                    csv_export = gr.File(label="Download Full Report (CSV)")
+    
+    # This is a new state object to hold the results to avoid re-running the 'process' function
+    results_state = gr.State({})
 
-        with gr.Column(scale=2):
-            gr.Markdown("### Top Candidates Summary")
-            top_table = gr.DataFrame(label="Top Candidates", interactive=False)
-            gr.Markdown("### Detailed Ranking")
-            results_table = gr.DataFrame(label="Candidate Ranking")
-            csv_export = gr.File(label="Download Full Report (CSV)")
+    def run_process_and_update_status(jd_text, jd_file, resume_files, conditional_req):
+        yield gr.Markdown(value="⏳ Processing... Analyzing job description and resumes. This may take a moment.", visible=True), \
+              pd.DataFrame(), pd.DataFrame(), None, {} # Clear previous results while running
+        
+        try:
+            df_table, csv_path, top_df = process(jd_text, jd_file, resume_files, conditional_req)
+            status_message = f"✅ Done! Analyzed {len(df_table)} resumes. See results below."
+            results = {
+                "df_table": df_table,
+                "csv_path": csv_path,
+                "top_df": top_df
+            }
+            yield gr.Markdown(value=status_message, visible=True), df_table, top_df, csv_path, results
+        except Exception as e:
+            yield gr.Markdown(value=f"❌ Error: {e}", visible=True), \
+                  pd.DataFrame(), pd.DataFrame(), None, {}
+
+    def clear_all():
+        return None, None, [], "", pd.DataFrame(), pd.DataFrame(), None, gr.Markdown(value="Status: Cleared. Ready for new inputs.", visible=True), {}
 
     submit_btn.click(
-        process,
-        # Note: Sliders are removed from inputs as they are not used in the backend logic.
+        run_process_and_update_status,
         inputs=[jd_text, jd_file, resume_files, conditional_req],
-        outputs=[results_table, csv_export, top_table]
+        outputs=[status_md, results_table, top_table, csv_export, results_state]
     )
 
+    clear_btn.click(
+        clear_all,
+        inputs=[],
+        outputs=[jd_text, jd_file, resume_files, conditional_req, results_table, top_table, csv_export, status_md, results_state]
+    )
+
+
 if __name__ == "__main__":
     demo.launch()