import gradio as gr
import os
import io
import re
from docx import Document
from PyPDF2 import PdfReader
import pandas as pd
import spacy
from collections import Counter
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
# --- SpaCy Model Loading ---
try:
nlp = spacy.load("en_core_web_lg")
print("SpaCy model loaded successfully.")
except Exception as e:
print(f"Error loading spaCy model: {e}. Please ensure 'en_core_web_lg' is correctly installed via requirements.txt.")
# --- Global Predefined Skills ---
predefined_skills_list = set([
"python", "tensorflow", "pytorch", "scikit-learn", "numpy", "pandas",
"docker", "kubernetes", "aws", "git", "sql", "java", "r", "tableau",
"jupyter", "vscode", "bert", "spacy", "nltk", "opencv", "cnns",
"mlops", "agile", "feature engineering", "model deployment",
"machine learning", "deep learning", "nlp", "computer vision",
"data analysis", "predictive modeling", "fraud detection",
"recommendation system", "sentiment analysis", "ab testing",
"xgboost", "spark", "hadoop", "azure", "gcp",
"ai", "artificial intelligence", "data science", "big data",
"software development", "web development", "mobile development",
"databases", "cloud computing", "networking", "cybersecurity",
"project management", "communication", "teamwork", "leadership",
"problem solving", "critical thinking", "creativity"
])
predefined_skills_list.update([
"machine learning engineer", "data scientist", "ai engineer", "deep learning engineer",
"senior machine learning engineer", "junior data scientist",
"data engineer", "software engineer", "full stack", "frontend", "backend"
])
# --- Text Extraction Functions ---
def extract_text_from_pdf(pdf_path):
try:
with open(pdf_path, 'rb') as file:
reader = PdfReader(file)
text = ""
for page in reader.pages:
text += page.extract_text() or ""
return text
except Exception as e:
print(f"Error reading PDF {pdf_path}: {e}")
return ""
def extract_text_from_docx(docx_path):
try:
document = Document(docx_path)
text = "\n".join([paragraph.text for paragraph in document.paragraphs])
return text
except Exception as e:
print(f"Error reading DOCX {docx_path}: {e}")
return ""
def get_file_content(file_obj):
if file_obj is None:
return ""
file_path = file_obj.name
if file_path.endswith('.pdf'):
return extract_text_from_pdf(file_path)
elif file_path.endswith('.docx'):
return extract_text_from_docx(file_path)
elif file_path.endswith('.txt'):
with open(file_path, 'r', encoding='utf-8') as f:
return f.read()
else:
return ""
# --- Text Preprocessing Functions ---
def preprocess_text(text):
if not isinstance(text, str): return ""
text = text.lower()
text = re.sub(r'\s+', ' ', text).strip()
doc = nlp(text)
processed_tokens = [token.lemma_ for token in doc if not token.is_stop and not token.is_punct and not token.is_space]
return " ".join(processed_tokens)
# --- Information Extraction ---
def extract_skills(text_doc, skill_keywords=None):
extracted_skills = []
if skill_keywords is None: skill_keywords = set()
doc_text = text_doc.text.lower()
for skill in skill_keywords:
if re.search(r'\b' + re.escape(skill) + r'\b', doc_text):
extracted_skills.append(skill)
entities = {}
for ent in text_doc.ents:
if ent.label_ == "ORG": entities.setdefault("organizations", []).append(ent.text)
elif ent.label_ == "GPE": entities.setdefault("locations", []).append(ent.text)
elif ent.label_ == "DATE": entities.setdefault("dates", []).append(ent.text)
elif ent.label_ == "PERSON": entities.setdefault("people", []).append(ent.text)
return list(set(extracted_skills)), entities
def extract_experience_and_education(text):
years_experience = 0
education_level = "Not Specified"
exp_matches = re.findall(r'(\d+)\s*(?:\+|plus)?\s*years?\s+of\s+experience|\d+\s*yrs?\s+exp', text.lower())
if exp_matches:
try:
years_experience = max([int(re.findall(r'\d+', m)[0]) for m in exp_matches if re.findall(r'\d+', m)])
except (ValueError, IndexError): pass
text_lower = text.lower()
if "phd" in text_lower or "doctorate" in text_lower: education_level = "Ph.D."
elif "master" in text_lower or "m.s." in text_lower or "msc" in text_lower: education_level = "Master's"
elif "bachelor" in text_lower or "b.s." in text_lower or "bsc" in text_lower: education_level = "Bachelor's"
elif "associate" in text_lower: education_level = "Associate's"
return years_experience, education_level
# --- Feature Engineering ---
def get_text_embeddings(text):
if not text: return np.zeros(nlp.vocab.vectors.shape[1])
doc = nlp(text)
if doc.has_vector: return doc.vector
else: return np.mean([token.vector for token in doc if token.has_vector], axis=0) if [token.vector for token in doc if token.has_vector] else np.zeros(nlp.vocab.vectors.shape[1])
def calculate_cosine_similarity(vec1, vec2):
if np.all(vec1 == 0) or np.all(vec2 == 0):
return 0.0
vec1 = vec1.reshape(1, -1)
vec2 = vec2.reshape(1, -1)
return cosine_similarity(vec1, vec2)[0][0]
# --- Main Processing Pipeline ---
def analyze_document(doc_text):
doc_spacy = nlp(doc_text)
cleaned_text = preprocess_text(doc_text)
extracted_skills, general_entities = extract_skills(doc_spacy, skill_keywords=predefined_skills_list)
years_exp, education_level = extract_experience_and_education(doc_text)
text_embedding = get_text_embeddings(cleaned_text)
return {
"raw_text": doc_text, "cleaned_text": cleaned_text, "spacy_doc": doc_spacy,
"extracted_skills": extracted_skills, "general_entities": general_entities,
"years_experience": years_exp, "education_level": education_level,
"text_embedding": text_embedding
}
# --- Matching and Scoring Logic ---
def calculate_match_scores(cv_data, jd_data):
results = {}
overall_similarity = calculate_cosine_similarity(cv_data["text_embedding"], jd_data["text_embedding"])
results["overall_match_score"] = round(overall_similarity * 100, 2)
cv_skills = set(cv_data["extracted_skills"])
jd_skills = set(jd_data["extracted_skills"])
matched_skills = list(cv_skills.intersection(jd_skills))
missing_skills = list(jd_skills.difference(cv_skills))
extra_skills_in_cv = list(cv_skills.difference(jd_skills))
results["matched_skills"] = matched_skills
results["missing_skills"] = missing_skills
results["extra_skills_in_cv"] = extra_skills_in_cv
if jd_skills: skill_match_percentage = len(matched_skills) / len(jd_skills) * 100
else: skill_match_percentage = 0.0
results["skill_match_percentage"] = round(skill_match_percentage, 2)
corpus = [cv_data["cleaned_text"], jd_data["cleaned_text"]]
tfidf_vectorizer = TfidfVectorizer(max_features=100)
tfidf_matrix = tfidf_vectorizer.fit_transform(corpus)
feature_names = tfidf_vectorizer.get_feature_names_out()
cv_tfidf_scores = {feature_names[i]: tfidf_matrix[0, i] for i in tfidf_matrix[0].nonzero()[1]}
jd_tfidf_scores = {feature_names[i]: tfidf_matrix[1, i] for i in tfidf_matrix[1].nonzero()[1]}
top_cv_keywords = sorted(cv_tfidf_scores.items(), key=lambda x: x[1], reverse=True)[:15]
top_jd_keywords = sorted(jd_tfidf_scores.items(), key=lambda x: x[1], reverse=True)[:15]
results["top_cv_keywords"] = [k for k,v in top_cv_keywords]
results["top_jd_keywords"] = [k for k,v in top_jd_keywords]
common_keywords = set(results["top_cv_keywords"]).intersection(set(results["top_jd_keywords"]))
results["common_keywords"] = list(common_keywords)
cv_exp_years = cv_data["years_experience"]
jd_exp_years = jd_data["years_experience"]
results["cv_years_experience"] = cv_exp_years
results["jd_years_experience"] = jd_exp_years
exp_status = "Not specified by Job"
if jd_exp_years > 0:
if cv_exp_years >= jd_exp_years: exp_status = "Meets or Exceeds Requirement"
else: exp_status = f"Below Requirement (Needs {jd_exp_years - cv_exp_years} more years)"
results["experience_match_status"] = exp_status
cv_edu = cv_data["education_level"]
jd_edu = jd_data["education_level"]
results["cv_education_level"] = cv_edu
results["jd_education_level"] = jd_edu
edu_match_status = "Not Specified by Job"
if jd_edu != "Not Specified":
edu_order = {"Associate's": 1, "Bachelor's": 2, "Master's": 3, "Ph.D.": 4}
if edu_order.get(cv_edu, 0) >= edu_order.get(jd_edu, 0): edu_match_status = "Meets or Exceeds Requirement"
else: edu_match_status = "Below Requirement"
results["education_match_status"] = edu_match_status
return results
# --- Overall Analysis Orchestrator ---
def perform_cv_job_analysis(cv_text, job_desc_text):
cv_analysis_data = analyze_document(cv_text)
job_desc_analysis_data = analyze_document(job_desc_text)
match_results = calculate_match_scores(cv_analysis_data, job_desc_analysis_data)
return match_results
# --- Visualization Functions ---
def create_overall_match_plot(score):
fig, ax = plt.subplots(figsize=(6, 2))
sns.set_style("whitegrid")
ax.barh(["Overall Match"], [score], color='skyblue')
ax.set_xlim(0, 100)
ax.text(score + 2, 0, f'{score}%', va='center', color='black', fontsize=12)
ax.set_title("Overall CV-Job Description Match Score", fontsize=14)
ax.set_xlabel("Match Percentage", fontsize=12)
ax.get_yaxis().set_visible(False)
plt.tight_layout()
return fig
def create_skill_match_plot(matched_skills, missing_skills):
labels = ['Matched Skills', 'Missing Skills']
sizes = [len(matched_skills), len(missing_skills)]
colors = ['#66b3ff', '#ff9999']
explode = (0.05, 0.05) if sizes[0] > 0 and sizes[1] > 0 else (0,0)
if sum(sizes) == 0: return None
fig, ax = plt.subplots(figsize=(7, 7))
ax.pie(sizes, explode=explode, labels=labels, colors=colors, autopct='%1.1f%%', shadow=True, startangle=90, textprops={'fontsize': 12})
ax.axis('equal')
ax.set_title("Skill Match Breakdown", fontsize=14)
plt.tight_layout()
return fig
def create_top_keywords_plot(cv_keywords, jd_keywords):
fig, axes = plt.subplots(1, 2, figsize=(16, 6))
sns.set_style("whitegrid")
cv_df = pd.DataFrame(Counter(cv_keywords).most_common(10), columns=['Keyword', 'Count'])
if not cv_df.empty:
sns.barplot(x='Count', y='Keyword', data=cv_df, ax=axes[0], palette='viridis')
axes[0].set_title('Top Keywords in CV', fontsize=14)
axes[0].set_xlabel('Frequency/Importance', fontsize=12)
axes[0].set_ylabel('')
jd_df = pd.DataFrame(Counter(jd_keywords).most_common(10), columns=['Keyword', 'Count'])
if not jd_df.empty:
sns.barplot(x='Count', y='Keyword', data=jd_df, ax=axes[1], palette='plasma')
axes[1].set_title('Top Keywords in Job Description', fontsize=14)
axes[1].set_xlabel('Frequency/Importance', fontsize=12)
axes[1].set_ylabel('')
plt.tight_layout()
return fig
# --- Main Gradio Interface Function ---
def analyze_cv_match(cv_file_obj, cv_text_input, jd_text_input):
cv_content = ""
if cv_file_obj is not None:
cv_content = get_file_content(cv_file_obj)
elif cv_text_input:
cv_content = cv_text_input
if not cv_content:
return (f"🚨 Error: Please upload a CV file or paste your CV text.
",
None, None, None, "Analysis Failed")
if not jd_text_input:
return (f"🚨 Error: Please paste the Job Description text.
",
None, None, None, "Analysis Failed")
try:
analysis_results = perform_cv_job_analysis(cv_content, jd_text_input)
matched_skills_str = ', '.join(analysis_results['matched_skills']) if analysis_results['matched_skills'] else 'None found matching job description.'
missing_skills_str = ', '.join(analysis_results['missing_skills']) if analysis_results['missing_skills'] else '🥳 None! Your CV has all specified skills.'
extra_skills_str = ', '.join(analysis_results['extra_skills_in_cv']) if analysis_results['extra_skills_in_cv'] else 'None. (This is often fine, showing broader capability.)'
common_keywords_str = ', '.join(analysis_results['common_keywords']) if analysis_results['common_keywords'] else 'No significant common keywords beyond skills.'
cv_keywords_str = ', '.join(analysis_results['top_cv_keywords']) if analysis_results['top_cv_keywords'] else 'N/A'
jd_keywords_str = ', '.join(analysis_results['top_jd_keywords']) if analysis_results['top_jd_keywords'] else 'N/A'
html_output = f"""
💡 Analysis Results Summary 💡
Overall Match Score
{analysis_results['overall_match_score']}%
Skill Match
{analysis_results['skill_match_percentage']}%
Experience Match
{analysis_results['experience_match_status']}
📝 Detailed Breakdown
Skills Analysis
✅ Matched Skills: {matched_skills_str}
❌ Missing Skills (from Job Description): {missing_skills_str}
💡 Extra Skills in CV (not in Job Description): {extra_skills_str}
Keyword Relevance (Top TF-IDF Terms)
🤝 Top Common Keywords: {common_keywords_str}
🔍 Top Keywords in Your CV: {cv_keywords_str}
🎯 Top Keywords in Job Description: {jd_keywords_str}
Experience & Education Comparison
👤 Your CV's Experience: {analysis_results['cv_years_experience']} years
💼 Job's Required Experience: {analysis_results['jd_years_experience']} years
Status: {analysis_results['experience_match_status']}
🎓 Your CV's Education: {analysis_results['cv_education_level']}
📚 Job's Required Education: {analysis_results['jd_education_level']}
Status: {analysis_results['education_match_status']}
"""
overall_plot = create_overall_match_plot(analysis_results['overall_match_score'])
skill_plot = create_skill_match_plot(analysis_results['matched_skills'], analysis_results['missing_skills'])
keywords_plot = create_top_keywords_plot(analysis_results['top_cv_keywords'], analysis_results['top_jd_keywords'])
return html_output, overall_plot, skill_plot, keywords_plot, "Analysis Complete!"
except Exception as e:
import traceback
error_traceback = traceback.format_exc()
return (f"An unexpected error occurred during analysis: {e}
"
f"Click for details
{error_traceback}