Update app.py

app.py

@@ -1,160 +1,75 @@
 import os
 import json
-import re
 import requests
 import gradio as gr
-from pypdf import PdfReader
-from docx import Document
+from google import genai
+from google.genai import types
 
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 JSEARCH_API_KEY = os.getenv("JSEARCH_API_KEY")
-HF_TOKEN = os.getenv("HF_TOKEN")
 
-QWEN_MODEL = "Qwen/Qwen2.5-1.5B-Instruct"
+client = genai.Client(api_key=GEMINI_API_KEY)
 
 
-def extract_text(file):
+def extract_profile_with_gemini(file):
     if file is None:
-        return ""
+        return None, "No file uploaded."
 
-    path = file.name
+    uploaded_file = client.files.upload(file=file.name)
 
-    if path.lower().endswith(".pdf"):
-        reader = PdfReader(path)
-        text = ""
-        for page in reader.pages:
-            text += page.extract_text() or ""
-        return text
+    prompt = """
+You are an AI resume analysis assistant.
 
-    if path.lower().endswith(".docx"):
-        doc = Document(path)
-        return "\n".join([p.text for p in doc.paragraphs])
+Analyze this resume/CV from any career field.
 
-    if path.lower().endswith(".txt"):
-        with open(path, "r", encoding="utf-8", errors="ignore") as f:
-            return f.read()
+Extract:
+- candidate field or industry
+- education
+- work experience
+- technical skills
+- soft skills
+- certifications
+- suitable job titles
+- job search queries
 
-    return ""
+Return ONLY valid JSON in this exact structure:
 
-
-def call_qwen(prompt):
-    if not HF_TOKEN:
-        return None
-
-    api_url = f"https://api-inference.huggingface.co/models/{QWEN_MODEL}"
-
-    headers = {
-        "Authorization": f"Bearer {HF_TOKEN}",
-        "Content-Type": "application/json"
-    }
-
-    payload = {
-        "inputs": prompt,
-        "parameters": {
-            "max_new_tokens": 700,
-            "temperature": 0.2,
-            "return_full_text": False
-        }
-    }
-
-    response = requests.post(api_url, headers=headers, json=payload, timeout=60)
-
-    if response.status_code != 200:
-        print("Qwen Error:", response.text)
-        return None
-
-    data = response.json()
-
-    if isinstance(data, list) and len(data) > 0:
-        return data[0].get("generated_text", "")
-
-    return str(data)
-
-
-def extract_json(text):
-    if not text:
-        return None
-
-    try:
-        return json.loads(text)
-    except:
-        pass
-
-    match = re.search(r"\{[\s\S]*\}", text)
-
-    if match:
-        try:
-            return json.loads(match.group(0))
-        except:
-            return None
-
-    return None
-
-
-def analyze_cv_with_ai(cv_text):
-    prompt = f"""
-You are an AI career assistant.
-
-Analyze this CV and extract career information.
-
-Return valid JSON only. Do not add explanations.
-
-Use this exact format:
-{{
-  "profile_level": "Entry-level",
+{
+  "candidate_field": "",
+  "seniority_level": "",
+  "education": [],
+  "work_experience": [],
   "technical_skills": [],
   "soft_skills": [],
-  "suitable_roles": [],
-  "job_search_keywords": []
-}}
-
-CV:
-{cv_text[:6000]}
+  "certifications": [],
+  "suitable_job_titles": [],
+  "job_search_queries": []
+}
+
+Rules:
+- The resume can be from any field: IT, finance, accounting, HR, marketing, design, engineering, healthcare, admin, hospitality, etc.
+- Do not assume the candidate is in IT.
+- Generate realistic job titles based on the resume.
+- Generate 5 to 8 job_search_queries.
+- Each query should be short and useful for a real job search.
 """
 
-    result = call_qwen(prompt)
-    print("RAW QWEN RESPONSE:", result)
-
-    data = extract_json(result)
-
-    if not data:
-        data = {}
-
-    technical_skills = data.get("technical_skills", [])
-    suitable_roles = data.get("suitable_roles", [])
-    job_search_keywords = data.get("job_search_keywords", [])
-
-    fallback_keywords = []
-
-    fallback_text = cv_text.lower()
-
-    if "technical support" in fallback_text or "it support" in fallback_text:
-        fallback_keywords.append("IT Support")
-
-    if "linux" in fallback_text or "system administration" in fallback_text:
-        fallback_keywords.append("System Administrator")
-
-    if "sql" in fallback_text or "mysql" in fallback_text:
-        fallback_keywords.append("Database")
-
-    if "java" in fallback_text or "javascript" in fallback_text:
-        fallback_keywords.append("Junior Software Developer")
-
-    if "machine learning" in fallback_text or "nlp" in fallback_text:
-        fallback_keywords.append("Machine Learning Intern")
-
-    if not job_search_keywords:
-        job_search_keywords = suitable_roles or fallback_keywords
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=[uploaded_file, prompt],
+        config=types.GenerateContentConfig(
+            temperature=0.2,
+            response_mime_type="application/json"
+        )
+    )
 
-    return {
-        "profile_level": data.get("profile_level", "Entry-level"),
-        "technical_skills": technical_skills,
-        "soft_skills": data.get("soft_skills", []),
-        "suitable_roles": suitable_roles,
-        "job_search_keywords": job_search_keywords
-    }
+    try:
+        return json.loads(response.text), response.text
+    except:
+        return None, response.text
 
 
-def search_jobs(keyword, location):
+def search_jobs(query, location):
     if not JSEARCH_API_KEY:
         return []
 
@@ -162,11 +77,11 @@ def search_jobs(keyword, location):
         "X-API-Key": JSEARCH_API_KEY
     }
 
-    query = f"{keyword} jobs in {location}"
+    full_query = f"{query} jobs in {location}"
 
     response = requests.get(
         "https://api.openwebninja.com/jsearch/search-v2",
-        params={"query": query},
+        params={"query": full_query},
         headers=headers,
         timeout=30
     )
@@ -177,26 +92,17 @@ def search_jobs(keyword, location):
 
     data = response.json()
 
-    if "jobs" in data:
-        return data["jobs"]
-
-    if "data" in data:
-        return data["data"]
-
-    return []
+    return data.get("jobs", data.get("data", data.get("results", [])))
 
 
-def rank_job_with_ai(cv_summary, job):
-    title = job.get("title", "Unknown Job")
-    company = job.get("company_name", job.get("company", "Unknown Company"))
-    description = job.get("description", job.get("snippet", ""))
-
+def rank_job_with_gemini(profile, job):
     prompt = f"""
 You are an AI job matching assistant.
 
