try:

# Extract job skills from job description

job_skills = [skill.strip().lower() for skill in job_desc.get("skills", "").split(",") if skill]

# Extract programming languages from resume text

resume_skills = [skill.lower() for skill in re.findall(r'\b(Python|Java|SQL|JavaScript|C\+\+|HTML|CSS|iOS|Swift)\b', resume_text, re.IGNORECASE)]

# Calculate skill overlap

common_skills = len(set(job_skills) & set(resume_skills))

# Compute base score based on skill match

score = (common_skills / len(job_skills)) * 80 if job_skills else 50

# Extract experience from resume

exp_match = re.search(r'(\d+\.?\d*|\b(?:one|two|three|four|five|six|seven|eight|nine|ten)\b)\s*(?:years?|yrs?|\+?\s*years?|\+?\s*yrs?)(?:\s*of\s*experience)?', resume_text, re.IGNORECASE)

if exp_match:

num_str = exp_match.group(1)

# Convert word numbers to integers

word_to_num = {"one": 1, "two": 2, "three": 3, "four": 4, "five": 5, "six": 6, "seven": 7, "eight": 8, "nine": 9, "ten": 10}

# Parse experience years

exp_years = float(word_to_num[num_str.lower()] if num_str.lower() in word_to_num else num_str)

# Add experience-based score

score += min(exp_years / job_desc.get("experience", 1), 1) * 20

# Return capped score

return round(min(score, 100), 2)

except Exception as e:

# Display error and return default score

st.error(f"Error simulating CATSOne ATS score: {str(e)}")

# Define supported programming languages

languages = ["Python", "Java", "SQL", "JavaScript", "C++", "HTML", "CSS", "iOS", "Swift"]

# Extract job skills

job_skills = [skill.strip().lower() for skill in job_desc.get("skills", "").split(",") if skill]

# Extract resume skills

resume_skills = [skill.lower() for skill in re.findall(r'\b(' + '|'.join(languages) + r')\b', resume_text, re.IGNORECASE)]

# Calculate depth of expertise (mentions per language)

depth_scores = {}

for skill in resume_skills:

depth_scores[skill] = depth_scores.get(skill, 0) + 1

# Calculate breadth score (number of languages)

breadth_score = len(set(resume_skills)) * 10

# Calculate relevance score (job-required skills)

relevance_score = sum(depth_scores.get(skill, 0) * 20 for skill in job_skills)

# Compute total expertise score (capped at 100)

total_score = min(relevance_score + breadth_score, 100)

