Update app.py

app.py

@@ -1,3 +1,5 @@
+# app.py
+
 import streamlit as st
 from streamlit_option_menu import option_menu
 from langchain_groq import ChatGroq
@@ -10,6 +12,9 @@ import plotly.express as px
 import re
 import pandas as pd
 import json
+import sqlite3
+import streamlit_authenticator as stauth
+from datetime import datetime, timedelta
 
 # Initialize the LLM with your Groq API key from Streamlit secrets
 llm = ChatGroq(
@@ -30,7 +35,7 @@ def extract_text_from_pdf(pdf_file):
                 text += page.get_text()
         return text
     except Exception as e:
-        st.error(f"Error extracting text from resume: {e}")
+        st.error(f"Error extracting text from PDF: {e}")
         return ""
 
 def extract_job_description(job_link):
@@ -159,7 +164,7 @@ def extract_skills(text):
 
     skills = response.content.strip()
     # Clean and split the skills
-    skills_list = [skill.strip() for skill in re.split(',|\\n', skills) if skill.strip()]
+    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):
@@ -183,7 +188,7 @@ def suggest_keywords(resume_text, job_description=None):
     response = chain.invoke({})
 
     keywords = response.content.strip()
-    keywords_list = [keyword.strip() for keyword in re.split(',|\\n', keywords) if keyword.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"):
@@ -211,7 +216,7 @@ def get_job_recommendations(resume_text, location="India"):
                 "title": job.get("title"),
                 "company": job.get("company_name"),
                 "link": job.get("url"),
-                "job_description": job.get("description") 
+                "job_description": job.get("description")  # Including job description for Skill Matching
             }
             job_list.append(job_info)
         return job_list
@@ -288,265 +293,393 @@ def parse_duration(duration_str):
     except:
         return 0
 
