Update app.py

app.py

@@ -1,20 +1,30 @@
+# 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 
+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='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',  # Replace with your Groq API key
+    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:
@@ -26,11 +36,17 @@ def extract_text_from_pdf(pdf_file):
         return ""
 
 def extract_job_description(job_link):
+    """
+    Fetches and extracts job description text from a given URL.
+    """
     try:
-        response = requests.get(job_link)
+        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')
-        # You might need to adjust the selectors based on the website's structure
+        # 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:
@@ -38,6 +54,9 @@ def extract_job_description(job_link):
         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:
 
@@ -56,22 +75,28 @@ def extract_requirements(job_description):
     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"""
-    Given the following job description:
-{job_description}
+    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:
 
-And the following extracted requirements:
-{requirements}
+    **Job Description:**
+    {job_description}
+
+    **Extracted Requirements:**
+    {requirements}
 
-And the following resume text:
-{resume_text}
+    **Your Resume:**
+    {resume_text}
 
-Write a cold email as Adithya S Nair, a recent graduate in Computer Science with a focus on Artificial Intelligence and Machine Learning. 
-Highlight your relevant skills and experiences from the resume, emphasizing how you, as a fresher, can bring value to the client’s company. 
-Mention key projects, internships, and any leadership experiences that align with the job description and requirements. 
-Ensure the email is concise and professional.
+    **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:
+    **Email:**
     """
 
     prompt = PromptTemplate.from_template(prompt_text)
@@ -81,6 +106,207 @@ Ensure the email is concise and professional.
     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
 # -------------------------------
@@ -89,7 +315,7 @@ def email_generator_page():
     st.header("Automated Email Generator")
 
     st.write("""
-    This application generates a personalized email based on a job posting and your resume.
+    This application generates a personalized cold email based on a job posting and your resume.
     """)
 
     # Input fields
@@ -128,10 +354,72 @@ def email_generator_page():
             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")
@@ -142,14 +430,33 @@ def resume_analysis_page():
             st.success("Resume uploaded successfully!")
             # Perform analysis
             st.subheader("Extracted Information")
-            # Example: Extracted skills
+            # 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:** Consider adding more industry-specific keywords relevant to your desired roles.")
+            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.")
 
@@ -165,27 +472,50 @@ def job_recommendations_page():
             # Fetch job recommendations
             st.subheader("Recommended Jobs")
             jobs = get_job_recommendations(resume_text)
-            for job in jobs:
-                st.write(f"**{job['title']}** at {job['company']}")
-                st.markdown(f"[Apply Here]({job['link']})")
+            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.")
 
-# Placeholder for job recommendations - Replace with actual implementation
-def get_job_recommendations(resume_text):
-    # Implement job fetching logic, possibly integrating with job APIs
-    # This is a placeholder example
-    return [
-        {"title": "Data Scientist", "company": "TechCorp", "link": "https://example.com/job1"},
-        {"title": "Machine Learning Engineer", "company": "InnovateX", "link": "https://example.com/job2"},
-    ]
+def skill_matching_page():
+    st.header("Skill Matching and Gap Analysis")
 
-def extract_skills(text):
-    # Implement advanced skill extraction logic
-    # For demonstration, using a predefined skill list
-    skills_list = ["Python", "Machine Learning", "Data Analysis", "SQL", "Communication", "Leadership"]
-    extracted_skills = [skill for skill in skills_list if skill.lower() in text.lower()]
-    return extracted_skills
+    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
@@ -197,18 +527,22 @@ def main():
     with st.sidebar:
         selected = option_menu(
             "Main Menu",
-            ["Email Generator", "Resume Analysis", "Job Recommendations"],
-            icons=["envelope", "file-person", "briefcase"],
+            ["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()