Update app.py

app.py

@@ -10,11 +10,15 @@ import PyPDF2
 import docx2txt
 import gradio as gr
 import pandas as pd
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # Global Configuration
-DEEPINFRA_API_KEY = "285LUJulGIprqT6hcPhiXtcrphU04FG4"
-DEEPINFRA_BASE_URL = "https://api.deepinfra.com/v1/openai/chat/completions"
-DEFAULT_MODEL = "openai/gpt-oss-120b"
+DEEPINFRA_API_KEY = "kPEm10rrnxXrCf0TuB6Xcd7Y7lp3YgKa"
+DEEPINFRA_BASE_URL = "https://api.deepinfra.com/v1/openai"
+DEFAULT_MODEL = "Qwen/Qwen3-32B"
 REQUEST_TIMEOUT_SECS = 120
 
 # Prompts for LLM Calls
@@ -53,11 +57,19 @@ Schema:
 }
 """
 
-FEEDBACK_SYSTEM = """You are an expert technical recruiter. Compare a job and a candidate and return STRICT JSON with actionable feedback.
+# New feedback system prompt with detailed scoring
+FEEDBACK_SYSTEM_DETAILED = """You are an expert technical recruiter. Compare a job and a candidate and return STRICT JSON with actionable feedback and a detailed score breakdown.
 Respond in the job description's language.
+Scores should be out of 100.
 Schema:
 {
   "overall_summary": "",
+  "scores": {
+    "skills": 0,
+    "qualifications": 0,
+    "responsibilities": 0,
+    "education_and_experience": 0
+  },
   "strengths": [],
   "weaknesses": [],
   "missing_requirements": [],
@@ -67,6 +79,13 @@ Keep each bullet short (max ~12 words).
 Output ONLY JSON.
 """
 
+# New recommendation system prompt
+RECOMMEND_SYSTEM = """You are a senior technical recruiter writing a concise recommendation summary for a hiring manager.
+Based on the provided candidate and job description, write a 2-3 sentence summary explaining why this candidate is a good match.
+Focus on key skills, relevant experience, and overall fit. Do not use a conversational tone.
+Output ONLY the summary text, no markdown or extra formatting."""
+
+
 # Helper Functions
 def _pdf_to_text(path: str) -> str:
     text = []
