Update app.py

app.py

@@ -8,26 +8,26 @@ import sqlite3
 from datetime import datetime, timedelta
 import re
 import os
-from streamlit_option_menu import option_menu
 import fitz  # PyMuPDF
 from bs4 import BeautifulSoup
+from streamlit_option_menu import option_menu
 
-
+# Secrets and API Keys
 GROQ_API_KEY = st.secrets["GROQ_API_KEY"]
 RAPIDAPI_KEY = st.secrets["RAPIDAPI_KEY"]
 YOUTUBE_API_KEY = st.secrets["YOUTUBE_API_KEY"]
 THE_MUSE_API_KEY = st.secrets.get("THE_MUSE_API_KEY", "") 
 BLS_API_KEY = st.secrets.get("BLS_API_KEY", "")  
 
-
 llm = ChatGroq(
     temperature=0,
     groq_api_key=GROQ_API_KEY,
     model_name="llama-3.1-70b-versatile"
 )
 
-
-
+# -------------------------------
+# PDF and HTML Extraction Functions
+# -------------------------------
 @st.cache_data(ttl=3600)
 def extract_text_from_pdf(pdf_file):
     """
@@ -49,13 +49,10 @@ 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)"
-        }
+        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
         job_description = soup.get_text(separator='\n')
         return job_description.strip()
     except Exception as e:
@@ -76,19 +73,20 @@ def extract_requirements(job_description):
 
     Requirements:
     """
-
     try:
         response = llm.invoke(prompt)
-        requirements = response.content.strip()
-        return requirements
+        return response.content.strip()
     except Exception as e:
         st.error(f"Error extracting requirements: {e}")
         return ""
 
+# -------------------------------
+# Email and Cover Letter Generation
+# -------------------------------
 @st.cache_data(ttl=3600)
 def generate_email(job_description, requirements, resume_text):
     """
-    Generates a personalized cold email using Groq based on the job description, requirements, and resume.
+    Generates a personalized cold email using Groq.
     """
     prompt = 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:
@@ -103,16 +101,14 @@ def generate_email(job_description, requirements, resume_text):
     {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.
+    - Introduction: Briefly introduce yourself and mention the specific job you are applying for.
+    - Body: Highlight your relevant skills, projects, internships, and leadership experiences.
+    - Value Proposition: Explain how your fresh perspective can add value to the company.
+    - Closing: Express enthusiasm and request an interview.
     """
-
     try:
         response = llm.invoke(prompt)
-        email_text = response.content.strip()
-        return email_text
+        return response.content.strip()
     except Exception as e:
         st.error(f"Error generating email: {e}")
         return ""
@@ -120,10 +116,10 @@ def generate_email(job_description, requirements, resume_text):
 @st.cache_data(ttl=3600)
 def generate_cover_letter(job_description, requirements, resume_text):
     """
-    Generates a personalized cover letter using Groq based on the job description, requirements, and resume.
+    Generates a personalized cover letter using Groq.
     """
     prompt = 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:
+    You are Adithya S Nair, a recent Computer Science graduate specializing in Artificial Intelligence and Machine Learning. Compose a professional cover letter based on the following information:
 
     **Job Description:**
     {job_description}
@@ -135,24 +131,22 @@ def generate_cover_letter(job_description, requirements, resume_text):
     {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.
+    1. Greeting: Address the hiring manager.
+    2. Introduction: Mention the position and your enthusiasm.
+    3. Body: Highlight skills, experiences, and relevant projects.
+    4. Value Proposition: Explain how you can contribute to the company.
+    5. Conclusion: Express interest in an interview and thank the reader.
     """
-
     try:
         response = llm.invoke(prompt)
-        cover_letter = response.content.strip()
-        return cover_letter
+        return response.content.strip()
     except Exception as e:
         st.error(f"Error generating cover letter: {e}")
         return ""
 
+# -------------------------------
+# Resume Analysis Functions
+# -------------------------------
 @st.cache_data(ttl=3600)
 def extract_skills(text):
     """
@@ -166,11 +160,9 @@ def extract_skills(text):
 
     Skills:
     """
-
     try:
         response = llm.invoke(prompt)
         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
     except Exception as e:
@@ -180,10 +172,10 @@ def extract_skills(text):
 @st.cache_data(ttl=3600)
 def suggest_keywords(resume_text, job_description=None):
     """
-    Suggests additional relevant keywords to enhance resume compatibility with ATS.
+    Suggests additional relevant keywords for ATS optimization.
     """
     prompt = 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.
+    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 accordingly.
 
     Resume Text:
     {resume_text}
@@ -193,7 +185,6 @@ def suggest_keywords(resume_text, job_description=None):
 
     Suggested Keywords:
     """
-
     try:
         response = llm.invoke(prompt)
         keywords = response.content.strip()
@@ -218,7 +209,6 @@ def create_experience_timeline(resume_text):
     """
     Creates an experience timeline from the resume text.
     """
-    # Extract work experience details using Groq
     prompt = 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).
 
@@ -227,11 +217,9 @@ def create_experience_timeline(resume_text):
 
     Table:
     """
-
     try:
         response = llm.invoke(prompt)
         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"):
@@ -240,12 +228,10 @@ def create_experience_timeline(resume_text):
                     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")
@@ -274,30 +260,15 @@ def parse_duration(duration_str):
         return 0
 
 # -------------------------------
-# API Integration Functions
+# Job API Integration Functions
 # -------------------------------
-
-# Remotive API Integration
-@st.cache_data(ttl=86400)  # Cache results for 1 day
+@st.cache_data(ttl=86400)
 def fetch_remotive_jobs_api(job_title, location=None, category=None, remote=True, max_results=50):
     """
-    Fetches job listings from Remotive API based on user preferences.
-    
-    Args:
-        job_title (str): The job title to search for.
-        location (str, optional): The job location. Defaults to None.
-        category (str, optional): The job category. Defaults to None.
-        remote (bool, optional): Whether to fetch remote jobs. Defaults to True.
-        max_results (int, optional): Maximum number of jobs to fetch. Defaults to 50.
-    
-    Returns:
-        list: A list of job dictionaries.
+    Fetches job listings from Remotive API.
     """
     base_url = "https://remotive.com/api/remote-jobs"
-    params = {
-        "search": job_title,
-        "limit": max_results
-    }
+    params = {"search": job_title, "limit": max_results}
     if category:
         params["category"] = category
     try:
@@ -305,72 +276,36 @@ def fetch_remotive_jobs_api(job_title, location=None, category=None, remote=True
         response.raise_for_status()
         jobs = response.json().get("jobs", [])
         if remote:
-            # Filter for remote jobs if not already
             jobs = [job for job in jobs if job.get("candidate_required_location") == "Worldwide" or job.get("remote") == True]
         return jobs
     except requests.exceptions.RequestException as e:
         st.error(f"Error fetching jobs from Remotive: {e}")
         return []
 
-# The Muse API Integration
-@st.cache_data(ttl=86400)  # Cache results for 1 day
+@st.cache_data(ttl=86400)
 def fetch_muse_jobs_api(job_title, location=None, category=None, max_results=50):
     """
-    Fetches job listings from The Muse API based on user preferences.
-    
-    Args:
-        job_title (str): The job title to search for.
-        location (str, optional): The job location. Defaults to None.
-        category (str, optional): The job category. Defaults to None.
-        max_results (int, optional): Maximum number of jobs to fetch. Defaults to 50.
-    
-    Returns:
-        list: A list of job dictionaries.
+    Fetches job listings from The Muse API.
     """
     base_url = "https://www.themuse.com/api/public/jobs"
-    headers = {
-        "Content-Type": "application/json"
-    }
-    params = {
-        "page": 1,
-        "per_page": max_results,
-        "category": category,
-        "location": location,
-        "company": None  # Can be extended based on needs
-    }
+    headers = {"Content-Type": "application/json"}
+    params = {"page": 1, "per_page": max_results, "category": category, "location": location, "company": None}
     try:
         response = requests.get(base_url, params=params, headers=headers)
         response.raise_for_status()
         jobs = response.json().get("results", [])
-        # Filter based on job title
         filtered_jobs = [job for job in jobs if job_title.lower() in job.get("name", "").lower()]
         return filtered_jobs
     except requests.exceptions.RequestException as e:
         st.error(f"Error fetching jobs from The Muse: {e}")
         return []
 
-# Indeed API Integration using /list and /get
-@st.cache_data(ttl=86400)  # Cache results for 1 day
+@st.cache_data(ttl=86400)
 def fetch_indeed_jobs_list_api(job_title, location="United States", distance="1.0", language="en_GB", remoteOnly="false", datePosted="month", employmentTypes="fulltime;parttime;intern;contractor", index=0, page_size=10):
     """
-    Fetches a list of job IDs from Indeed API based on user preferences.
-
-    Args:
-        job_title (str): The job title to search for.
-        location (str, optional): The job location. Defaults to "United States".
-        distance (str, optional): Search radius in miles. Defaults to "1.0".
-        language (str, optional): Language code. Defaults to "en_GB".
-        remoteOnly (str, optional): "true" or "false". Defaults to "false".
-        datePosted (str, optional): e.g., "month". Defaults to "month".
-        employmentTypes (str, optional): e.g., "fulltime;parttime;intern;contractor". Defaults to "fulltime;parttime;intern;contractor".
-        index (int, optional): Pagination index. Defaults to 0.
-        page_size (int, optional): Number of jobs to fetch. Defaults to 10.
-
-    Returns:
-        list: A list of job IDs.
+    Fetches a list of job IDs from Indeed API.
     """
     url = "https://jobs-api14.p.rapidapi.com/list"
-
     querystring = {
         "query": job_title,
         "location": location,
@@ -382,106 +317,48 @@ def fetch_indeed_jobs_list_api(job_title, location="United States", distance="1.
         "index": str(index),
         "page_size": str(page_size)
     }
-
-    headers = {
-        "x-rapidapi-key": RAPIDAPI_KEY,
-        "x-rapidapi-host": "jobs-api14.p.rapidapi.com"
-    }
-
+    headers = {"x-rapidapi-key": RAPIDAPI_KEY, "x-rapidapi-host": "jobs-api14.p.rapidapi.com"}
     try:
         response = requests.get(url, headers=headers, params=querystring)
         response.raise_for_status()
         data = response.json()
         job_ids = [job["id"] for job in data.get("jobs", [])]
         return job_ids
-    except requests.exceptions.HTTPError as http_err:
-        if response.status_code == 400:
-            st.error("❌ Bad Request: Please check the parameters you're sending.")
-        elif response.status_code == 403:
-            st.error("❌ Access Forbidden: Check your API key and permissions.")
-        elif response.status_code == 404:
-            st.error("❌ Resource Not Found: Verify the endpoint and parameters.")
-        else:
-            st.error(f"❌ HTTP error occurred: {http_err}")
-        return []
-    except requests.exceptions.RequestException as req_err:
-        st.error(f"❌ Request Exception: {req_err}")
-        return []
-    except Exception as e:
-        st.error(f"❌ An unexpected error occurred: {e}")
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching job IDs from Indeed: {e}")
         return []
 
-@st.cache_data(ttl=86400)  # Cache results for 1 day
+@st.cache_data(ttl=86400)
 def fetch_indeed_job_details_api(job_id, language="en_GB"):
     """
-    Fetches job details from Indeed API based on job ID.
-
-    Args:
-        job_id (str): The job ID.
-        language (str, optional): Language code. Defaults to "en_GB".
-
-    Returns:
-        dict: Job details.
+    Fetches job details from Indeed API.
     """
     url = "https://jobs-api14.p.rapidapi.com/get"
-
-    querystring = {
-        "id": job_id,
-        "language": language
-    }
-
-    headers = {
-        "x-rapidapi-key": RAPIDAPI_KEY,
-        "x-rapidapi-host": "jobs-api14.p.rapidapi.com"
-    }
-
+    querystring = {"id": job_id, "language": language}
+    headers = {"x-rapidapi-key": RAPIDAPI_KEY, "x-rapidapi-host": "jobs-api14.p.rapidapi.com"}
     try:
         response = requests.get(url, headers=headers, params=querystring)
         response.raise_for_status()
-        job_details = response.json()
-        return job_details
-    except requests.exceptions.HTTPError as http_err:
-        if response.status_code == 400:
-            st.error("❌ Bad Request: Please check the job ID and parameters.")
-        elif response.status_code == 403:
-            st.error("❌ Access Forbidden: Check your API key and permissions.")
-        elif response.status_code == 404:
-            st.error("❌ Job Not Found: Verify the job ID.")
-        else:
-            st.error(f"❌ HTTP error occurred: {http_err}")
-        return {}
-    except requests.exceptions.RequestException as req_err:
-        st.error(f"❌ Request Exception: {req_err}")
-        return {}
-    except Exception as e:
-        st.error(f"❌ An unexpected error occurred: {e}")
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching job details from Indeed: {e}")
         return {}
 
 def recommend_indeed_jobs(user_skills, user_preferences):
     """
     Recommends jobs from Indeed API based on user skills and preferences.
-
-    Args:
-        user_skills (list): List of user's skills.
-        user_preferences (dict): User preferences like job title, location, category.
-
-    Returns:
-        list: Recommended job listings.
     """
     job_title = user_preferences.get("job_title", "")
     location = user_preferences.get("location", "United States")
     category = user_preferences.get("category", "")
     language = "en_GB"
 
-    # Fetch job IDs
-    job_ids = fetch_indeed_jobs_list_api(job_title, location=location, category=category, page_size=5)  # Limiting to 5 for API call count
-
+    job_ids = fetch_indeed_jobs_list_api(job_title, location=location, category=category, page_size=5)
     recommended_jobs = []
-    api_calls_needed = len(job_ids)  # Each /get call counts as one
+    api_calls_needed = len(job_ids)
 
-    # Check if enough API calls are left
     if not can_make_api_calls(api_calls_needed):
-        st.error("❌ You have reached your monthly API request limit. Please try again next month.")
+        st.error("❌ You have reached your monthly API request limit. Please try again later.")
         return []
 
     for job_id in job_ids:
@@ -493,117 +370,28 @@ def recommend_indeed_jobs(user_skills, user_preferences):
                 recommended_jobs.append((match_score, job_details))
                 decrement_api_calls(1)
     
-    # Sort jobs based on match_score
     recommended_jobs.sort(reverse=True, key=lambda x: x[0])
-
-    # Return only the job dictionaries
-    return [job for score, job in recommended_jobs[:10]]  # Top 10 recommendations
+    return [job for score, job in recommended_jobs[:10]]
 
 def recommend_jobs(user_skills, user_preferences):
     """
-    Recommends jobs based on user skills and preferences from Remotive, The Muse, and Indeed APIs.
-
-    Args:
-        user_skills (list): List of user's skills.
-        user_preferences (dict): User preferences like job title, location, category.
-
-    Returns:
-        list: Recommended job listings.
+    Combines job recommendations from Remotive, The Muse, and Indeed.
     """
-    # Fetch from Remotive
     remotive_jobs = fetch_remotive_jobs_api(user_preferences.get("job_title", ""), user_preferences.get("location"), user_preferences.get("category"))
-
-    # Fetch from The Muse
     muse_jobs = fetch_muse_jobs_api(user_preferences.get("job_title", ""), user_preferences.get("location"), user_preferences.get("category"))
-
-    # Fetch from Indeed
     indeed_jobs = recommend_indeed_jobs(user_skills, user_preferences)
 
-    # Combine all job listings
     combined_jobs = remotive_jobs + muse_jobs + indeed_jobs
-
-    # Remove duplicates based on job URL
     unique_jobs = {}
     for job in combined_jobs:
         url = job.get("url") or job.get("redirect_url") or job.get("url_standard")
         if url and url not in unique_jobs:
             unique_jobs[url] = job
-
     return list(unique_jobs.values())
 
-# -------------------------------
-# BLS API Integration and Display
-# -------------------------------
-
-@st.cache_data(ttl=86400)  # Cache results for 1 day
-def fetch_bls_data(series_ids, start_year=2020, end_year=datetime.now().year):
-    """
-    Fetches labor market data from the BLS API.
-
-    Args:
-        series_ids (list): List of BLS series IDs.
-        start_year (int, optional): Start year for data. Defaults to 2020.
-        end_year (int, optional): End year for data. Defaults to current year.
-
-    Returns:
-        dict: BLS data response.
-    """
-    bls_url = "https://api.bls.gov/publicAPI/v2/timeseries/data/"
-    headers = {
-        "Content-Type": "application/json"
-    }
-    payload = {
-        "seriesid": series_ids,
-        "startyear": str(start_year),
-        "endyear": str(end_year)
-    }
-    try:
-        response = requests.post(bls_url, json=payload, headers=headers)
-        response.raise_for_status()
-        data = response.json()
-        if data.get("status") == "REQUEST_SUCCEEDED":
-            return data.get("Results", {})
-        else:
-            st.error("BLS API request failed.")
-            return {}
-    except requests.exceptions.RequestException as e:
-        st.error(f"Error fetching data from BLS: {e}")
-        return {}
-
-def display_bls_data(series_id, title):
-    """
-    Processes and displays BLS data with visualizations.
-
-    Args:
-        series_id (str): BLS series ID.
-        title (str): Title for the visualization.
-    """
-    data = fetch_bls_data([series_id])
-    if not data:
-        st.info("No data available.")
-        return
-
-    series_data = data.get("series", [])[0]
-    series_title = series_data.get("title", title)
-    observations = series_data.get("data", [])
-
-    # Extract year and value
-    years = [int(obs["year"]) for obs in observations]
-    values = [float(obs["value"].replace(',', '')) for obs in observations]
-
-    df = pd.DataFrame({
-        "Year": years,
-        "Value": values
-    }).sort_values("Year")
-
-    st.markdown(f"### {series_title}")
-    fig = px.line(df, x="Year", y="Value", title=series_title, markers=True)
-    st.plotly_chart(fig, use_container_width=True)
-
 # -------------------------------
 # API Usage Counter Functions
 # -------------------------------
-
 def init_api_usage_db():
     """
     Initializes the SQLite database and creates the api_usage table if it doesn't exist.
@@ -617,10 +405,8 @@ def init_api_usage_db():
             last_reset DATE
         )
     ''')
-    # Check if a row exists, if not, initialize
     c.execute('SELECT COUNT(*) FROM api_usage')
     if c.fetchone()[0] == 0:
-        # Initialize with 25 requests and current date
         c.execute('INSERT INTO api_usage (count, last_reset) VALUES (?, ?)', (25, datetime.now().date()))
     conn.commit()
     conn.close()
@@ -628,9 +414,6 @@ def init_api_usage_db():
 def get_api_usage():
     """
     Retrieves the current API usage count and last reset date.
-
-    Returns:
-        tuple: (count, last_reset_date)
     """
     conn = sqlite3.connect('applications.db')
     c = conn.cursor()
@@ -644,7 +427,7 @@ def get_api_usage():
 
 def reset_api_usage():
     """
-    Resets the API usage count to 25 and updates the last reset date.
+    Resets the API usage count to 25.
     """
     conn = sqlite3.connect('applications.db')
     c = conn.cursor()
@@ -655,49 +438,34 @@ def reset_api_usage():
 def can_make_api_calls(requests_needed):
     """
     Checks if there are enough API calls remaining.
-
-    Args:
-        requests_needed (int): Number of API calls required.
-
-    Returns:
-        bool: True if allowed, False otherwise.
     """
     count, last_reset = get_api_usage()
     today = datetime.now().date()
     if today >= last_reset + timedelta(days=30):
         reset_api_usage()
         count, last_reset = get_api_usage()
-    if count >= requests_needed:
-        return True
-    else:
-        return False
+    return count >= requests_needed
 
 def decrement_api_calls(requests_used):
     """
-    Decrements the API usage count by the number of requests used.
-
-    Args:
-        requests_used (int): Number of API calls used.
+    Decrements the API usage count.
     """
     conn = sqlite3.connect('applications.db')
     c = conn.cursor()
     c.execute('SELECT count FROM api_usage WHERE id = 1')
     row = c.fetchone()
     if row:
-        new_count = row[0] - requests_used
-        if new_count < 0:
-            new_count = 0
+        new_count = max(row[0] - requests_used, 0)
         c.execute('UPDATE api_usage SET count = ? WHERE id = 1', (new_count,))
         conn.commit()
     conn.close()
 
 # -------------------------------
-# Application Tracking Database Functions
+# Application Tracking Functions
 # -------------------------------
-
 def init_db():
     """
-    Initializes the SQLite database and creates the applications table if it doesn't exist.
+    Initializes the SQLite database and creates the applications table.
     """
     conn = sqlite3.connect('applications.db')
     c = conn.cursor()
@@ -777,16 +545,15 @@ def delete_application(app_id):
     conn.close()
 
 # -------------------------------
-# Learning Path Generation Function
+# Learning Path Generation
 # -------------------------------
-
-@st.cache_data(ttl=86400)  # Cache results for 1 day
+@st.cache_data(ttl=86400)
 def generate_learning_path(career_goal, current_skills):
     """
-    Generates a personalized learning path using Groq based on career goal and current skills.
+    Generates a personalized learning path using Groq.
     """
     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.
+    Based on the following career goal and current skills, create a personalized learning path that includes recommended courses, projects, and milestones.
 
     **Career Goal:**
     {career_goal}
@@ -796,11 +563,9 @@ def generate_learning_path(career_goal, current_skills):
 
     **Learning Path:**
     """
-
     try:
         response = llm.invoke(prompt)
-        learning_path = response.content.strip()
-        return learning_path
+        return response.content.strip()
     except Exception as e:
         st.error(f"Error generating learning path: {e}")
         return ""
@@ -808,19 +573,10 @@ def generate_learning_path(career_goal, current_skills):
 # -------------------------------
 # YouTube Video Search and Embed Functions
 # -------------------------------
-
-@st.cache_data(ttl=86400)  # Cache results for 1 day
+@st.cache_data(ttl=86400)
 def search_youtube_videos(query, max_results=2, video_duration="long"):
     """
-    Searches YouTube for videos matching the query and returns video URLs.
-    
-    Args:
-        query (str): Search query.
-        max_results (int, optional): Number of videos to return. Defaults to 2.
-        video_duration (str, optional): Duration filter ('any', 'short', 'medium', 'long'). Defaults to "long".
-    
-    Returns:
-        list: List of YouTube video URLs.
+    Searches YouTube for videos matching the query.
     """
     search_url = "https://www.googleapis.com/youtube/v3/search"
     params = {
@@ -843,63 +599,23 @@ def search_youtube_videos(query, max_results=2, video_duration="long"):
 
 def embed_youtube_videos(video_urls, module_name):
     """
-    Embeds YouTube videos in the Streamlit app.
-    
-    Args:
-        video_urls (list): List of YouTube video URLs.
-        module_name (str): Name of the module for context.
+    Embeds YouTube videos.
     """
     for url in video_urls:
         st.video(url)
 
 # -------------------------------
-# Job Recommendations and BLS Integration
+# Application Modules (Pages)
 # -------------------------------
-
-def labor_market_insights_module():
-    st.header("📈 Labor Market Insights")
-
-    st.write("""
-    Gain valuable insights into the current labor market trends, employment rates, and industry growth to make informed career decisions.
-    """)
-
-    # Define BLS Series IDs based on desired data
-    # Example: Unemployment rate (Series ID: LNS14000000)
-    # Reference: https://www.bls.gov/web/laus/laumstrk.htm
-    unemployment_series_id = "LNS14000000"  # Unemployment Rate
-    employment_series_id = "CEU0000000001"  # Total Employment
-
-    # Display Unemployment Rate
-    display_bls_data(unemployment_series_id, "Unemployment Rate (%)")
-
-    # Display Total Employment
-    display_bls_data(employment_series_id, "Total Employment")
-
-    # Additional Insights
-    st.subheader("💡 Additional Insights")
-    st.write("""
-    - **Industry Growth:** Understanding which industries are growing can help you target your job search effectively.
-    - **Salary Trends:** Keeping an eye on salary trends ensures that you negotiate effectively and align your expectations.
-    - **Geographical Demand:** Some regions may have higher demand for certain roles, guiding your location preferences.
-    """)
-
-# -------------------------------
-# Page Functions
-# -------------------------------
-
 def email_generator_page():
     st.header("📧 Automated Email Generator")
+    st.write("Generate personalized cold emails based on job postings and your resume.")
 
-    st.write("""
-    Generate personalized cold emails based on job postings and your resume.
-    """)
-
-    # Create two columns for input fields
     col1, col2 = st.columns(2)
     with col1:
         job_link = st.text_input("🔗 Enter the job link:")
     with col2:
-        uploaded_file = st.file_uploader("📄 Upload your resume (PDF format):", type="pdf")
+        uploaded_file = st.file_uploader("📄 Upload your resume (PDF):", type="pdf")
 
     if st.button("Generate Email"):
         if not job_link:
@@ -908,54 +624,36 @@ def email_generator_page():
         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"
-                )
+                st.download_button("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.")
 
-    st.write("""
-    Generate personalized cover letters based on job postings and your resume.
-    """)
-
-    # Create two columns for input fields
     col1, col2 = st.columns(2)
     with col1:
         job_link = st.text_input("🔗 Enter the job link:")
     with col2:
-        uploaded_file = st.file_uploader("📄 Upload your resume (PDF format):", type="pdf")
+        uploaded_file = st.file_uploader("📄 Upload your resume (PDF):", type="pdf")
 
     if st.button("Generate Cover Letter"):
         if not job_link:
@@ -964,104 +662,64 @@ def cover_letter_generator_page():
         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"
-                )
+                st.download_button("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")
-
-    st.write("""
-    Enhance your resume's effectiveness with our comprehensive analysis tools. Upload your resume to extract key information, receive optimization suggestions, and visualize your skills and experience.
-    """)
-
-    uploaded_file = st.file_uploader("📂 Upload your resume (PDF format):", type="pdf")
-
+    st.write("Enhance your resume by extracting key information, suggestions, and visual analytics.")
+    
+    uploaded_file = st.file_uploader("📂 Upload your resume (PDF):", type="pdf")
     if uploaded_file:
         resume_text = extract_text_from_pdf(uploaded_file)
         if resume_text:
             st.success("✅ Resume uploaded successfully!")
-
-            # Extracted Information
             st.subheader("🔍 Extracted Information")
-
-            # Create tabs for organized sections
             tabs = st.tabs(["💼 Skills", "🔑 Suggested Keywords"])
-
             with tabs[0]:
                 skills = extract_skills(resume_text)
                 if skills:
                     st.markdown("**Identified Skills:**")
-                    # Display skills as bullet points in columns
                     cols = st.columns(4)
                     for idx, skill in enumerate(skills, 1):
                         cols[idx % 4].write(f"- {skill}")
                 else:
                     st.info("No skills extracted.")
-
             with tabs[1]:
                 keywords = suggest_keywords(resume_text)
                 if keywords:
                     st.markdown("**Suggested Keywords for ATS Optimization:**")
-                    # Display keywords as bullet points in columns
                     cols = st.columns(4)
                     for idx, keyword in enumerate(keywords, 1):
                         cols[idx % 4].write(f"- {keyword}")
                 else:
                     st.info("No keywords suggested.")
-
-            # Optimization Suggestions
             st.subheader("🛠️ Optimization Suggestions")
-            if keywords:
-                st.markdown("""
-                - **Keyword Optimization:** Incorporate the suggested keywords to improve ATS compatibility.
-                - **Enhance Relevant Sections:** Highlight skills and experiences that align closely with job descriptions.
-                """)
-            else:
-                st.markdown("- **Keyword Optimization:** No keywords suggested.")
             st.markdown("""
-                - **Formatting:** Ensure consistent formatting for headings, bullet points, and text alignment to enhance readability.
-                - **Quantify Achievements:** Where possible, quantify your accomplishments to demonstrate impact.
-                - **Tailor Your Resume:** Customize your resume for each job application to emphasize relevant experiences.
+            - **Keyword Optimization:** Incorporate suggested keywords.
+            - **Highlight Relevant Sections:** Emphasize skills that match job requirements.
+            - **Consistent Formatting:** Ensure readability and structure.
             """)
-
-            # Visual Resume Analytics
             st.subheader("📊 Visual Resume Analytics")
-
-            # Create two columns for charts
             viz_col1, viz_col2 = st.columns(2)
-
             with viz_col1:
                 if skills:
                     st.markdown("**Skill Distribution:**")
@@ -1069,7 +727,6 @@ def resume_analysis_page():
                     st.plotly_chart(fig_skills, use_container_width=True)
                 else:
                     st.info("No skills to display.")
-
             with viz_col2:
                 fig_experience = create_experience_timeline(resume_text)
                 if fig_experience:
@@ -1077,8 +734,6 @@ def resume_analysis_page():
                     st.plotly_chart(fig_experience, use_container_width=True)
                 else:
                     st.info("Not enough data to generate an experience timeline.")
-
-            # Save the resume and analysis to the database
             st.subheader("💾 Save Resume Analysis")
             if st.button("Save Resume Analysis"):
                 add_application(
@@ -1098,12 +753,9 @@ def resume_analysis_page():
 
 def application_tracking_dashboard():
     st.header("📋 Application Tracking Dashboard")
-
-    # Initialize database
     init_db()
     init_api_usage_db()
-
-    # Form to add a new application
+    
     st.subheader("➕ Add New Application")
     with st.form("add_application"):
         job_title = st.text_input("🖇️ Job Title")
@@ -1116,10 +768,7 @@ def application_tracking_dashboard():
         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 = ""
+            job_description = extract_text_from_pdf(uploaded_file) if uploaded_file else ""
             if uploaded_resume:
                 resume_text = extract_text_from_pdf(uploaded_resume)
                 skills = extract_skills(resume_text)
@@ -1138,78 +787,49 @@ def application_tracking_dashboard():
                 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)
-
-        # Export Button
         csv = df.to_csv(index=False).encode('utf-8')
-        st.download_button(
-            label="💾 Download Applications as CSV",
-            data=csv,
-            file_name='applications.csv',
-            mime='text/csv',
-        )
-
-        # Import Button
+        st.download_button("💾 Download Applications as CSV", data=csv, file_name='applications.csv', mime='text/csv')
         st.subheader("📥 Import Applications")
         uploaded_csv = st.file_uploader("📁 Upload a CSV file", type="csv")
         if uploaded_csv:
             try:
                 imported_df = pd.read_csv(uploaded_csv)
-                # Validate required columns
                 required_columns = {"Job Title", "Company", "Application Date", "Status", "Deadline", "Notes"}
                 if not required_columns.issubset(imported_df.columns):
                     st.error("❌ Uploaded CSV is missing required columns.")
                 else:
-                    for index, row in imported_df.iterrows():
-                        job_title = row.get("Job Title", "N/A")
-                        company = row.get("Company", "N/A")
-                        application_date = row.get("Application Date", datetime.now().strftime("%Y-%m-%d"))
-                        status = row.get("Status", "Applied")
-                        deadline = row.get("Deadline", "")
-                        notes = row.get("Notes", "")
-                        job_description = row.get("Job Description", "")
-                        resume_text = row.get("Resume Text", "")
-                        skills = row.get("Skills", "").split(', ') if row.get("Skills") else []
+                    for _, row in imported_df.iterrows():
                         add_application(
-                            job_title=job_title,
-                            company=company,
-                            application_date=application_date,
-                            status=status,
-                            deadline=deadline,
-                            notes=notes,
-                            job_description=job_description,
-                            resume_text=resume_text,
-                            skills=skills
+                            job_title=row.get("Job Title", "N/A"),
+                            company=row.get("Company", "N/A"),
+                            application_date=row.get("Application Date", datetime.now().strftime("%Y-%m-%d")),
+                            status=row.get("Status", "Applied"),
+                            deadline=row.get("Deadline", ""),
+                            notes=row.get("Notes", ""),
+                            job_description=row.get("Job Description", ""),
+                            resume_text=row.get("Resume Text", ""),
+                            skills=row.get("Skills", "").split(', ') if row.get("Skills") else []
                         )
                     st.success("✅ Applications imported successfully!")
             except Exception as e:
                 st.error(f"❌ Error importing applications: {e}")
-
-        # 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!")
@@ -1218,46 +838,29 @@ def application_tracking_dashboard():
 
 def job_recommendations_module():
     st.header("🔍 Job Matching & Recommendations")
-
-    st.write("""
-    Discover job opportunities tailored to your skills and preferences. Get personalized recommendations from multiple job platforms.
-    """)
-
-    # User Preferences Form
+    st.write("Discover job opportunities tailored to your skills and preferences.")
     st.subheader("🎯 Set Your Preferences")
     with st.form("preferences_form"):
-        job_title = st.text_input("🔍 Desired Job Title", placeholder="e.g., Data Scientist, Backend Developer")
-        location = st.text_input("📍 Preferred Location", placeholder="e.g., New York, NY, USA or Remote")
+        job_title = st.text_input("🔍 Desired Job Title", placeholder="e.g., Data Scientist")
+        location = st.text_input("📍 Preferred Location", placeholder="e.g., New York, USA or Remote")
         category = st.selectbox("📂 Job Category", ["", "Engineering", "Marketing", "Design", "Sales", "Finance", "Healthcare", "Education", "Other"])
         user_skills_input = st.text_input("💡 Your Skills (comma-separated)", placeholder="e.g., Python, Machine Learning, SQL")
         submitted = st.form_submit_button("🚀 Get Recommendations")
-
         if submitted:
             if not job_title or not user_skills_input:
                 st.error("❌ Please enter both job title and your skills.")
                 return
-
             user_skills = [skill.strip() for skill in user_skills_input.split(",") if skill.strip()]
-            user_preferences = {
-                "job_title": job_title,
-                "location": location,
-                "category": category
-            }
-
+            user_preferences = {"job_title": job_title, "location": location, "category": category}
             with st.spinner("🔄 Fetching job recommendations..."):
-                # Fetch recommendations from all APIs (Remotive, The Muse, Indeed)
                 recommended_jobs = recommend_jobs(user_skills, user_preferences)
-
                 if recommended_jobs:
                     st.subheader("💼 Recommended Jobs:")
                     for idx, job in enumerate(recommended_jobs, 1):
-                        # Depending on the API, job data structure might differ
                         job_title_display = job.get("title") or job.get("name") or job.get("jobTitle")
                         company_display = job.get("company", {}).get("name") or job.get("company_name") or job.get("employer", {}).get("name")
                         location_display = job.get("candidate_required_location") or job.get("location") or job.get("country")
-                        salary_display = "N/A"  # Salary is removed
                         job_url = job.get("url") or job.get("redirect_url") or job.get("url_standard")
-
                         st.markdown(f"### {idx}. {job_title_display}")
                         st.markdown(f"**🏢 Company:** {company_display}")
                         st.markdown(f"**📍 Location:** {location_display}")
@@ -1268,32 +871,22 @@ def job_recommendations_module():
 
 def interview_preparation_module():
     st.header("🎤 Interview Preparation")
-
-    st.write("""
-    Prepare for your interviews with tailored mock questions and expert answers.
-    """)
-
-    # Create two columns for input fields
+    st.write("Prepare for your interviews with tailored mock questions and answers.")
     col1, col2 = st.columns(2)
     with col1:
         job_title = st.text_input("🔍 Enter the job title you're applying for:")
     with col2:
         company = st.text_input("🏢 Enter the company name:")
-
     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 to generate 50 interview questions with answers
             prompt = f"""
             Generate a list of 50 interview questions along with their answers for the position of {job_title} at {company}. Each question should be followed by a concise and professional answer.
             """
-
             try:
-                # Invoke the LLM to get questions and answers
                 qa_text = llm.invoke(prompt).content.strip()
-                # Split into question-answer pairs
                 qa_pairs = qa_text.split('\n\n')
                 st.subheader("🗣️ Mock Interview Questions and Answers:")
                 for idx, qa in enumerate(qa_pairs, 1):
@@ -1310,18 +903,12 @@ def interview_preparation_module():
 
 def personalized_learning_paths_module():
     st.header("📚 Personalized Learning Paths")
-
-    st.write("""
-    Receive tailored learning plans to help you acquire the skills needed for your desired career, complemented with curated video resources.
-    """)
-
-    # Create two columns for input fields
+    st.write("Receive tailored learning plans to help you achieve your career goals, complemented with curated video resources.")
     col1, col2 = st.columns(2)
     with col1:
-        career_goal = st.text_input("🎯 Enter your career goal (e.g., Data Scientist, Machine Learning Engineer):")
+        career_goal = st.text_input("🎯 Enter your career goal (e.g., Data Scientist):")
     with col2:
         current_skills = st.text_input("💡 Enter your current skills (comma-separated):")
-
     if st.button("🚀 Generate Learning Path"):
         if not career_goal or not current_skills:
             st.error("❌ Please enter both career goal and current skills.")
@@ -1331,21 +918,10 @@ def personalized_learning_paths_module():
             if learning_path:
                 st.subheader("📜 Your Personalized Learning Path:")
                 st.write(learning_path)
-                
-                # Assuming the learning path is divided into modules/subparts separated by newlines or numbering
-                # We'll extract subparts and embed YouTube videos for each
-                # Example format:
-                # 1. Module One
-                # 2. Module Two
-                # etc.
-
-                # Split learning path into modules
                 modules = re.split(r'\d+\.\s+', learning_path)
                 modules = [module.strip() for module in modules if module.strip()]
-                
                 st.subheader("📹 Recommended YouTube Videos for Each Module:")
                 for module in modules:
-                    # Search for long videos related to the module
                     video_urls = search_youtube_videos(query=module, max_results=2, video_duration="long")
                     if video_urls:
                         st.markdown(f"### {module}")
@@ -1357,24 +933,17 @@ def personalized_learning_paths_module():
 
 def networking_opportunities_module():
     st.header("🤝 Networking Opportunities")
-
-    st.write("""
-    Expand your professional network by connecting with relevant industry peers and joining professional groups.
-    """)
-
-    # Create two columns for input fields
+    st.write("Expand your professional network by connecting with relevant industry peers and groups.")
     col1, col2 = st.columns(2)
     with col1:
         user_skills = st.text_input("💡 Enter your key skills (comma-separated):")
     with col2:
-        industry = st.text_input("🏭 Enter your industry (e.g., Technology, Finance):")
-
+        industry = st.text_input("🏭 Enter your industry (e.g., Technology):")
     if st.button("🔍 Find Networking Opportunities"):
         if not user_skills or not industry:
             st.error("❌ Please enter both key skills and industry.")
             return
         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.
             """
@@ -1387,153 +956,46 @@ def networking_opportunities_module():
 
 def feedback_and_improvement_module():
     st.header("🗣️ Feedback and Continuous Improvement")
-
-    st.write("""
-    We value your feedback! Let us know how we can improve your experience.
-    """)
-
+    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:
-                # 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}")
+                # You can store the feedback in a database or send via email
                 st.success("✅ Thank you for your feedback!")
 
-def gamification_module():
-    st.header("🏆 Gamification and Achievements")
-
-    st.write("""
-    Stay motivated by earning badges and tracking your progress!
-    """)
-
-    # Initialize database
-    init_db()
-
-    # 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)
-    }
-
-    for achievement, earned in achievements.items():
-        if earned:
-            st.success(f"🎉 {achievement}")
-        else:
-            st.info(f"🔜 {achievement}")
-
-    # Progress Bar
-    progress = min(num_apps / 10, 1.0)  # Ensure progress is between 0.0 and 1.0
-    st.write("**Overall Progress:**")
-    st.progress(progress)
-    st.write(f"{progress * 100:.0f}% complete")
-
 def resource_library_page():
     st.header("📚 Resource Library")
-
-    st.write("""
-    Access a collection of templates and guides to enhance your job search.
-    """)
-
+    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"
-        }
+        {"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": "A checklist to ensure you cover all steps.", "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=os.path.basename(resource['file']),
-                    mime="application/octet-stream"
-                )
+                st.download_button("⬇️ Download", data=file, file_name=os.path.basename(resource['file']), mime="application/octet-stream")
         except FileNotFoundError:
             st.error(f"❌ File {resource['file']} not found. Please ensure the file is in the correct directory.")
         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
+    st.write("Have questions or need assistance? Chat with our AI-powered assistant!")
     if 'chat_history' not in st.session_state:
         st.session_state['chat_history'] = []
-
-    # User input
     user_input = st.text_input("🗨️ You:", key="user_input")
-
     if st.button("Send"):
         if user_input:
-            # Append user message to chat history
             st.session_state['chat_history'].append({"message": user_input, "is_user": True})
             prompt = f"""
             You are a helpful assistant for a Job Application Assistant app. Answer the user's query based on the following context:
@@ -1541,17 +1003,13 @@ def chatbot_support_page():
             {user_input}
             """
             try:
-                # Invoke the LLM to get a response
                 response = llm.invoke(prompt)
                 assistant_message = response.content.strip()
-                # Append assistant response to chat history
                 st.session_state['chat_history'].append({"message": assistant_message, "is_user": False})
             except Exception as e:
                 error_message = "❌ Sorry, I encountered an error while processing your request."
                 st.session_state['chat_history'].append({"message": error_message, "is_user": False})
                 st.error(f"❌ Error in chatbot: {e}")
-
-    # Display chat history using streamlit-chat
     for chat in st.session_state['chat_history']:
         if chat['is_user']:
             message(chat['message'], is_user=True, avatar_style="thumbs")
@@ -1560,65 +1018,44 @@ def chatbot_support_page():
 
 def help_page():
     st.header("❓ Help & FAQ")
-
     with st.expander("🛠️ How do I generate a cover letter?"):
-        st.write("""
-            To generate a cover letter, navigate to the **Cover Letter Generator** section, enter the job link, upload your resume, and click on **Generate Cover Letter**.
-        """)
-
+        st.write("Navigate to the **Cover Letter Generator** section, enter the job link, upload your resume, and click **Generate Cover Letter**.")
     with st.expander("📋 How do I track my applications?"):
-        st.write("""
-            Use the **Application Tracking Dashboard** to add new applications, update their status, and monitor deadlines.
-        """)
-
+        st.write("Use the **Application Tracking Dashboard** to add and manage your job applications.")
     with st.expander("📄 How can I optimize my resume?"):
-        st.write("""
-            Upload your resume in the **Resume Analysis** section to extract skills and receive optimization suggestions.
-        """)
-
+        st.write("Upload your resume in the **Resume Analysis** section to extract skills and receive optimization suggestions.")
     with st.expander("📥 How do I import my applications?"):
-        st.write("""
-            In the **Application Tracking Dashboard**, use the **Import Applications** section to upload a CSV file containing your applications. Ensure the CSV has the required columns.
-        """)
-
+        st.write("In the **Application Tracking Dashboard**, use the **Import Applications** section to upload a CSV file with the required columns.")
     with st.expander("🗣️ How do I provide feedback?"):
-        st.write("""
-            Navigate to the **Feedback and Continuous Improvement** section, fill out the form, and submit your feedback.
-        """)
+        st.write("Go to the **Feedback** section, fill out the form, and submit your feedback.")
 
 # -------------------------------
-# Main App Function
+# Main Application
 # -------------------------------
-
 def main_app():
-    # Apply a consistent theme or style
     st.markdown(
         """
         <style>
-        .reportview-container {
-            background-color: #f5f5f5;
-        }
-        .sidebar .sidebar-content {
-            background-image: linear-gradient(#2e7bcf, #2e7bcf);
-            color: white;
-        }
+        .reportview-container { background-color: #f5f5f5; }
+        .sidebar .sidebar-content { background-image: linear-gradient(#2e7bcf, #2e7bcf); color: white; }
         </style>
         """,
         unsafe_allow_html=True
     )
-
-    # Sidebar Navigation using streamlit_option_menu
     with st.sidebar:
         selected = option_menu(
             menu_title="📂 Main Menu",
-            options=["Email Generator", "Cover Letter Generator", "Resume Analysis", "Application Tracking",
-                     "Job Recommendations", "Labor Market Insights", "Interview Preparation", "Personalized Learning Paths",
-                     "Networking Opportunities", "Feedback", "Gamification", "Resource Library",
-                     "Success Stories", "Chatbot Support", "Help"],
-            icons=["envelope", "file-earmark-text", "file-person", "briefcase",
-                   "search", "bar-chart-line", "microphone", "book",
-                   "people", "chat-left-text", "trophy", "collection",
-                   "star", "robot", "question-circle"],
+            options=[
+                "Email Generator", "Cover Letter Generator", "Resume Analysis",
+                "Application Tracking", "Job Recommendations", "Interview Preparation",
+                "Personalized Learning Paths", "Networking Opportunities",
+                "Feedback", "Resource Library", "Chatbot Support", "Help"
+            ],
+            icons=[
+                "envelope", "file-earmark-text", "file-person", "briefcase",
+                "search", "microphone", "book", "people",
+                "chat-left-text", "collection", "robot", "question-circle"
+            ],
             menu_icon="cast",
             default_index=0,
             styles={
@@ -1628,8 +1065,6 @@ def main_app():
                 "nav-link-selected": {"background-color": "#1e5aab"},
             }
         )
-
-    # Route to the selected page
     if selected == "Email Generator":
         email_generator_page()
     elif selected == "Cover Letter Generator":
@@ -1640,8 +1075,6 @@ def main_app():
         application_tracking_dashboard()
     elif selected == "Job Recommendations":
         job_recommendations_module()
-    elif selected == "Labor Market Insights":
-        labor_market_insights_module()
     elif selected == "Interview Preparation":
         interview_preparation_module()
     elif selected == "Personalized Learning Paths":
@@ -1650,17 +1083,12 @@ def main_app():
         networking_opportunities_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()
     elif selected == "Help":
         help_page()
 
-
 if __name__ == "__main__":
     main_app()