-# -------------------------------
-# Page Functions
-# -------------------------------
+def init_db():
+    """
+    Initializes the SQLite database for application tracking.
+    """
+    conn = sqlite3.connect('applications.db')
+    c = conn.cursor()
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS applications (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            job_title TEXT,
+            company TEXT,
+            application_date TEXT,
+            status TEXT,
+            deadline TEXT,
+            notes TEXT,
+            job_description TEXT,
+            resume_text TEXT,
+            skills TEXT
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def add_application(job_title, company, application_date, status, deadline, notes, job_description, resume_text, skills):
+    """
+    Adds a new application to the database.
+    """
+    conn = sqlite3.connect('applications.db')
+    c = conn.cursor()
+    c.execute('''
+        INSERT INTO applications (job_title, company, application_date, status, deadline, notes, job_description, resume_text, skills)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ''', (job_title, company, application_date, status, deadline, notes, job_description, resume_text, ', '.join(skills)))
+    conn.commit()
+    conn.close()
+
+def fetch_applications():
+    """
+    Fetches all applications from the database.
+    """
+    conn = sqlite3.connect('applications.db')
+    c = conn.cursor()
+    c.execute('SELECT * FROM applications')
+    data = c.fetchall()
+    conn.close()
+    applications = []
+    for app in data:
+        applications.append({
+            "ID": app[0],
+            "Job Title": app[1],
+            "Company": app[2],
+            "Application Date": app[3],
+            "Status": app[4],
+            "Deadline": app[5],
+            "Notes": app[6],
+            "Job Description": app[7],
+            "Resume Text": app[8],
+            "Skills": app[9].split(', ')
+        })
+    return applications
+
+def update_application_status(app_id, new_status):
+    """
+    Updates the status of an application.
+    """
+    conn = sqlite3.connect('applications.db')
+    c = conn.cursor()
+    c.execute('UPDATE applications SET status = ? WHERE id = ?', (new_status, app_id))
+    conn.commit()
+    conn.close()
+
+def delete_application(app_id):
+    """
+    Deletes an application from the database.
+    """
+    conn = sqlite3.connect('applications.db')
+    c = conn.cursor()
+    c.execute('DELETE FROM applications WHERE id = ?', (app_id,))
+    conn.commit()
+    conn.close()
 
-def email_generator_page():
-    st.header("Automated Email Generator")
+def generate_learning_path(career_goal, current_skills):
+    """
+    Generates a personalized learning path using Groq based on career goal and current skills.
+    """
+    prompt = f"""
+    Based on the following career goal and current skills, create a personalized learning path that includes recommended courses, projects, and milestones to achieve the career goal.
+
+    **Career Goal:**
+    {career_goal}
+
+    **Current Skills:**
+    {current_skills}
+
+    **Learning Path:**
+    """
+
+    response = llm.invoke({"input": prompt})
+    learning_path = response.content.strip()
+    return learning_path
+
+def setup_authentication():
+    """
+    Sets up user authentication using streamlit-authenticator.
+    """
+    # In a real application, retrieve user data from a secure database
+    names = ["Adithya S Nair"]  # Replace with dynamic user data
+    usernames = ["adithya"]
+    # Passwords should be hashed in a real application
+    passwords = ["$2b$12$KIXvUq2YdZ19FWJGzTqFUeAewH1/gO7xmD2z77Qvxh3A1F1C9KdaW"]  # "password" hashed
+
+    authenticator = stauth.Authenticate(names, usernames, passwords, "job_app_assistant", "abcdef", cookie_expiry_days=30)
+    return authenticator
+
+def application_tracking_dashboard():
+    st.header("Application Tracking Dashboard")
+
+    # Initialize database
+    init_db()
+
+    # Form to add a new application
+    st.subheader("Add New Application")
+    with st.form("add_application"):
+        job_title = st.text_input("Job Title")
+        company = st.text_input("Company")
+        application_date = st.date_input("Application Date", datetime.today())
+        status = st.selectbox("Status", ["Applied", "Interviewing", "Offered", "Rejected"])
+        deadline = st.date_input("Application Deadline", datetime.today() + timedelta(days=30))
+        notes = st.text_area("Notes")
+        uploaded_file = st.file_uploader("Upload Job Description (PDF)", type="pdf")
+        uploaded_resume = st.file_uploader("Upload Resume (PDF)", type="pdf")
+        submitted = st.form_submit_button("Add Application")
+        if submitted:
+            if uploaded_file:
+                job_description = extract_text_from_pdf(uploaded_file)
+            else:
+                job_description = ""
+            if uploaded_resume:
+                resume_text = extract_text_from_pdf(uploaded_resume)
+                skills = extract_skills(resume_text)
+            else:
+                resume_text = ""
+                skills = []
+            add_application(
+                job_title=job_title,
+                company=company,
+                application_date=application_date.strftime("%Y-%m-%d"),
+                status=status,
+                deadline=deadline.strftime("%Y-%m-%d"),
+                notes=notes,
+                job_description=job_description,
+                resume_text=resume_text,
+                skills=skills
+            )
+            st.success("Application added successfully!")
+
+    # Display applications
+    st.subheader("Your Applications")
+    applications = fetch_applications()
+    if applications:
+        df = pd.DataFrame(applications)
+        df = df.drop(columns=["Job Description", "Resume Text", "Skills"])
+        st.dataframe(df)
+
+        # Actions: Update Status or Delete
+        for app in applications:
+            with st.expander(f"{app['Job Title']} at {app['Company']}"):
+                st.write(f"**Application Date:** {app['Application Date']}")
+                st.write(f"**Deadline:** {app['Deadline']}")
+                st.write(f"**Status:** {app['Status']}")
+                st.write(f"**Notes:** {app['Notes']}")
+                if app['Job Description']:
+                    st.write("**Job Description:**")
+                    st.write(app['Job Description'][:500] + "...")
+                if app['Skills']:
+                    st.write("**Skills:**", ', '.join(app['Skills']))
+                # Update status
+                new_status = st.selectbox("Update Status:", ["Applied", "Interviewing", "Offered", "Rejected"], key=f"status_{app['ID']}")
+                if st.button("Update Status", key=f"update_{app['ID']}"):
+                    update_application_status(app['ID'], new_status)
+                    st.success("Status updated successfully!")
+                # Delete application
+                if st.button("Delete Application", key=f"delete_{app['ID']}"):
+                    delete_application(app['ID'])
+                    st.success("Application deleted successfully!")
+    else:
+        st.write("No applications found.")
+
+def interview_preparation_module():
+    st.header("Interview Preparation")
 
     st.write("""
-    This application generates a personalized cold email based on a job posting and your resume.
+    Prepare for your interviews with tailored mock questions and expert tips.
     """)
 
     # Input fields
-    job_link = st.text_input("Enter the job link:")
-    uploaded_file = st.file_uploader("Upload your resume (PDF format):", type="pdf")
+    job_title = st.text_input("Enter the job title you're applying for:")
+    company = st.text_input("Enter the company name:")
 
-    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.")
+    if st.button("Generate Mock Interview Questions"):
+        if not job_title or not company:
+            st.error("Please enter both job title and company name.")
             return
+        with st.spinner("Generating questions..."):
+            prompt = f"""
+            Generate a list of 10 interview questions for a {job_title} position at {company}. Include a mix of technical and behavioral questions.
+            """
+            questions = llm.invoke({"input": prompt}).content.strip()
+            st.subheader("Mock Interview Questions:")
+            st.write(questions)
+
+            # Optionally, provide sample answers or tips
+            if st.checkbox("Show Sample Answers"):
+                sample_prompt = f"""
+                Provide sample answers for the following interview questions for a {job_title} position at {company}.
+
+                Questions:
+                {questions}
+
+                Sample Answers:
+                """
+                sample_answers = llm.invoke({"input": sample_prompt}).content.strip()
+                st.subheader("Sample Answers:")
+                st.write(sample_answers)
+
+def personalized_learning_paths_module():
+    st.header("Personalized Learning Paths")
 
-        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.")
+    st.write("""
+    Receive tailored learning plans to help you acquire the skills needed for your desired career.
+    """)
+
+    # Input fields
+    career_goal = st.text_input("Enter your career goal (e.g., Data Scientist, Machine Learning Engineer):")
+    current_skills = st.text_input("Enter your current skills (comma-separated):")
 
-def cover_letter_generator_page():
-    st.header("Automated Cover Letter Generator")
+    if st.button("Generate Learning Path"):
+        if not career_goal or not current_skills:
+            st.error("Please enter both career goal and current skills.")
+            return
+        with st.spinner("Generating your personalized learning path..."):
+            learning_path = generate_learning_path(career_goal, current_skills)
+            st.subheader("Your Personalized Learning Path:")
+            st.write(learning_path)
+
+def networking_opportunities_module():
+    st.header("Networking Opportunities")
 
     st.write("""
-    This application generates a personalized cover letter based on a job posting and your resume.
+    Expand your professional network by connecting with relevant industry peers and joining professional groups.
     """)
 
-    # Input fields
-    job_link = st.text_input("Enter the job link:")
-    uploaded_file = st.file_uploader("Upload your resume (PDF format):", type="pdf")
+    user_skills = st.text_input("Enter your key skills (comma-separated):")
+    industry = st.text_input("Enter your industry (e.g., Technology, Finance):")
 
-    if st.button("Generate Cover Letter"):
-        if not job_link:
-            st.error("Please enter a job link.")
+    if st.button("Find Networking Opportunities"):
+        if not user_skills or not industry:
+            st.error("Please enter both key skills and industry.")
             return
-        if not uploaded_file:
-            st.error("Please upload your resume.")
+        with st.spinner("Fetching networking opportunities..."):
+            # Suggest LinkedIn groups or connections based on skills and industry
+            prompt = f"""
+            Based on the following skills: {user_skills}, and industry: {industry}, suggest relevant LinkedIn groups, professional organizations, and industry events for networking.
+            """
+            suggestions = llm.invoke({"input": prompt}).content.strip()
+            st.subheader("Recommended Networking Groups and Events:")
+            st.write(suggestions)
+
+def salary_estimation_module():
+    st.header("Salary Estimation and Negotiation Tips")
+
+    st.write("""
+    Understand the salary expectations for your desired roles and learn effective negotiation strategies.
+    """)
+
+    job_title = st.text_input("Enter the job title:")
+    location = st.text_input("Enter the location (e.g., Bangalore, India):")
+
+    if st.button("Get Salary Estimate"):
+        if not job_title or not location:
+            st.error("Please enter both job title and location.")
             return
+        with st.spinner("Fetching salary data..."):
+            # Example using a placeholder API or precompiled data
+            # Replace with actual API integration if available
+            # For demonstration, we'll use a mock response
+            prompt = f"""
+            Provide an estimated salary range for a {job_title} in {location}. Include the minimum, average, and maximum salaries.
+            """
+            salary_data = llm.invoke({"input": prompt}).content.strip()
+            st.subheader("Salary Estimate:")
+            st.write(salary_data)
+
+            # Generate negotiation tips
+            tips_prompt = f"""
+            Provide a list of 5 effective tips for negotiating a salary for a {job_title} position in {location}.
+            """
+            tips = llm.invoke({"input": tips_prompt}).content.strip()
+            st.subheader("Negotiation Tips:")
+            st.write(tips)
+
+def feedback_and_improvement_module():
+    st.header("Feedback and Continuous Improvement")
 
-        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 idx, job in enumerate(jobs, 1):
-                    st.markdown(f"### Job {idx}")
-                    st.write(f"**{job['title']}** at **{job['company']}**")
-                    st.markdown(f"[Apply Here]({job['link']})")
-                    st.write("---")
-            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")
-
-    uploaded_file = st.file_uploader("Upload your resume (PDF format):", type="pdf")
-
-    # Fetch job recommendations once resume is uploaded
-    if uploaded_file:
-        resume_text = extract_text_from_pdf(uploaded_file)
-        if resume_text:
-            st.success("Resume uploaded successfully!")
-            # Fetch job recommendations
-            jobs = get_job_recommendations(resume_text)
-            if jobs:
-                # Display job recommendations with selection
-                job_titles = [f"{job['title']} at {job['company']}" for job in jobs]
-                selected_job = st.selectbox("Select a job for Skill Matching:", job_titles)
-                if selected_job:
-                    # Find the selected job's details
-                    selected_index = job_titles.index(selected_job)
-                    selected_job_info = jobs[selected_index]
-                    job_description = selected_job_info['job_description']
-                    
-                    # Extract requirements
-                    requirements = extract_requirements(job_description)
-                    if not requirements:
-                        st.error("Failed to extract requirements.")
-                        return
-
-                    # Extract skills from resume
-                    resume_skills = extract_skills(resume_text)
-                    job_skills = extract_skills(job_description)
-
-                    # 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.")
-
-                    # Provide suggestions
-                    st.subheader("Suggestions for Improvement")
-                    if missing_skills:
-                        st.write("- **Acquire Missing Skills:** Consider pursuing courses or certifications in the following areas:")
-                        for skill in missing_skills:
-                            st.write(f"  - {skill}")
-                    else:
-                        st.write("You have all the required skills for this job!")
+    st.write("""
+    We value your feedback! Let us know how we can improve your experience.
+    """)
+
+    with st.form("feedback_form"):
+        name = st.text_input("Your Name")
+        email = st.text_input("Your Email")
+        feedback_type = st.selectbox("Type of Feedback", ["Bug Report", "Feature Request", "General Feedback"])
+        feedback = st.text_area("Your Feedback")
+        submitted = st.form_submit_button("Submit")
 
+        if submitted:
+            if not name or not email or not feedback:
+                st.error("Please fill in all the fields.")
             else:
-                st.write("No job recommendations found based on your skills.")
-        else:
-            st.error("Failed to extract text from resume.")
-    else:
-        st.write("Please upload your resume to perform Skill Matching.")
+                # Here you can implement logic to store feedback, e.g., in a database or send via email
+                # For demonstration, we'll print to the console
+                print(f"Feedback from {name} ({email}): {feedback_type} - {feedback}")
+                st.success("Thank you for your feedback!")
+
+# -------------------------------
+# Authentication Setup
+# -------------------------------
+
+def setup_authentication():
+    """
+    Sets up user authentication using streamlit-authenticator.
+    """
+    # In a real application, retrieve user data from a secure database
+    names = ["Adithya S Nair"]  # Replace with dynamic user data
+    usernames = ["adithya"]
+    # Passwords should be hashed in a real application
+    passwords = ["$2b$12$KIXvUq2YdZ19FWJGzTqFUeAewH1/gO7xmD2z77Qvxh3A1F1C9KdaW"]  # "password" hashed
 
+    authenticator = stauth.Authenticate(names, usernames, passwords, "job_app_assistant", "abcdef", cookie_expiry_days=30)
+    return authenticator
 
+# -------------------------------
+# 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()
+    # Setup authentication
+    authenticator = setup_authentication()
+    name, authentication_status = authenticator.login("Login", "main")
+
+    if authentication_status:
+        with st.sidebar:
+            selected = option_menu(
+                "Main Menu",
+                ["Email Generator", "Cover Letter Generator", "Resume Analysis", "Application Tracking",
+                 "Interview Preparation", "Personalized Learning Paths", "Networking Opportunities",
+                 "Salary Estimation", "Feedback"],
+                icons=["envelope", "file-earmark-text", "file-person", "briefcase", "gear",
+                       "book", "people", "currency-dollar", "chat-left-text"],
+                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 == "Application Tracking":
+            application_tracking_dashboard()
+        elif selected == "Interview Preparation":
+            interview_preparation_module()
+        elif selected == "Personalized Learning Paths":
+            personalized_learning_paths_module()
+        elif selected == "Networking Opportunities":
+            networking_opportunities_module()
+        elif selected == "Salary Estimation":
+            salary_estimation_module()
+        elif selected == "Feedback":
+            feedback_and_improvement_module()
+    elif authentication_status == False:
+        st.error("Username/password is incorrect")
+    elif authentication_status == None:
+        st.warning("Please enter your username and password")
 
 if __name__ == "__main__":
     main()