@@ -94,6 +113,7 @@ def read_file_safely(path: str) -> str:
             return _docx_to_text(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:
@@ -101,7 +121,8 @@ def safe_json_loads(text: str) -> dict:
         m = re.search(r"```json\s*(.*?)```", text or "", re.DOTALL | re.IGNORECASE)
         block = m.group(1) if m else text
         return json.loads(block)
-    except Exception:
+    except Exception as e:
+        logging.error(f"Failed to parse JSON: {e}\nRaw Text: {text[:500]}...")
         return {}
 
 def deepinfra_chat(messages: List[Dict[str, str]], api_key: str, model: str, temperature: float = 0.2) -> str:
@@ -112,18 +133,22 @@ def deepinfra_chat(messages: List[Dict[str, str]], api_key: str, model: str, tem
         "messages": messages,
         "temperature": temperature,
     }
-    resp = requests.post(
-        DEEPINFRA_BASE_URL,
-        headers={
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-        },
-        data=json.dumps(payload),
-        timeout=REQUEST_TIMEOUT_SECS,
-    )
-    resp.raise_for_status()
-    data = resp.json()
-    return (data.get("choices", [{}])[0].get("message", {}).get("content", "") or "").strip()
+    try:
+        resp = requests.post(
+            DEEPINFRA_BASE_URL,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            data=json.dumps(payload),
+            timeout=REQUEST_TIMEOUT_SECS,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        return (data.get("choices", [{}])[0].get("message", {}).get("content", "") or "").strip()
+    except requests.exceptions.RequestException as e:
+        logging.error(f"API request failed: {e}")
+        raise gr.Error(f"API request failed: {e}. Check your API key and model name.")
 
 def quick_contacts(text: str) -> dict:
     email_re = re.compile(r"\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b")
@@ -166,17 +191,26 @@ def llm_extract_resume(resume_text: str, api_key: str, model: str, temperature:
     raw = deepinfra_chat(messages, api_key=api_key, model=model, temperature=temperature)
     return safe_json_loads(raw)
 
-def llm_feedback(jd_struct: Dict, resume_struct: Dict, api_key: str, model: str, temperature: float = 0.2) -> Dict:
+# New function for detailed feedback and scoring
+def llm_detailed_feedback(jd_struct: Dict, resume_struct: Dict, api_key: str, model: str, temperature: float = 0.2) -> Dict:
     prompt = json.dumps({"job": jd_struct, "candidate": resume_struct}, ensure_ascii=False)
     messages = [
-        {"role": "system", "content": FEEDBACK_SYSTEM},
+        {"role": "system", "content": FEEDBACK_SYSTEM_DETAILED},
         {"role": "user", "content": prompt},
     ]
     raw = deepinfra_chat(messages, api_key=api_key, model=model, temperature=temperature)
     return safe_json_loads(raw)
 
+# New function for candidate recommendation summary
+def llm_recommend(jd_struct: Dict, resume_struct: Dict, api_key: str, model: str, temperature: float = 0.2) -> str:
+    prompt = json.dumps({"job": jd_struct, "candidate": resume_struct}, ensure_ascii=False)
+    messages = [
+        {"role": "system", "content": RECOMMEND_SYSTEM},
+        {"role": "user", "content": prompt},
+    ]
+    return deepinfra_chat(messages, api_key=api_key, model=model, temperature=temperature)
 
-def prompt_for_match(jd_struct: Dict[str, Any], cv_structs: List[Dict[str, Any]]) -> List[Dict[str, str]]:
+def prompt_for_match(jd_struct: Dict[str, Any], cv_structs: List[Dict[str, Any]], conditional_req: str) -> List[Dict[str, str]]:
     # compact candidates to reduce tokens
     compact_cands = []
     for c in cv_structs:
@@ -198,6 +232,7 @@ def prompt_for_match(jd_struct: Dict[str, Any], cv_structs: List[Dict[str, Any]]
         "- Nice-to-have skills and domain fit\n"
         "- Evidence quality in work history/education\n"
         "- Language/locale requirements if any\n"
+        "- **Conditional Requirement:** If provided, evaluate the candidate's fit against this requirement.\n"
         "IMPORTANT:\n"
         "- The 'candidate' MUST EXACTLY EQUAL the resume 'name' field provided.\n"
         "- No extra keys. No markdown."
@@ -206,14 +241,14 @@ def prompt_for_match(jd_struct: Dict[str, Any], cv_structs: List[Dict[str, Any]]
         "Role (parsed JSON):\n"
         f"{json.dumps(jd_struct, ensure_ascii=False)}\n\n"
         "Candidates (compact JSON):\n"
-        f"{json.dumps(compact_cands, ensure_ascii=False)}"
+        f"{json.dumps(compact_cands, ensure_ascii=False)}\n\n"
+        f"Conditional Requirement: {conditional_req}"
     )
     return [{"role": "system", "content": system}, {"role": "user", "content": user}]
 
 RANK_LINE_RE = re.compile(r"^\s*(\d+)\.\s*(.*?)\s*[—\-]\s*([0-9]+(?:\.[0-9]+)?)\s*/\s*10\b", re.M)
 
 def parse_ranked_output(content: str) -> List[Dict[str, Any]]:
-    # Prefer strict JSON; fallback to "1. Name — 8.0/10" lines.
     rows: List[Dict[str, Any]] = []
     parsed = safe_json_loads(content or "")
 
@@ -251,9 +286,10 @@ def process(
     model_name,
     temperature,
     top_n,
-    w_skill,   # kept for UI compatibility (unused here)
-    w_qual,    # kept for UI compatibility (unused here)
-    w_resp,    # kept for UI compatibility (unused here)
+    w_skill,      # kept for UI compatibility (unused here)
+    w_qual,       # kept for UI compatibility (unused here)
+    w_resp,       # kept for UI compatibility (unused here)
+    conditional_req # new input for conditional requirement
 ):
     t0 = time.perf_counter()
 
@@ -270,6 +306,7 @@ def process(
         raise gr.Error("Please paste a Job Description or upload a JD file.")
     jd_struct = llm_extract_jd(jd_raw, api_key=api_key, model=model_name)
     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:
@@ -287,22 +324,30 @@ def process(
         if not isinstance(cand_struct, dict):
             cand_struct = {}
         cand_struct.setdefault("name", os.path.splitext(fname)[0])
-        cand_struct.setdefault("skills", [])
-        cand_struct.setdefault("skills_en", [])
-        cand_struct.setdefault("education", [])
-        cand_struct.setdefault("experience", [])
-        cand_struct.setdefault("languages", [])
         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', [])
+        
         parsed_cands.append(cand_struct)
         name_to_file[cand_struct["name"]] = fname
         t_parse_total += (time.perf_counter() - t_parse_s)
+    
+    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")
 
     t_match_start = time.perf_counter()
-    match_msgs = prompt_for_match(jd_struct, parsed_cands)
+    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)
     ranked_rows = parse_ranked_output(raw_match)
     t_match_total = time.perf_counter() - t_match_start
+    logging.info(f"Matching time: {t_match_total:.2f}s")
 
     score_map = {r["candidate"]: (float(r.get("score", 0.0)), r.get("justification","")) for r in ranked_rows}
 
@@ -310,10 +355,22 @@ def process(
 
     for c in parsed_cands:
         nm = c.get("name","")
-        sc, just = score_map.get(nm, (0.0, ""))  # if LLM didn't return this name, default 0
+        sc, just = score_map.get(nm, (0.0, ""))
+        
+        # Get detailed scores
+        detailed_scores = c.get('detailed_scores', {})
+        skills_sc = detailed_scores.get('skills', 0)
+        qual_sc = detailed_scores.get('qualifications', 0)
+        resp_sc = detailed_scores.get('responsibilities', 0)
+        exp_sc = detailed_scores.get('education_and_experience', 0)
+        
         table_rows.append({
             "Candidate": nm,
-            "Score": round(sc, 1),
+            "Score (0-10)": round(sc, 1),
+            "Skills (0-100)": skills_sc,
+            "Qualifications (0-100)": qual_sc,
+            "Responsibilities (0-100)": resp_sc,
+            "Experience (0-100)": exp_sc,
             "Email": c.get("email",""),
             "Phone": c.get("phone",""),
             "File": name_to_file.get(nm,""),
@@ -321,51 +378,56 @@ def process(
         export_rows.append({
             "candidate": nm,
             "Score": round(sc, 1),
+            "skills_score": skills_sc,
+            "qualifications_score": qual_sc,
+            "responsibilities_score": resp_sc,
+            "experience_score": exp_sc,
             "file": name_to_file.get(nm,""),
             "justification": just,
         })
+        
         detail_blobs.append((
             nm, sc,
             f"""### {nm} — {sc:.1f}/10
 **File:** {name_to_file.get(nm,'')}  
 **Email:** {c.get('email','')}  |  **Phone:** {c.get('phone','')}
 
-**Justification:** {just}
+**Overall Justification:** {just}
+**Detailed Feedback:** {c.get('summary_feedback', '')}
 """,
-            name_to_file.get(nm,"")
+            name_to_file.get(nm,""),
+            c.get('detailed_scores', {}),
+            c
         ))
 
     # sort by Score DESC
-    df = pd.DataFrame(table_rows).sort_values("Score", ascending=False, kind="mergesort")
+    df = pd.DataFrame(table_rows).sort_values("Score (0-10)", ascending=False, kind="mergesort")
     df_show = df.head(int(top_n)) if top_n and isinstance(top_n, (int, float)) else df
 
     # CSV export: rank, candidate, Score, file, justification
     sorted_items = sorted(export_rows, key=lambda r: float(r["Score"]), reverse=True)
     export_with_rank = []
     for i, r in enumerate(sorted_items, start=1):
-        export_with_rank.append({
-            "rank": i,
-            "candidate": r["candidate"],
-            "Score": r["Score"],
-            "file": r["file"],
-            "justification": r["justification"],
-        })
+        r["rank"] = i
+        export_with_rank.append(r)
+    
     csv_path = tempfile.NamedTemporaryFile(delete=False, suffix=".csv").name
-    pd.DataFrame(export_with_rank, columns=["rank", "candidate", "Score", "file", "justification"]) \
-        .to_csv(csv_path, index=False, encoding="utf-8")
+    pd.DataFrame(export_with_rank).to_csv(csv_path, index=False, encoding="utf-8")
 
-    # Candidate Details: top 5 only (based on score)
+    # Candidate Details & Recommendation: top 5 only (based on score)
     detail_blobs_sorted = sorted(detail_blobs, key=lambda t: t[1], reverse=True)
-    top5_md = "\n\n".join(md for (_n, _s, md, _f) in detail_blobs_sorted[:5])
-
+    top5_md = ""
+    for (_n, _s, md, _f, _scores, cand_struct) in detail_blobs_sorted[:5]:
+        recommendation = llm_recommend(jd_struct, cand_struct, api_key, model_name, temperature)
+        top5_md += f"{md}\n**Recommendation:** {recommendation}\n\n"
+        
     # metrics
     t_total = time.perf_counter() - t0
-    avg_parse = (t_parse_total / max(1, len(parsed_cands)))
     metrics_md = (
 f"""### Processing Metrics
 - JD parsing: {t_jd:.2f}s
-- Resume parsing (avg): {avg_parse:.2f}s
-- Matching (single LLM call): {t_match_total:.2f}s
+- Resume parsing & scoring (avg): {avg_parse:.2f}s
+- Ranking (single LLM call): {t_match_total:.2f}s
 - Total (all candidates): {t_total:.2f}s
 """)
 
@@ -381,7 +443,6 @@ f"""### Processing Metrics
     return metrics_md, df_show, csv_path, jd_pretty, top5_md
 
 
-
 with gr.Blocks(title="JD ↔ Resume Matcher") as demo:
     gr.Markdown("# 📌 JD ↔ Resume Matcher\nPaste a Job Description and upload resumes to rank candidates (Score 0–10), get Top-5 details, and download a CSV.")
 
@@ -399,11 +460,14 @@ with gr.Blocks(title="JD ↔ Resume Matcher") as demo:
                 model_name = gr.Textbox(label="Model", value=DEFAULT_MODEL)
                 temperature = gr.Slider(label="Model temperature", minimum=0.0, maximum=1.0, value=0.2, step=0.05)
                 top_n = gr.Slider(label="Show top N candidates (table)", minimum=1, maximum=50, value=10, step=1)
+                
+                # New input for conditional requirement
+                conditional_req = gr.Textbox(label="Conditional Requirement (e.g., must be in Cairo)", placeholder="e.g., 'Must be fluent in French'", lines=2)
 
                 # keep sliders (unused now) to avoid UI breaking changes
-                w_skill = gr.Slider(label="(unused) Weight: Skills overlap", minimum=0.0, maximum=1.0, value=0.6, step=0.05)
-                w_qual  = gr.Slider(label="(unused) Weight: Qualifications match", minimum=0.0, maximum=1.0, value=0.2, step=0.05)
-                w_resp  = gr.Slider(label="(unused) Weight: Responsibilities match", minimum=0.0, maximum=1.0, value=0.2, step=0.05)
+                w_skill = gr.Slider(label="(unused) Weight: Skills overlap", minimum=0.0, maximum=1.0, value=0.6, step=0.05, visible=False)
+                w_qual  = gr.Slider(label="(unused) Weight: Qualifications match", minimum=0.0, maximum=1.0, value=0.2, step=0.05, visible=False)
+                w_resp  = gr.Slider(label="(unused) Weight: Responsibilities match", minimum=0.0, maximum=1.0, value=0.2, step=0.05, visible=False)
 
             run_btn = gr.Button("🔎 Rank & Score", variant="primary")
             clear_btn = gr.Button("Clear")
@@ -415,12 +479,12 @@ with gr.Blocks(title="JD ↔ Resume Matcher") as demo:
             csv_out = gr.File(label="Download Ranked CSV")
             gr.Markdown("### 🧩 Parsed JD")
             jd_json = gr.JSON()
-            gr.Markdown("### 🗒️ Candidate Details (Top 5)")
+            gr.Markdown("### 🗒️ Candidate Details & Recommendation (Top 5)")
             details_md = gr.Markdown()
 
     run_btn.click(
         fn=process,
-        inputs=[jd_text, jd_file, resumes, api_key_pw, model_name, temperature, top_n, w_skill, w_qual, w_resp],
+        inputs=[jd_text, jd_file, resumes, api_key_pw, model_name, temperature, top_n, w_skill, w_qual, w_resp, conditional_req],
         outputs=[metrics_md, ranked_df, csv_out, jd_json, details_md]
     )
 
@@ -437,12 +501,13 @@ with gr.Blocks(title="JD ↔ Resume Matcher") as demo:
             None,          # csv_out
             {},            # jd_json
             "",            # details_md
+            ""             # conditional_req
         )
 
     clear_btn.click(
         fn=clear_all,
         inputs=[],
-        outputs=[jd_text, jd_file, resumes, api_key_pw, model_name, metrics_md, ranked_df, csv_out, jd_json, details_md]
+        outputs=[jd_text, jd_file, resumes, api_key_pw, model_name, metrics_md, ranked_df, csv_out, jd_json, details_md, conditional_req]
     )
 
 if __name__ == "__main__":