Spaces:
Running
Running
| # app.py | |
| import streamlit as st | |
| from streamlit_option_menu import option_menu | |
| from langchain_groq import ChatGroq | |
| from langchain_core.prompts import PromptTemplate | |
| import fitz # PyMuPDF | |
| import requests | |
| from bs4 import BeautifulSoup | |
| import uuid | |
| import plotly.express as px | |
| import re | |
| import pandas as pd | |
| import json | |
| # Initialize the LLM with your Groq API key from Streamlit secrets | |
| llm = ChatGroq( | |
| temperature=0, | |
| groq_api_key=st.secrets["groq_api_key"], | |
| model_name="llama-3.1-70b-versatile" | |
| ) | |
| def extract_text_from_pdf(pdf_file): | |
| """ | |
| Extracts text from an uploaded PDF file. | |
| """ | |
| text = "" | |
| try: | |
| with fitz.open(stream=pdf_file.read(), filetype="pdf") as doc: | |
| for page in doc: | |
| text += page.get_text() | |
| return text | |
| except Exception as e: | |
| st.error(f"Error extracting text from resume: {e}") | |
| return "" | |
| def extract_job_description(job_link): | |
| """ | |
| Fetches and extracts job description text from a given URL. | |
| """ | |
| try: | |
| headers = { | |
| "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" | |
| } | |
| response = requests.get(job_link, headers=headers) | |
| response.raise_for_status() | |
| soup = BeautifulSoup(response.text, 'html.parser') | |
| # Adjust selectors based on the website's structure for better extraction | |
| job_description = soup.get_text(separator='\n') | |
| return job_description.strip() | |
| except Exception as e: | |
| st.error(f"Error fetching job description: {e}") | |
| return "" | |
| def extract_requirements(job_description): | |
| """ | |
| Uses Groq to extract job requirements from the job description. | |
| """ | |
| prompt_text = f""" | |
| The following is a job description: | |
| {job_description} | |
| Extract the list of job requirements, qualifications, and skills from the job description. Provide them as a numbered list. | |
| Requirements: | |
| """ | |
| prompt = PromptTemplate.from_template(prompt_text) | |
| chain = prompt | llm | |
| response = chain.invoke({}) | |
| requirements = response.content.strip() | |
| return requirements | |
| def generate_email(job_description, requirements, resume_text): | |
| """ | |
| Generates a personalized cold email using Groq based on the job description, requirements, and resume. | |
| """ | |
| prompt_text = f""" | |
| You are Adithya S Nair, a recent Computer Science graduate specializing in Artificial Intelligence and Machine Learning. Craft a concise and professional cold email to a potential employer based on the following information: | |
| **Job Description:** | |
| {job_description} | |
| **Extracted Requirements:** | |
| {requirements} | |
| **Your Resume:** | |
| {resume_text} | |
| **Email Requirements:** | |
| - **Introduction:** Briefly introduce yourself and mention the specific job you are applying for. | |
| - **Body:** Highlight your relevant skills, projects, internships, and leadership experiences that align with the job requirements. | |
| - **Value Proposition:** Explain how your fresh perspective and recent academic knowledge can add value to the company. | |
| - **Closing:** Express enthusiasm for the opportunity, mention your willingness for an interview, and thank the recipient for their time. | |
| **Email:** | |
| """ | |
| prompt = PromptTemplate.from_template(prompt_text) | |
| chain = prompt | llm | |
| response = chain.invoke({}) | |
| email_text = response.content.strip() | |
| return email_text | |
| def generate_cover_letter(job_description, requirements, resume_text): | |
| """ | |
| Generates a personalized cover letter using Groq based on the job description, requirements, and resume. | |
| """ | |
| prompt_text = f""" | |
| You are Adithya S Nair, a recent Computer Science graduate specializing in Artificial Intelligence and Machine Learning. Compose a personalized and professional cover letter based on the following information: | |
| **Job Description:** | |
| {job_description} | |
| **Extracted Requirements:** | |
| {requirements} | |
| **Your Resume:** | |
| {resume_text} | |
| **Cover Letter Requirements:** | |
| 1. **Greeting:** Address the hiring manager by name if available; otherwise, use a generic greeting such as "Dear Hiring Manager." | |
| 2. **Introduction:** Begin with an engaging opening that mentions the specific position you are applying for and conveys your enthusiasm. | |
| 3. **Body:** | |
| - **Skills and Experiences:** Highlight relevant technical skills, projects, internships, and leadership roles that align with the job requirements. | |
| - **Alignment:** Demonstrate how your academic background and hands-on experiences make you a suitable candidate for the role. | |
| 4. **Value Proposition:** Explain how your fresh perspective, recent academic knowledge, and eagerness to learn can contribute to the company's success. | |
| 5. **Conclusion:** End with a strong closing statement expressing your interest in an interview, your availability, and gratitude for the hiring manager’s time and consideration. | |
| 6. **Professional Tone:** Maintain a respectful and professional tone throughout the letter. | |
| **Cover Letter:** | |
| """ | |
| prompt = PromptTemplate.from_template(prompt_text) | |
| chain = prompt | llm | |
| response = chain.invoke({}) | |
| cover_letter = response.content.strip() | |
| return cover_letter | |
| def extract_skills(text): | |
| """ | |
| Extracts a list of skills from the resume text using Groq. | |
| """ | |
| prompt_text = f""" | |
| Extract a comprehensive list of technical and soft skills from the following resume text. Provide the skills as a comma-separated list. | |
| Resume Text: | |
| {text} | |
| Skills: | |
| """ | |
| prompt = PromptTemplate.from_template(prompt_text) | |
| chain = prompt | llm | |
| response = chain.invoke({}) | |
| skills = response.content.strip() | |
| # Clean and split the skills | |
| skills_list = [skill.strip() for skill in re.split(',|\\n', skills) if skill.strip()] | |
| return skills_list | |
| def suggest_keywords(resume_text, job_description=None): | |
| """ | |
| Suggests additional relevant keywords to enhance resume compatibility with ATS. | |
| """ | |
| prompt_text = f""" | |
| Analyze the following resume text and suggest additional relevant keywords that can enhance its compatibility with Applicant Tracking Systems (ATS). If a job description is provided, tailor the keywords to align with the job requirements. | |
| Resume Text: | |
| {resume_text} | |
| Job Description: | |
| {job_description if job_description else "N/A"} | |
| Suggested Keywords: | |
| """ | |
| prompt = PromptTemplate.from_template(prompt_text) | |
| chain = prompt | llm | |
| response = chain.invoke({}) | |
| keywords = response.content.strip() | |
| keywords_list = [keyword.strip() for keyword in re.split(',|\\n', keywords) if keyword.strip()] | |
| return keywords_list | |
| def get_job_recommendations(resume_text, location="India"): | |
| """ | |
| Fetches job recommendations using the JSearch API based on the user's skills. | |
| """ | |
| # Extract skills from resume | |
| skills = extract_skills(resume_text) | |
| query = " ".join(skills) if skills else "Software Engineer" | |
| url = "https://jsearch.p.rapidapi.com/search" | |
| headers = { | |
| "X-RapidAPI-Key": st.secrets["rapidapi_key"], # Accessing RapidAPI key securely | |
| "X-RapidAPI-Host": "jsearch.p.rapidapi.com" | |
| } | |
| params = { | |
| "query": query, | |
| "page": "1", | |
| "num_pages": "1", | |
| "size": "20", | |
| "remote_filter": "false", | |
| "location": location, | |
| "sort": "relevance", | |
| "salary_min": "0", | |
| "salary_max": "0", | |
| "salary_currency": "INR", | |
| "radius": "0", | |
| "company_type": "", | |
| "job_type": "", | |
| "degree_level": "", | |
| "career_level": "", | |
| "include_remote": "false" | |
| } | |
| try: | |
| response = requests.get(url, headers=headers, params=params) | |
| response.raise_for_status() | |
| data = response.json() | |
| jobs = data.get("data", []) | |
| job_list = [] | |
| for job in jobs: | |
| job_info = { | |
| "title": job.get("job_title"), | |
| "company": job.get("employer", {}).get("name"), | |
| "link": job.get("job_apply_link") or job.get("job_listing_url") | |
| } | |
| job_list.append(job_info) | |
| return job_list | |
| except Exception as e: | |
| st.error(f"Error fetching job recommendations: {e}") | |
| return [] | |
| def create_skill_distribution_chart(skills): | |
| """ | |
| Creates a bar chart showing the distribution of skills. | |
| """ | |
| skill_counts = {} | |
| for skill in skills: | |
| skill_counts[skill] = skill_counts.get(skill, 0) + 1 | |
| df = pd.DataFrame(list(skill_counts.items()), columns=['Skill', 'Count']) | |
| fig = px.bar(df, x='Skill', y='Count', title='Skill Distribution') | |
| return fig | |
| def create_experience_timeline(resume_text): | |
| """ | |
| Creates an experience timeline from the resume text. | |
| """ | |
| # Extract work experience details using Groq | |
| prompt_text = f""" | |
| From the following resume text, extract the job titles, companies, and durations of employment. Provide the information in a table format with columns: Job Title, Company, Duration (in years). | |
| Resume Text: | |
| {resume_text} | |
| Table: | |
| """ | |
| prompt = PromptTemplate.from_template(prompt_text) | |
| chain = prompt | llm | |
| response = chain.invoke({}) | |
| table_text = response.content.strip() | |
| # Parse the table_text to create a DataFrame | |
| data = [] | |
| for line in table_text.split('\n'): | |
| if line.strip() and not line.lower().startswith("job title"): | |
| parts = line.split('|') | |
| if len(parts) == 3: | |
| job_title = parts[0].strip() | |
| company = parts[1].strip() | |
| duration = parts[2].strip() | |
| # Convert duration to a float representing years | |
| duration_years = parse_duration(duration) | |
| data.append({"Job Title": job_title, "Company": company, "Duration (years)": duration_years}) | |
| df = pd.DataFrame(data) | |
| if not df.empty: | |
| # Create a cumulative duration for timeline | |
| df['Start Year'] = df['Duration (years)'].cumsum() - df['Duration (years)'] | |
| df['End Year'] = df['Duration (years)'].cumsum() | |
| fig = px.timeline(df, x_start="Start Year", x_end="End Year", y="Job Title", color="Company", title="Experience Timeline") | |
| fig.update_yaxes(categoryorder="total ascending") | |
| return fig | |
| else: | |
| return None | |
| def parse_duration(duration_str): | |
| """ | |
| Parses duration strings like '2 years' or '6 months' into float years. | |
| """ | |
| try: | |
| if 'year' in duration_str.lower(): | |
| years = float(re.findall(r'\d+\.?\d*', duration_str)[0]) | |
| return years | |
| elif 'month' in duration_str.lower(): | |
| months = float(re.findall(r'\d+\.?\d*', duration_str)[0]) | |
| return months / 12 | |
| else: | |
| return 0 | |
| except: | |
| return 0 | |
| # ------------------------------- | |
| # Page Functions | |
| # ------------------------------- | |
| def email_generator_page(): | |
| st.header("Automated Email Generator") | |
| st.write(""" | |
| This application generates a personalized cold email based on a job posting and your resume. | |
| """) | |
| # Input fields | |
| job_link = st.text_input("Enter the job link:") | |
| uploaded_file = st.file_uploader("Upload your resume (PDF format):", type="pdf") | |
| if st.button("Generate Email"): | |
| if not job_link: | |
| st.error("Please enter a job link.") | |
| return | |
| if not uploaded_file: | |
| st.error("Please upload your resume.") | |
| return | |
| with st.spinner("Processing..."): | |
| # Extract job description | |
| job_description = extract_job_description(job_link) | |
| if not job_description: | |
| st.error("Failed to extract job description.") | |
| return | |
| # Extract requirements | |
| requirements = extract_requirements(job_description) | |
| if not requirements: | |
| st.error("Failed to extract requirements.") | |
| return | |
| # Extract resume text | |
| resume_text = extract_text_from_pdf(uploaded_file) | |
| if not resume_text: | |
| st.error("Failed to extract text from resume.") | |
| return | |
| # Generate email | |
| email_text = generate_email(job_description, requirements, resume_text) | |
| if email_text: | |
| st.subheader("Generated Email:") | |
| st.write(email_text) | |
| # Provide download option | |
| st.download_button( | |
| label="Download Email", | |
| data=email_text, | |
| file_name="generated_email.txt", | |
| mime="text/plain" | |
| ) | |
| else: | |
| st.error("Failed to generate email.") | |
| def cover_letter_generator_page(): | |
| st.header("Automated Cover Letter Generator") | |
| st.write(""" | |
| This application generates a personalized cover letter based on a job posting and your resume. | |
| """) | |
| # Input fields | |
| job_link = st.text_input("Enter the job link:") | |
| uploaded_file = st.file_uploader("Upload your resume (PDF format):", type="pdf") | |
| if st.button("Generate Cover Letter"): | |
| if not job_link: | |
| st.error("Please enter a job link.") | |
| return | |
| if not uploaded_file: | |
| st.error("Please upload your resume.") | |
| return | |
| with st.spinner("Processing..."): | |
| # Extract job description | |
| job_description = extract_job_description(job_link) | |
| if not job_description: | |
| st.error("Failed to extract job description.") | |
| return | |
| # Extract requirements | |
| requirements = extract_requirements(job_description) | |
| if not requirements: | |
| st.error("Failed to extract requirements.") | |
| return | |
| # Extract resume text | |
| resume_text = extract_text_from_pdf(uploaded_file) | |
| if not resume_text: | |
| st.error("Failed to extract text from resume.") | |
| return | |
| # Generate cover letter | |
| cover_letter = generate_cover_letter(job_description, requirements, resume_text) | |
| if cover_letter: | |
| st.subheader("Generated Cover Letter:") | |
| st.write(cover_letter) | |
| # Provide download option | |
| st.download_button( | |
| label="Download Cover Letter", | |
| data=cover_letter, | |
| file_name="generated_cover_letter.txt", | |
| mime="text/plain" | |
| ) | |
| else: | |
| st.error("Failed to generate cover letter.") | |
| def resume_analysis_page(): | |
| import pandas as pd # Importing here to prevent unnecessary imports if not used | |
| st.header("Resume Analysis and Optimization") | |
| uploaded_file = st.file_uploader("Upload your resume (PDF format):", type="pdf") | |
| if uploaded_file: | |
| resume_text = extract_text_from_pdf(uploaded_file) | |
| if resume_text: | |
| st.success("Resume uploaded successfully!") | |
| # Perform analysis | |
| st.subheader("Extracted Information") | |
| # Extracted skills | |
| skills = extract_skills(resume_text) | |
| st.write("**Skills:**", ', '.join(skills)) | |
| # Extract keywords | |
| keywords = suggest_keywords(resume_text) | |
| st.write("**Suggested Keywords for ATS Optimization:**", ', '.join(keywords)) | |
| # Provide optimization suggestions | |
| st.subheader("Optimization Suggestions") | |
| st.write("- **Keyword Optimization:** Incorporate the suggested keywords to improve ATS compatibility.") | |
| st.write("- **Formatting:** Ensure consistent formatting for headings and bullet points to enhance readability.") | |
| st.write("- **Experience Details:** Provide specific achievements and quantify your accomplishments where possible.") | |
| # Visual Resume Analytics | |
| st.subheader("Visual Resume Analytics") | |
| # Skill Distribution Chart | |
| if skills: | |
| st.write("**Skill Distribution:**") | |
| fig_skills = create_skill_distribution_chart(skills) | |
| st.plotly_chart(fig_skills) | |
| # Experience Timeline (if applicable) | |
| fig_experience = create_experience_timeline(resume_text) | |
| if fig_experience: | |
| st.write("**Experience Timeline:**") | |
| st.plotly_chart(fig_experience) | |
| else: | |
| st.write("**Experience Timeline:** Not enough data to generate a timeline.") | |
| else: | |
| st.error("Failed to extract text from resume.") | |
| def job_recommendations_page(): | |
| st.header("Job Recommendations") | |
| uploaded_file = st.file_uploader("Upload your resume (PDF format):", type="pdf") | |
| if uploaded_file: | |
| resume_text = extract_text_from_pdf(uploaded_file) | |
| if resume_text: | |
| st.success("Resume uploaded successfully!") | |
| # Fetch job recommendations | |
| st.subheader("Recommended Jobs") | |
| jobs = get_job_recommendations(resume_text) | |
| if jobs: | |
| for job in jobs: | |
| st.write(f"**{job['title']}** at {job['company']}") | |
| st.markdown(f"[Apply Here]({job['link']})") | |
| else: | |
| st.write("No job recommendations found based on your skills.") | |
| else: | |
| st.error("Failed to extract text from resume.") | |
| def skill_matching_page(): | |
| st.header("Skill Matching and Gap Analysis") | |
| job_description_input = st.text_area("Paste the job description here:") | |
| uploaded_file = st.file_uploader("Upload your resume (PDF format):", type="pdf") | |
| if st.button("Analyze Skills"): | |
| if not job_description_input: | |
| st.error("Please paste the job description.") | |
| return | |
| if not uploaded_file: | |
| st.error("Please upload your resume.") | |
| return | |
| with st.spinner("Analyzing..."): | |
| # Extract resume text | |
| resume_text = extract_text_from_pdf(uploaded_file) | |
| if not resume_text: | |
| st.error("Failed to extract text from resume.") | |
| return | |
| # Extract skills | |
| resume_skills = extract_skills(resume_text) | |
| job_skills = extract_skills(job_description_input) | |
| # Find matches and gaps | |
| matching_skills = set(resume_skills).intersection(set(job_skills)) | |
| missing_skills = set(job_skills) - set(resume_skills) | |
| # Display results | |
| st.subheader("Matching Skills") | |
| st.write(', '.join(matching_skills) if matching_skills else "No matching skills found.") | |
| st.subheader("Missing Skills") | |
| st.write(', '.join(missing_skills) if missing_skills else "No missing skills.") | |
| # ------------------------------- | |
| # Main App with Sidebar Navigation | |
| # ------------------------------- | |
| def main(): | |
| st.set_page_config(page_title="Job Application Assistant", layout="wide") | |
| with st.sidebar: | |
| selected = option_menu( | |
| "Main Menu", | |
| ["Email Generator", "Cover Letter Generator", "Resume Analysis", "Job Recommendations", "Skill Matching"], | |
| icons=["envelope", "file-earmark-text", "file-person", "briefcase", "bar-chart"], | |
| menu_icon="cast", | |
| default_index=0, | |
| ) | |
| if selected == "Email Generator": | |
| email_generator_page() | |
| elif selected == "Cover Letter Generator": | |
| cover_letter_generator_page() | |
| elif selected == "Resume Analysis": | |
| resume_analysis_page() | |
| elif selected == "Job Recommendations": | |
| job_recommendations_page() | |
| elif selected == "Skill Matching": | |
| skill_matching_page() | |
| if __name__ == "__main__": | |
| main() | |