-Compare the candidate profile with this job.
+Compare this candidate profile with the job.
+
+Return ONLY valid JSON:
 
-Return JSON only:
 {{
   "match_score": 0,
   "reason": "",
@@ -205,108 +111,127 @@ Return JSON only:
 }}
 
 Candidate profile:
-{json.dumps(cv_summary)}
-
-Job title:
-{title}
-
-Company:
-{company}
+{json.dumps(profile)}
 
-Job description:
-{description[:3000]}
+Job:
+{json.dumps(job)[:5000]}
 """
 
-    result = call_qwen(prompt)
-    data = extract_json(result)
+    response = client.models.generate_content(
+        model="gemini-2.5-flash",
+        contents=prompt,
+        config=types.GenerateContentConfig(
+            temperature=0.2,
+            response_mime_type="application/json"
+        )
+    )
 
-    if not data:
+    try:
+        return json.loads(response.text)
+    except:
         return {
             "match_score": 0,
-            "reason": "Could not analyze this job.",
+            "reason": "Could not rank this job.",
             "matched_skills": [],
             "missing_skills": []
         }
 
-    return data
-
 
-def analyze_cv(file, location):
-    cv_text = extract_text(file)
+def analyze_resume(file, location):
+    profile, raw_response = extract_profile_with_gemini(file)
 
-    if not cv_text.strip():
-        return "Could not extract text from the CV."
+    if not profile:
+        return f"Could not analyze resume.\n\nRaw Gemini response:\n\n```text\n{raw_response}\n```"
 
-    cv_summary = analyze_cv_with_ai(cv_text)
+    queries = profile.get("job_search_queries", [])
 
-    technical_skills = cv_summary.get("technical_skills", [])
-    suitable_roles = cv_summary.get("suitable_roles", [])
-    keywords = cv_summary.get("job_search_keywords", [])
+    if not queries:
+        return "Gemini analyzed the resume but did not generate job search queries."
 
-    output = "# Debug Output\n\n"
+    output = "# CareerMatch AI Results\n\n"
 
-    output += "## Extracted CV Text Preview\n\n"
-    output += "```text\n"
-    output += cv_text[:1500]
-    output += "\n```\n\n"
+    output += "## Resume Analysis\n\n"
+    output += f"**Field:** {profile.get('candidate_field', 'Not detected')}\n\n"
+    output += f"**Seniority Level:** {profile.get('seniority_level', 'Not detected')}\n\n"
 
-    output += "## AI Parsed CV Summary\n\n"
-    output += "```json\n"
-    output += json.dumps(cv_summary, indent=2)
-    output += "\n```\n\n"
-
-    output += "## Skills Detected\n\n"
-    output += ", ".join(technical_skills) if technical_skills else "No technical skills detected"
+    output += "**Technical Skills:** "
+    output += ", ".join(profile.get("technical_skills", [])) or "Not detected"
     output += "\n\n"
 
-    output += "## Suitable Roles Detected\n\n"
-    output += ", ".join(suitable_roles) if suitable_roles else "No suitable roles detected"
+    output += "**Soft Skills:** "
+    output += ", ".join(profile.get("soft_skills", [])) or "Not detected"
     output += "\n\n"
 
-    output += "## Keywords Passed to JSearch\n\n"
-
-    search_terms = keywords or suitable_roles or technical_skills
-
-    if not search_terms:
-        output += "No keywords available for JSearch.\n\n"
-        return output
+    output += "**Suitable Job Titles:** "
+    output += ", ".join(profile.get("suitable_job_titles", [])) or "Not detected"
+    output += "\n\n"
 
-    output += ", ".join(search_terms)
+    output += "**Search Queries Used:** "
+    output += ", ".join(queries)
     output += "\n\n---\n\n"
 
     all_jobs = []
 
-    for keyword in search_terms[:5]:
-        output += f"Searching JSearch for: `{keyword} jobs in {location}`\n\n"
-        jobs = search_jobs(keyword, location)
-        output += f"Jobs found: {len(jobs)}\n\n"
+    for query in queries[:5]:
+        jobs = search_jobs(query, location)
         all_jobs.extend(jobs[:5])
 
     if not all_jobs:
-        output += "No real jobs found from JSearch."
-        return output
+        return output + "No jobs found from JSearch."
+
+    unique_jobs = []
+    seen = set()
+
+    for job in all_jobs:
+        title = job.get("title", "")
+        company = job.get("company_name", job.get("company", ""))
+        key = f"{title}-{company}"
+
+        if key not in seen:
+            seen.add(key)
+            unique_jobs.append(job)
+
+    ranked_jobs = []
+
+    for job in unique_jobs[:8]:
+        match = rank_job_with_gemini(profile, job)
+        ranked_jobs.append({
+            "job": job,
+            "match": match
+        })
+
+    ranked_jobs.sort(
+        key=lambda x: int(x["match"].get("match_score", 0)),
+        reverse=True
+    )
+
+    output += "## Real Job Matches\n\n"
 
-    output += "## Raw Jobs Found\n\n"
+    for item in ranked_jobs:
+        job = item["job"]
+        match = item["match"]
 
-    for job in all_jobs[:10]:
         title = job.get("title", "Unknown Job")
         company = job.get("company_name", job.get("company", "Unknown Company"))
         job_location = job.get("location", "Not specified")
         url = job.get("url", job.get("apply_link", "#"))
 
-        output += f"### {title}\n"
+        output += f"### {title} — {match.get('match_score', 0)}% Match\n\n"
         output += f"**Company:** {company}\n\n"
         output += f"**Location:** {job_location}\n\n"
+        output += f"**Why it matches:** {match.get('reason', 'Not provided')}\n\n"
+        output += f"**Matched Skills:** {', '.join(match.get('matched_skills', [])) or 'Not specified'}\n\n"
+        output += f"**Missing Skills:** {', '.join(match.get('missing_skills', [])) or 'None listed'}\n\n"
         output += f"[Apply Here]({url})\n\n---\n\n"
 
     return output
 
 
 demo = gr.Interface(
-    fn=analyze_cv,
+    fn=analyze_resume,
     inputs=[
         gr.File(
-            label="Upload your CV",
+            label="Upload Resume/CV",
             file_types=[".pdf", ".docx", ".txt"]
         ),
         gr.Textbox(
@@ -315,8 +240,8 @@ demo = gr.Interface(
         )
     ],
     outputs=gr.Markdown(label="Results"),
-    title="JobFit AI",
-    description="Upload your CV and get real job matches ranked using AI."
+    title="CareerMatch AI",
+    description="Upload any resume and get real job matches based on the candidate profile."
 )