return {

"language_expertise_score": round(total_score, 2),

"primary_language": max(depth_scores, key=depth_scores.get, default="None"),

"language_count": len(set(resume_skills))

try:

# Initialize PDF reader

pdf_reader = PyPDF2.PdfReader(file)

# Extract text from all pages

return "\n".join(page.extract_text() or "" for page in pdf_reader.pages)

except Exception as e:

# Display error and return empty string

st.error(f"Error reading PDF: {str(e)}")

try:

# Set user-agent to avoid blocking

headers = {'User-Agent': 'Mozilla/5.0'}

# Make HTTP request to LinkedIn URL

response = requests.get(linkedin_url, headers=headers, timeout=5)

if response.status_code == 200:

# Parse HTML content

soup = BeautifulSoup(response.text, 'html.parser')

# Find profile photo

img_tag = soup.find('img', {'class': 'profile-photo'})

# Return image source or placeholder

return img_tag['src'] if img_tag and img_tag.get('src') else "https://via.placeholder.com/150"

return "https://via.placeholder.com/150"

except Exception:

# Return placeholder on error

try:

# Extract GitHub username

username = github_url.rstrip('/').split('/')[-1]

# Fetch GitHub user data

response = requests.get(f"https://api.github.com/users/{username}")

if response.status_code == 200:

# Get avatar URL

avatar_url = response.json().get("avatar_url")

# Return avatar if valid

if avatar_url and avatar_url != "https://avatars.githubusercontent.com/u/0":

return avatar_url

# Fallback to LinkedIn

return fetch_linkedin_profile_picture(linkedin_url) if linkedin_url else "https://via.placeholder.com/150"

except Exception:

# Fallback to LinkedIn or placeholder

# Initialize candidate data dictionary

data = {

"name": "", "email": "", "phone": "", "skills": [],

"experience": 0, "location": "", "degree": "", "college": "",

"sentiment": 0.0, "tags": [], "ats_rejection_risk": "Low",

"github_url": "", "linkedin_url": "", "profile_picture": "",

"source": "Uploaded", "raw_resume": text, "catsone_ats_score": 0.0,

"language_expertise_score": 0.0, "primary_language": "None", "language_count": 0,

"match_score": 0.0, "missing_skills": ""

}

if text:

# Extract name (assume first line)

data["name"] = text.split('\n')[0].strip() or "Unknown"

# Extract email using regex

email_match = re.search(r'[\w\.-]+@[\w\.-]+', text)

if email_match:

data["email"] = email_match.group(0)

# Extract phone number using regex

phone_match = re.search(r'(\+?\d[\d -]{7,}\d)', text)

if phone_match:

data["phone"] = phone_match.group(1)

# Extract GitHub URL

github_match = re.search(r'(?:https?://)?(?:www\.)?github\.com/([a-zA-Z0-9_-]+)(?:/)?', text, re.IGNORECASE)

if github_match:

data["github_url"] = f"https://github.com/{github_match.group(1)}"

# Extract LinkedIn URL

linkedin_match = re.search(r'(?:https?://)?(?:www\.)?linkedin\.com/in/([a-zA-Z0-9_-]+)(?:/)?', text, re.IGNORECASE)

if linkedin_match:

data["linkedin_url"] = f"https://linkedin.com/in/{linkedin_match.group(1)}"

# Fetch profile picture

data["profile_picture"] = fetch_github_profile_picture(data["github_url"], data["linkedin_url"])

# Define supported skills

skills = ["Python", "Java", "SQL", "JavaScript", "C++", "HTML", "CSS", "iOS", "Swift"]

# Extract skills from resume

data["skills"] = [skill for skill in skills if skill.lower() in text.lower()]

# Extract experience

exp_match = re.search(r'(\d+\.?\d*|\b(?:one|two|three|four|five|six|seven|eight|nine|ten)\b)\s*(?:years?|yrs?|\+?\s*years?|\+?\s*yrs?)(?:\s*of\s*experience)?', text, re.IGNORECASE)

if exp_match:

num_str = exp_match.group(1)

word_to_num = {"one": 1, "two": 2, "three": 3, "four": 4, "five": 5, "six": 6, "seven": 7, "eight": 8, "nine": 9, "ten": 10}

data["experience"] = float(word_to_num[num_str.lower()] if num_str.lower() in word_to_num else num_str)

# Extract location

location_match = re.search(r'(?:location|city|state)[\s:]*([\w\s,]+)', text, re.IGNORECASE)

if location_match:

data["location"] = location_match.group(1).strip()

# Extract degree

degree_match = re.search(r'(?:degree|education)[\s:]*([\w\s,]+)', text, re.IGNORECASE)

if degree_match:

data["degree"] = degree_match.group(1).strip()

# Extract college

college_match = re.search(r'(?:university|college)[\s:]*([\w\s,]+)', text, re.IGNORECASE)

if college_match:

data["college"] = college_match.group(1).strip()

# Calculate sentiment

blob = TextBlob(text)

data["sentiment"] = blob.sentiment.polarity

score = 0

# Extract job skills

job_skills = [skill.strip().lower() for skill in job_desc.get("skills", "").split(",") if skill]

# Extract resume skills

resume_skills = [skill.lower() for skill in resume_data["skills"]]

# Calculate skill overlap score

common_skills = len(set(job_skills) & set(resume_skills))

skill_score = (common_skills / len(job_skills)) * 30 if job_skills else 0

score += skill_score

# Calculate experience score

required_exp = job_desc.get("experience", 0)

exp_score = min(resume_data["experience"] / required_exp, 1) * 20 if required_exp else 0

score += exp_score

# Add degree match score

required_degree = job_desc.get("degree", "").lower()

if required_degree and required_degree in resume_data["degree"].lower():

score += 15

# Add location match score

required_location = job_desc.get("location", "").lower()

if required_location and required_location in resume_data["location"].lower():

score += 10

# Integrate CATSOne ATS score

catsone_score = get_catsone_ats_score(resume_data["raw_resume"], job_desc)

resume_data["catsone_ats_score"] = catsone_score

# Integrate language expertise score

lang_expertise = calculate_language_expertise(resume_data["raw_resume"], job_desc)

resume_data["language_expertise_score"] = lang_expertise["language_expertise_score"]

resume_data["primary_language"] = lang_expertise["primary_language"]

resume_data["language_count"] = lang_expertise["language_count"]

# Combine scores with weights

final_score = (score * 0.3) + (catsone_score * 0.3) + (resume_data["language_expertise_score"] * 0.4)

# Determine ATS rejection risk

if final_score < 60 or len(resume_data["skills"]) < 3 or resume_data["experience"] < 1:

resume_data["ats_rejection_risk"] = "High"

elif final_score < 80 or len(resume_data["skills"]) < 5 or resume_data["experience"] < 3:

resume_data["ats_rejection_risk"] = "Medium"

else:

resume_data["ats_rejection_risk"] = "Low"

questions = [

f"Tell me about your experience with {candidate_data['primary_language']}.",

f"How would you handle a challenging project requiring {random.choice(job_desc.get('skills', '').split(',')) if job_desc.get('skills') else 'unknown skill'}?",

f"What interests you most about working as a {job_desc.get('role', 'professional')}?",

"Can you describe a time when you solved a complex problem?",

f"How do you stay updated with the latest trends in {candidate_data['primary_language']}?"

]

feedback = [

"Your response was clear, but try to provide more specific examples.",

"Great answer! You demonstrated strong technical knowledge.",

"Consider slowing down your speech for better clarity."

]

# Initialize in-memory buffer

buffer = BytesIO()

# Create PDF document

doc = SimpleDocTemplate(buffer, pagesize=letter)

elements = []

# Get default styles

styles = getSampleStyleSheet()

# Add title

elements.append(Paragraph("HireIn AI: Shortlisted Candidates Report", styles['Title']))

# Add generation date

elements.append(Paragraph("Generated: June 2025", styles['Normal']))

# Add spacer

elements.append(Spacer(1, 12))

# Prepare table data

data = [["Name", "Email", "Experience", "Skills", "Match Score", "CATSOne ATS", "Lang Expertise"]]

for _, row in candidates_df.iterrows():

skills = ", ".join(row["skills"])

data.append([row["name"], row["email"], str(row["experience"]), skills,

f"{row['match_score']:.2f}", f"{row['catsone_ats_score']:.2f}",

f"{row['language_expertise_score']:.2f}"])

# Create table

table = Table(data)

# Style table

table.setStyle(TableStyle([

('BACKGROUND', (0, 0), (-1, 0), colors.HexColor("#1a1a38")),

('TEXTCOLOR', (0, 0), (-1, 0), colors.white),

('ALIGN', (0, 0), (-1, -1), 'CENTER'),

('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),

('FONTSIZE', (0, 0), (-1, -1), 12),

('BOTTOMPADDING', (0, 0), (-1, 0), 12),

('BACKGROUND', (0, 1), (-1, -1), colors.HexColor("#242450")),

('TEXTCOLOR', (0, 1), (-1, -1), colors.white),

('GRID', (0, 0), (-1, -1), 1, colors.white)

]))

elements.append(table)

# Build PDF

doc.build(elements)

buffer.seek(0)

buffer = BytesIO()

doc = SimpleDocTemplate(buffer, pagesize=letter)

elements = []

styles = getSampleStyleSheet()

elements.append(Paragraph("HireIn AI: Dashboard Summary Report", styles['Title']))

elements.append(Paragraph("Generated: June 2025", styles['Normal']))

elements.append(Spacer(1, 12))

elements.append(Paragraph("Key Metrics", styles['Heading2']))

metrics_data = [

["Total Candidates", str(len(candidates_df))],

["Average Experience", f"{candidates_df['experience'].mean():.1f} years"],

["Top Skills", ", ".join(skill_counts.head(3).index.tolist())],

["Degree Diversity", str(len(candidates_df["degree"].unique()))],

["Average CATSOne ATS Score", f"{candidates_df['catsone_ats_score'].mean():.1f}"],

["Average Language Expertise", f"{candidates_df['language_expertise_score'].mean():.1f}"]

]

metrics_table = Table(metrics_data)

metrics_table.setStyle(TableStyle([

('BACKGROUND', (0, 0), (-1, 0), colors.HexColor("#1a1a38")),

('TEXTCOLOR', (0, 0), (-1, 0), colors.white),

('ALIGN', (0, 0), (-1, -1), 'LEFT'),

('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),

('FONTSIZE', (0, 0), (-1, -1), 12),

('BOTTOMPADDING', (0, 0), (-1, 0), 12),

('BACKGROUND', (0, 1), (-1, -1), colors.HexColor("#242450")),

('TEXTCOLOR', (0, 1), (-1, -1), colors.white),

('GRID', (0, 0), (-1, -1), 1, colors.white)

]))

elements.append(metrics_table)

doc.build(elements)

buffer.seek(0)

try:

smtp_server = "smtp.gmail.com"

smtp_port = 587

server = smtplib.SMTP(smtp_server, smtp_port)

server.starttls()

server.login(sender_email, sender_password)

sent_count = 0

invalid_emails = []

for _, candidate in candidates_df[candidates_df["name"].isin(selected_candidates)].iterrows():

if not candidate["email"] or not re.match(r'[\w\.-]+@[\w\.-]+\.\w+', candidate["email"]):

invalid_emails.append(candidate["name"])

continue

msg = MIMEMultipart()

msg['From'] = sender_email

msg['To'] = candidate["email"]

msg['Subject'] = subject

personalized_body = body.replace("{name}", candidate["name"])

msg.attach(MIMEText(personalized_body, 'plain'))

server.send_message(msg)

sent_count += 1

server.quit()

return sent_count, invalid_emails

except Exception as e:

demo_data = [

{

"name": "Megha Panchal", "email": "[email protected]", "phone": "7354400695",

"skills": ["iOS", "Swift", "Java"], "experience": 1.5, "location": "Indore, India",

"degree": "MCA", "college": "Sage University", "sentiment": 0.2, "tags": [],

"ats_rejection_risk": "Medium", "github_url": "https://github.com/meghapanchal",

"linkedin_url": "https://linkedin.com/in/meghapanchal", "profile_picture": "https://via.placeholder.com/150",

"source": "Demo", "raw_resume": "Megha Panchal\niOS, Swift, Java, Java, Swift\n1.5 years experience\nMCA, Sage University\nIndore, India",

"catsone_ats_score": 75.0, "language_expertise_score": 80.0, "primary_language": "Swift", "language_count": 3

},

{

"name": "Akshay Baliyan", "email": "[email protected]", "phone": "7042270992",

"skills": ["Python", "Java", "JavaScript", "SQL", "C++"], "experience": 5.5, "location": "Noida, India",

"degree": "B.Tech", "college": "Raj Kumar Goel", "sentiment": 0.3, "tags": [],

"ats_rejection_risk": "Low", "github_url": "https://github.com/akshaybaliyan",

"linkedin_url": "https://linkedin.com/in/akshaybaliyan", "profile_picture": "https://via.placeholder.com/150",

"source": "Demo", "raw_resume": "Akshay Baliyan\nPython, Java, JavaScript, SQL, C++, Python, JavaScript\n5.5 years experience\nB.Tech, Raj Kumar Goel\nNoida, India",

"catsone_ats_score": 85.0, "language_expertise_score": 90.0, "primary_language": "Python", "language_count": 5

}

]

# Add navigation header to sidebar

st.sidebar.markdown("<h3 style='color: var(--primary-accent);'>Navigation</h3>", unsafe_allow_html=True)

# Create radio buttons for page navigation

page = st.sidebar.radio("Go to", ["Home", "Upload Resumes", "Shortlist Candidates", "AI Interviews", "Compare Candidates", "Dashboard", "Settings"])

if page == "Home":

# Display app title

st.title("HireIn: Smart Recruitment")

# Display updated subtitle in a styled card

st.markdown("""

""", unsafe_allow_html=True)

# Display promotional image

st.image("https://cdn.discordapp.com/attachments/1378528418748174427/1383758038019604510/sadasd-removebg-preview.png?ex=684ff499&is=684ea319&hm=07f0457937295c5e6928eeb50d4da62513a74f195ed8051e8e2213234c87815d&", caption="Streamline Your Hiring Process")

# Add demo mode button

if st.button("🚀 Try Demo Mode"):

# Load demo data

st.session_state["candidates"] = load_demo_data()

st.session_state["ranked"] = False

st.success("Demo data loaded! Navigate to other tabs to explore.")

elif page == "Upload Resumes":

# Display page header

st.header("Upload Resumes")

# Show spinner during file processing

with st.spinner("Processing resumes..."):

# Allow multiple PDF uploads

uploaded_files = st.file_uploader("Upload resumes (PDF)", accept_multiple_files=True, type=["pdf"], help="Upload candidate resumes in PDF format (max 200MB each).")

# Display email fetching placeholder

st.subheader("Fetch Resumes from Email")

st.warning("🚧 Email fetching is under development. Use the file uploader to add resumes.")

if st.button("Fetch from Email"):

st.info("Simulated: Fetched 5 resumes. Use the file uploader for now.")

if uploaded_files:

# Button to analyze resumes

if st.button("Analyze Resumes"):

# Show spinner during analysis

with st.spinner("Analyzing resumes..."):

results = []

# Get job description from session state

job_desc = st.session_state.get("job_desc", {"skills": "Python, JavaScript", "experience": 3.0})

for file in uploaded_files:

try:

# Extract text from PDF

text = extract_text_from_pdf(file)

if text:

# Parse resume data

data = parse_resume(text)

data["filename"] = file.name

# Calculate match score

data["match_score"] = calculate_match_score(data, job_desc)

# Identify missing skills

data["missing_skills"] = ", ".join(skill_gap_analysis(data, job_desc))

results.append(data)

else:

st.error(f"No text extracted from {file.name}")

except Exception as e:

st.error(f"Error processing {file.name}: {str(e)}")

if results:

# Create DataFrame from results

candidates_df = pd.DataFrame(results)

# Store candidates in session state

st.session_state["candidates"] = candidates_df

st.session_state["ranked"] = False

# Display candidates

st.dataframe(st.session_state["candidates"])

# Offer CSV download

csv = st.session_state["candidates"].to_csv(index=False).encode('utf-8')

st.download_button(

"Download Parsed Data",

csv,

"parsed_resume_data.csv",

"text/csv"

)

elif page == "Shortlist Candidates":

# Display page header

st.header("Shortlist Candidates")

# Check if candidates exist

if "candidates" not in st.session_state or st.session_state["candidates"].empty:

st.warning("Please upload and analyze resumes first or use Demo Mode.")

else:

# Display job description input

st.subheader("Job Description")

with st.container():

job_desc = {

"role": st.text_input("Job Role", "iOS Developer", help="Enter the role you're hiring for."),

"skills": st.text_input("Required Skills (comma-separated)", "iOS, Swift, Java", help="List required skills, e.g., Python, Java."),

"experience": st.number_input("Minimum Experience (years)", 0.0, 20.0, 5.0, help="Set the minimum years of experience required."),

"degree": st.text_input("Required Degree", "B.Tech", help="Specify the required degree, e.g., B.Tech, MCA."),

"location": st.text_input("Preferred Location", "India", help="Enter the preferred location for the role.")

}

# Get number of candidates

num_candidates = len(st.session_state["candidates"])

default_top_candidates = min(3, num_candidates)

# Input for top candidates to display

num_top_candidates = st.number_input(

"Number of Top Candidates to Display",

min_value=1,

max_value=num_candidates,

value=default_top_candidates,

step=1

)

# Button to rank candidates

if st.button("Match and Rank Candidates"):

# Show spinner during ranking

with st.spinner("Ranking candidates..."):

candidates_df = st.session_state["candidates"].copy()

# Calculate match scores

candidates_df["match_score"] = candidates_df.apply(

lambda row: calculate_match_score(row.to_dict(), job_desc), axis=1

)

# Identify missing skills

candidates_df["missing_skills"] = candidates_df.apply(

lambda row: ", ".join(skill_gap_analysis(row.to_dict(), job_desc)), axis=1

)

# Sort candidates by match score

candidates_df = candidates_df.sort_values(by="match_score", ascending=False)

# Store shortlisted candidates

st.session_state["shortlisted"] = candidates_df

st.session_state["ranked"] = True

st.session_state["job_desc"] = job_desc

# Display top candidates

st.subheader(f"Top {num_top_candidates} Candidates")

cols = st.columns(min(num_top_candidates, 3))

for idx, (_, candidate) in enumerate(candidates_df.head(num_top_candidates).iterrows()):

with cols[idx % 3]:

# Define badge classes

badge_class = {"Low": "badge-low", "Medium": "badge-medium", "High": "badge-high"}

# Create GitHub link

github_link = f"<a href='{candidate['github_url']}' target='_blank'>GitHub</a>" if candidate['github_url'] else "No GitHub"

# Create LinkedIn link

linkedin_link = f"<a href='{candidate['linkedin_url']}' target='_blank'>LinkedIn</a>" if candidate['linkedin_url'] else "No LinkedIn"

# Handle phone info

phone_info = candidate['phone'] if candidate['phone'] else "No Phone"

# Display candidate card

st.markdown(f"""

""", unsafe_allow_html=True)

# Display insights if ranked

if st.session_state.get("ranked", False):

st.subheader("Candidate Match Insights")

missing_skills = [skill for row in st.session_state["shortlisted"]["missing_skills"] for skill in row.split(", ") if row]

if missing_skills:

st.markdown(f"**Common Skill Gaps**: {', '.join(set(missing_skills))}")

else:

st.markdown("**All required skills covered by candidates!**")

# Display bulk actions

st.subheader("Bulk Actions")

with st.form(key="bulk_action_form"):

# Select candidates

selected_candidates = st.multiselect("Select Candidates for Bulk Actions", st.session_state["shortlisted"]["name"])

# Select action

bulk_action = st.selectbox("Action", ["Tag Candidates", "Send Bulk Email"])

if bulk_action == "Tag Candidates":

# Select tag

tag = st.selectbox("Tag", ["Shortlisted", "Interviewed", "Rejected"])

elif bulk_action == "Send Bulk Email":

# Input email credentials

sender_email = st.text_input("Sender Email", value=os.getenv("SMTP_SENDER_EMAIL", ""))

sender_password = st.text_input("Sender App Password", type="password", value=os.getenv("SMTP_SENDER_PASSWORD", ""))

# Input email content

email_subject = st.text_input("Email Subject", "Interview Invitation from HireIn AI")

email_body = st.text_area("Email Body", "Dear {name},\n\nWe are pleased to invite you for an interview for the {role} position. Please reply to schedule a convenient time.\n\nBest regards,\nHireIn AI Team")

# Replace role placeholder

job_role = st.session_state.get("job_desc", {}).get("role", "Unknown Role")

email_body = email_body.replace("{role}", job_role)

# Submit action

submit_button = st.form_submit_button("Apply Action")

if submit_button:

candidates_df = st.session_state["shortlisted"].copy()

if not selected_candidates:

st.warning("Please select at least one candidate.")

elif bulk_action == "Tag Candidates":

# Apply tag

candidates_df.loc[candidates_df["name"].isin(selected_candidates), "tags"] = candidates_df.loc[candidates_df["name"].isin(selected_candidates), "tags"].apply(lambda x: list(set(x + [tag])))

st.session_state["shortlisted"] = candidates_df

st.success(f"Tagged {len(selected_candidates)} candidates as {tag}.")

elif bulk_action == "Send Bulk Email":

# Validate credentials

if not sender_email or not sender_password:

st.error("Please provide sender email and app password.")

else:

# Send emails

with st.spinner("Sending emails..."):

sent_count, errors = send_bulk_email(

sender_email, sender_password, email_subject, email_body,

candidates_df, selected_candidates

)

if sent_count > 0:

st.success(f"Sent emails to {sent_count} candidates.")

if errors:

st.error(f"Failed to send to: {', '.join(errors)}")

# Display shortlisted candidates

st.dataframe(st.session_state["shortlisted"])

# Offer CSV download

csv = st.session_state["shortlisted"].to_csv(index=False).encode('utf-8')

st.download_button(

"Download Shortlisted Candidates",

csv,

"shortlisted_candidates.csv",

"text/csv"

)

# Offer PDF report

st.subheader("Generate PDF Report")

if st.button("Download PDF Report"):

with st.spinner("Generating PDF report..."):

pdf_buffer = generate_pdf_report(st.session_state["shortlisted"].head(num_top_candidates))

st.download_button(

"Download PDF",

pdf_buffer,

"shortlisted_candidates_report.pdf",

"application/pdf"

)

elif page == "AI Interviews":

# Display page header

st.header("AI-Driven Mock Interviews")

# Check if shortlisted candidates exist

if "shortlisted" not in st.session_state:

st.warning("Please shortlist candidates first.")

else:

# Note about demo mode

st.markdown("<p style='color: #a0a0c0;'>These are pre-generated questions for demonstration. Actual AI interviews take ~10 minutes.</p>", unsafe_allow_html=True)

# Select candidate

candidate = st.selectbox("Select Candidate for Interview", st.session_state["shortlisted"]["name"])

# Button to generate questions

if st.button("Generate Interview Questions"):

# Show spinner

with st.spinner("Generating questions..."):

# Get candidate data

candidate_data = st.session_state["shortlisted"][

st.session_state["shortlisted"]["name"] == candidate

].iloc[0]

# Get job description

job_desc = st.session_state.get("job_desc", {

"role": "iOS Developer",

"skills": "iOS, Swift, Java",

"experience": 5.0,

"degree": "B.Tech",

"location": "India"

})

# Generate questions

questions = generate_interview_questions(job_desc, candidate_data)

st.session_state["interview_questions"] = questions

st.session_state["interview_candidate"] = candidate

# Display questions

st.subheader("Interview Questions")

feedback_data = []

for i, q in enumerate(questions, 1):

st.write(f"**Question {i}**: {q}")

# Get candidate answer

answer = st.text_area(f"Your Answer {i}", key=f"answer_{i}")

if answer:

# Generate feedback

feedback = simulate_interview_feedback()

st.write(f"**Feedback**: {feedback}")

feedback_data.append({"Question": q, "Answer": answer, "Feedback": feedback})

if feedback_data:

# Offer feedback download

feedback_df = pd.DataFrame(feedback_data)

st.subheader("Export Interview Feedback")

csv = feedback_df.to_csv(index=False).encode('utf-8')

st.download_button(

"Download Feedback as CSV",

csv,

f"{candidate}_interview_feedback.csv",

"text/csv"

)

elif page == "Compare Candidates":

# Display page header

st.header("Compare Top Candidates")

# Check if shortlisted candidates exist

if "shortlisted" not in st.session_state:

st.warning("Please shortlist candidates first.")

else:

# Input number of candidates to compare

num_top_candidates = st.number_input("Number of Top Candidates to Compare", min_value=2, max_value=len(st.session_state["shortlisted"]), value=3, step=1)

# Get top candidates

top_candidates = st.session_state["shortlisted"].head(num_top_candidates)

if len(top_candidates) < 2:

st.warning("Need at least 2 candidates to compare.")

else:

# Display candidates in columns

cols = st.columns(min(num_top_candidates, 3))

for idx, (_, candidate) in enumerate(top_candidates.iterrows()):

with cols[idx % 3]:

badge_class = {"Low": "badge-low", "Medium": "badge-medium", "High": "badge-high"}

github_link = f"<a href=\"{candidate['github_url']}\" target=\"_blank\">GitHub</a>" if candidate['github_url'] else "No GitHub"

linkedin_link = f"<a href=\"{candidate['linkedin_url']}\" target=\"_blank\">LinkedIn</a>" if candidate['linkedin_url'] else "No LinkedIn"

phone_info = candidate['phone'] if candidate['phone'] else "No Phone"

# Display candidate card

st.markdown(f"""

""", unsafe_allow_html=True)

elif page == "Dashboard":

# Display page header

st.header("Candidate Insights Dashboard")

# Check if shortlisted candidates exist

if "shortlisted" not in st.session_state or st.session_state["shortlisted"].empty:

st.warning("Please shortlist candidates first.")

else:

candidates_df = st.session_state["shortlisted"].copy()

# Display filters

st.subheader("Filter Candidates")

with st.container():

col1, col2, col3, col4, col5 = st.columns(5)

with col1:

exp_filter = st.slider("Experience Range (years)", 0.0, 20.0, (0.0, 20.0), step=0.5)

with col2:

all_skills = sorted(set([skill for skills in candidates_df["skills"] for skill in skills]))

skill_filter = st.multiselect("Select Skills", all_skills, default=[])

with col3:

all_locations = sorted(candidates_df["location"].unique())

location_filter = st.multiselect("Select Locations", all_locations, default=[])

with col4:

ats_score_filter = st.slider("CATSOne ATS Score Range", 0.0, 100.0, (0.0, 100.0), step=1.0)

with col5:

lang_score_filter = st.slider("Language Expertise Score", 0.0, 100.0, (0.0, 100.0), step=1.0)

# Apply filters

filtered_df = candidates_df[

(candidates_df["experience"].between(exp_filter[0], exp_filter[1])) &

(candidates_df["skills"].apply(lambda x: all(skill in x for skill in skill_filter)) if skill_filter else True) &

(candidates_df["location"].isin(location_filter) if location_filter else True) &

(candidates_df["catsone_ats_score"].between(ats_score_filter[0], ats_score_filter[1])) &

(candidates_df["language_expertise_score"].between(lang_score_filter[0], lang_score_filter[1]))

]

if filtered_df.empty:

st.warning("No candidates match the selected filters.")

else:

# Display enhanced recruitment summary

st.subheader("📊 Recruitment Summary")

total_candidates = len(filtered_df)

avg_experience = filtered_df["experience"].mean()

top_skills = pd.Series([skill for skills in filtered_df["skills"] for skill in skills]).value_counts().head(3).index.tolist()

degree_diversity = len(filtered_df["degree"].unique())

avg_catsone_score = filtered_df["catsone_ats_score"].mean()

avg_lang_score = filtered_df["language_expertise_score"].mean()

# Display metrics in a responsive layout

col1, col2, col3 = st.columns(3)

with col1:

st.markdown(f"""

""", unsafe_allow_html=True)

with col2:

st.markdown(f"""

""", unsafe_allow_html=True)

with col3:

st.markdown(f"""