Update app.py

app.py

@@ -1,5 +1,3 @@
-# app.py
-
 import streamlit as st
 from streamlit_option_menu import option_menu
 from langchain_groq import ChatGroq
@@ -11,15 +9,16 @@ import uuid
 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
+GROQ_API_KEY = "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"
+RAPIDAPI_KEY = "2a4a8a38a9msh97ce530a89589a6p1d0106jsn1acc0a5ea6bc"  
+
+
 llm = ChatGroq(
     temperature=0,
-    groq_api_key="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",  # Securely accessing the Groq API key
+    groq_api_key=GROQ_API_KEY,
     model_name="llama-3.1-70b-versatile"
 )
 
@@ -193,36 +192,42 @@ def suggest_keywords(resume_text, job_description=None):
 
 def get_job_recommendations(resume_text, location="India"):
     """
-    Fetches job recommendations using the Remotive.io API based on the user's skills.
+    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://remotive.io/api/remote-jobs"
-    params = {
-        "search": query,
-        "limit": 20
+    url = "https://jsearch.p.rapidapi.com/estimated-salary"
+    querystring = {
+        "job_title": query,
+        "location": location,
+        "radius": "100"  # Adjust radius as needed
+    }
+
+    headers = {
+        "x-rapidapi-key": RAPIDAPI_KEY,  # Embedded API key
+        "x-rapidapi-host": "jsearch.p.rapidapi.com"
     }
 
     try:
-        response = requests.get(url, params=params)
+        response = requests.get(url, headers=headers, params=querystring)
         response.raise_for_status()
-        data = response.json()
-        jobs = data.get("jobs", [])
-        job_list = []
-        for job in jobs:
-            job_info = {
-                "title": job.get("title"),
-                "company": job.get("company_name"),
-                "link": job.get("url"),
-                "job_description": job.get("description")  # Including job description for Skill Matching
-            }
-            job_list.append(job_info)
-        return job_list
+        salary_data = response.json()
+
+        # Extract relevant data
+        min_salary = salary_data.get("min_salary")
+        avg_salary = salary_data.get("avg_salary")
+        max_salary = salary_data.get("max_salary")
+
+        return {
+            "min_salary": min_salary,
+            "avg_salary": avg_salary,
+            "max_salary": max_salary
+        }
     except Exception as e:
         st.error(f"Error fetching job recommendations: {e}")
-        return []
+        return {}
 
 def create_skill_distribution_chart(skills):
     """
@@ -394,18 +399,171 @@ def generate_learning_path(career_goal, current_skills):
     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
+# -------------------------------
+# Page Functions
+# -------------------------------
+
+def email_generator_page():
+    st.header("Automated Email Generator")
+
+    st.write("""
+    Generate personalized cold emails based on job postings 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")
 
-    authenticator = stauth.Authenticate(names, usernames, passwords, "job_app_assistant", "abcdef", cookie_expiry_days=30)
-    return authenticator
+    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("""
+    Generate personalized cover letters based on job postings 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():
+    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.")
+
+            # Save the resume and analysis to the database
+            if st.button("Save Resume Analysis"):
+                add_application(
+                    job_title="N/A",
+                    company="N/A",
+                    application_date=datetime.now().strftime("%Y-%m-%d"),
+                    status="N/A",
+                    deadline="N/A",
+                    notes="Resume Analysis",
+                    job_description="N/A",
+                    resume_text=resume_text,
+                    skills=skills
+                )
+                st.success("Resume analysis saved successfully!")
+        else:
+            st.error("Failed to extract text from resume.")
 
 def application_tracking_dashboard():
     st.header("Application Tracking Dashboard")
@@ -568,31 +726,50 @@ def salary_estimation_module():
     Understand the salary expectations for your desired roles and learn effective negotiation strategies.
     """)
 
+    # Input fields
     job_title = st.text_input("Enter the job title:")
-    location = st.text_input("Enter the location (e.g., Bangalore, India):")
+    location = st.text_input("Enter the location (e.g., New York, NY, USA):")
 
     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)
+            # JSearch API Integration
+            salary_data = get_job_recommendations(job_title, location)
+            if salary_data:
+                min_salary = salary_data.get("min_salary")
+                avg_salary = salary_data.get("avg_salary")
+                max_salary = salary_data.get("max_salary")
+
+                if min_salary and avg_salary and max_salary:
+                    st.subheader("Salary Estimate:")
+                    st.write(f"**Minimum Salary:** ${min_salary:,}")
+                    st.write(f"**Average Salary:** ${avg_salary:,}")
+                    st.write(f"**Maximum Salary:** ${max_salary:,}")
+
+                    # Visualization
+                    salary_df = pd.DataFrame({
+                        "Salary Range": ["Minimum", "Average", "Maximum"],
+                        "Amount": [min_salary, avg_salary, max_salary]
+                    })
+
+                    fig = px.bar(salary_df, x="Salary Range", y="Amount",
+                                 title=f"Salary Estimates for {job_title} in {location}",
+                                 labels={"Amount": "Salary (USD)"},
+                                 text_auto=True)
+                    st.plotly_chart(fig)
+                else:
+                    st.error("Salary data not available for the provided job title and location.")
+
+                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)
+            else:
+                st.error("Failed to retrieve salary data.")
 
 def feedback_and_improvement_module():
     st.header("Feedback and Continuous Improvement")
@@ -612,74 +789,188 @@ def feedback_and_improvement_module():
             if not name or not email or not feedback:
                 st.error("Please fill in all the fields.")
             else:
-                # 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 gamification_module():
+    st.header("Gamification and Achievements")
 
-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
+    st.write("""
+    Stay motivated by earning badges and tracking your progress!
+    """)
 
-    authenticator = stauth.Authenticate(names, usernames, passwords, "job_app_assistant", "abcdef", cookie_expiry_days=30)
-    return authenticator
+    # Example achievements
+    applications = fetch_applications()
+    num_apps = len(applications)
+    achievements = {
+        "First Application": num_apps >= 1,
+        "5 Applications": num_apps >= 5,
+        "10 Applications": num_apps >= 10,
+        "Resume Optimized": any(app['Skills'] for app in applications),
+        "Interview Scheduled": any(app['Status'] == 'Interviewing' for app in applications)
+    }
 
-# -------------------------------
-# Main App with Sidebar Navigation
-# -------------------------------
+    for achievement, earned in achievements.items():
+        if earned:
+            st.success(f"🎉 {achievement}")
+        else:
+            st.info(f"🔜 {achievement}")
+
+    # Progress Bar
+    progress = min(num_apps / 10 * 100, 100)  # Assuming 10 applications for full progress
+    st.write("**Overall Progress:**")
+    st.progress(progress)
+    st.write(f"{progress:.0f}% complete")
+
+def resource_library_page():
+    st.header("Resource Library")
+
+    st.write("""
+    Access a collection of templates and guides to enhance your job search.
+    """)
+
+    resources = [
+        {
+            "title": "Resume Template",
+            "description": "A professional resume template in DOCX format.",
+            "file": "resume_template.docx"
+        },
+        {
+            "title": "Cover Letter Template",
+            "description": "A customizable cover letter template.",
+            "file": "cover_letter_template.docx"
+        },
+        {
+            "title": "Job Application Checklist",
+            "description": "Ensure you have all the necessary steps covered during your job search.",
+            "file": "application_checklist.pdf"
+        }
+    ]
+
+    for resource in resources:
+        st.markdown(f"### {resource['title']}")
+        st.write(resource['description'])
+        try:
+            with open(resource['file'], "rb") as file:
+                btn = st.download_button(
+                    label="Download",
+                    data=file,
+                    file_name=resource['file'],
+                    mime="application/octet-stream"
+                )
+        except FileNotFoundError:
+            st.error(f"File {resource['file']} not found.")
+        st.write("---")
+
+def success_stories_page():
+    st.header("Success Stories")
+
+    st.write("""
+    Hear from our users who have successfully landed their dream jobs with our assistance!
+    """)
+
+    # Example testimonials
+    testimonials = [
+        {
+            "name": "Rahul Sharma",
+            "position": "Data Scientist at TechCorp",
+            "testimonial": "This app transformed my job search process. The resume analysis and personalized emails were game-changers!",
+            "image": "images/user1.jpg"  # Replace with actual image paths
+        },
+        {
+            "name": "Priya Mehta",
+            "position": "Machine Learning Engineer at InnovateX",
+            "testimonial": "The interview preparation module helped me ace my interviews with confidence. Highly recommended!",
+            "image": "images/user2.jpg"
+        }
+    ]
+
+    for user in testimonials:
+        col1, col2 = st.columns([1, 3])
+        with col1:
+            try:
+                st.image(user["image"], width=100)
+            except:
+                st.write("![User Image](https://via.placeholder.com/100)")
+        with col2:
+            st.write(f"**{user['name']}**")
+            st.write(f"*{user['position']}*")
+            st.write(f"\"{user['testimonial']}\"")
+            st.write("---")
+
+def chatbot_support_page():
+    st.header("AI-Powered Chatbot Support")
+
+    st.write("""
+    Have questions or need assistance? Chat with our AI-powered assistant!
+    """)
+
+    # Initialize session state for chatbot
+    if 'chat_history' not in st.session_state:
+        st.session_state['chat_history'] = []
+
+    user_input = st.text_input("You:", key="user_input")
+
+    if st.button("Send"):
+        if user_input:
+            st.session_state['chat_history'].append(f"You: {user_input}")
+            prompt = f"""
+            You are a helpful assistant for a Job Application Assistant app. Answer the user's query based on the following context:
+            
+            {user_input}
+            """
+            response = llm.invoke({"input": prompt}).content.strip()
+            st.session_state['chat_history'].append(f"Assistant: {response}")
+
+    # Display chat history
+    for message in st.session_state['chat_history']:
+        if message.startswith("You:"):
+            st.markdown(f"<p style='color:blue;'>{message}</p>", unsafe_allow_html=True)
+        else:
+            st.markdown(f"<p style='color:green;'>{message}</p>", unsafe_allow_html=True)
 
 def main():
     st.set_page_config(page_title="Job Application Assistant", layout="wide")
 
-    # 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,
-            )
+    # Sidebar Navigation
+    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", "Gamification", "Resource Library", "Success Stories", "Chatbot Support"],
+            icons=["envelope", "file-earmark-text", "file-person", "briefcase", "gear",
+                   "book", "people", "currency-dollar", "chat-left-text", "trophy", "collection", "star", "chat"],
+            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 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 selected == "Gamification":
+        gamification_module()
+    elif selected == "Resource Library":
+        resource_library_page()
+    elif selected == "Success Stories":
+        success_stories_page()
+    elif selected == "Chatbot Support":
+        chatbot_support_page()
 
 if __name__ == "__main__":
     main()