Upload 531 files

.gitattributes

@@ -33,3 +33,31 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/cairo.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/deflate.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/expat.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/fontconfig-1.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/freetype.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/iconv.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/jpeg8.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/lcms2.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/Lerc.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/libcrypto-3-x64.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/libcurl.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/libexpat.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/liblzma.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/libpng16.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/libssh2.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/libtiff.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/libzstd.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/openjp2.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/pdftocairo.exe filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/pdftohtml.exe filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/pixman-1-0.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/poppler-cpp.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/poppler-glib.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/poppler.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/tiff.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/zstd.dll filter=lfs diff=lfs merge=lfs -text
+poppler/poppler-24.08.0/Library/bin/zstd.exe filter=lfs diff=lfs merge=lfs -text
+resume_data.db filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Parthib karak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

config/courses.py

@@ -0,0 +1,181 @@
+# Course recommendations organized by job categories
+COURSES_BY_CATEGORY = {
+    "Software Development and Engineering": {
+        "Frontend Developer": [
+            ["Frontend Web Development Bootcamp [Free]", "https://youtu.be/zJSY8tbf_ys"],
+            ["React Complete Course 2024 [Free]", "https://youtu.be/bMknfKXIFA8"],
+            ["The Web Developer Bootcamp", "https://www.udemy.com/course/the-web-developer-bootcamp/"],
+            ["Frontend Masters Complete Path", "https://frontendmasters.com/learn/beginner/"],
+            ["Advanced CSS and Sass", "https://www.udemy.com/course/advanced-css-and-sass/"]
+        ],
+        "Backend Developer": [
+            ["Node.js Tutorial for Beginners [Free]", "https://youtu.be/TlB_eWDSMt4"],
+            ["Python Django Full Course [Free]", "https://youtu.be/o0XbHvKxw7Y"],
+            ["Complete Python Developer in 2024", "https://www.udemy.com/course/complete-python-developer-zero-to-mastery/"],
+            ["Java Spring Boot Complete Course", "https://www.udemy.com/course/spring-hibernate-tutorial/"],
+            ["The Complete Node.js Developer Course", "https://www.udemy.com/course/the-complete-nodejs-developer-course-2/"]
+        ],
+        "Full Stack Developer": [
+            ["Full Stack Development Course [Free]", "https://youtu.be/nu_pCVPKzTk"],
+            ["The Complete 2024 Web Development Bootcamp", "https://www.udemy.com/course/the-complete-web-development-bootcamp/"],
+            ["Full Stack Engineer Career Path", "https://www.codecademy.com/learn/paths/full-stack-engineer-career-path"],
+            ["MERN Stack Front To Back", "https://www.udemy.com/course/mern-stack-front-to-back/"],
+            ["Full Stack Development with React & Node.js", "https://www.udemy.com/course/full-stack-react-node/"]
+        ],
+        "Mobile App Developer": [
+            ["Flutter & Dart Complete Course [Free]", "https://youtu.be/VPvVD8t02U8"],
+            ["iOS & Swift Complete iOS App Development", "https://www.udemy.com/course/ios-13-app-development-bootcamp/"],
+            ["Android Development with Kotlin", "https://www.udacity.com/course/android-kotlin-developer-nanodegree--nd940"],
+            ["React Native - The Practical Guide", "https://www.udemy.com/course/react-native-the-practical-guide/"],
+            ["Flutter & Firebase: Build a Complete App", "https://www.udemy.com/course/flutter-firebase-tutorial-build-5-social-media-apps/"]
+        ],
+        "Game Developer": [
+            ["Unity Game Development [Free]", "https://youtu.be/gB1F9G0JXOo"],
+            ["Unreal Engine 5 C++ Developer", "https://www.udemy.com/course/unrealcourse/"],
+            ["Complete C# Unity Game Developer 2D", "https://www.udemy.com/course/unitycourse/"],
+            ["Unity Certified Programmer Exam Preparation", "https://www.udemy.com/course/unity-advance-essentials-n/"],
+            ["Game Design and Development Specialization", "https://www.coursera.org/specializations/game-design-and-development"]
+        ]
+    },
+    "Data Science and Analytics": {
+        "Data Scientist": [
+            ["Data Science Full Course [Free]", "https://youtu.be/_V8eKsto3Ug"],
+            ["IBM Data Science Professional Certificate", "https://www.coursera.org/professional-certificates/ibm-data-science"],
+            ["Data Science Career Path", "https://www.codecademy.com/learn/paths/data-science"],
+            ["Applied Data Science with Python", "https://www.coursera.org/specializations/data-science-python"],
+            ["Complete Data Science Bootcamp", "https://www.udemy.com/course/the-data-science-course-complete-data-science-bootcamp/"]
+        ],
+        "Data Analyst": [
+            ["Data Analytics Full Course [Free]", "https://youtu.be/ua-CiDNNj30"],
+            ["Google Data Analytics Professional Certificate", "https://www.coursera.org/professional-certificates/google-data-analytics"],
+            ["Data Analyst with Python", "https://www.datacamp.com/tracks/data-analyst-with-python"],
+            ["Business Analytics Specialization", "https://www.coursera.org/specializations/business-analytics"],
+            ["Data Analysis with Pandas and Python", "https://www.udemy.com/course/data-analysis-with-pandas/"]
+        ],
+        "Machine Learning Engineer": [
+            ["Machine Learning Full Course [Free]", "https://youtu.be/jGwO_UgTS7I"],
+            ["Deep Learning Specialization", "https://www.coursera.org/specializations/deep-learning"],
+            ["Machine Learning Engineer Nanodegree", "https://www.udacity.com/course/machine-learning-engineer-nanodegree--nd009t"],
+            ["TensorFlow Developer Certificate", "https://www.tensorflow.org/certificate"],
+            ["Complete Machine Learning & Data Science Bootcamp", "https://www.udemy.com/course/complete-machine-learning-and-data-science-zero-to-mastery/"]
+        ]
+    },
+    "Cloud Computing and DevOps": {
+        "Cloud Architect": [
+            ["AWS Cloud Practitioner [Free]", "https://youtu.be/3hLmDS179YE"],
+            ["AWS Solutions Architect Professional", "https://www.udemy.com/course/aws-solutions-architect-professional/"],
+            ["Google Cloud Architect Professional Certificate", "https://www.coursera.org/professional-certificates/gcp-cloud-architect"],
+            ["Microsoft Azure Architect Technologies", "https://learn.microsoft.com/en-us/certifications/azure-solutions-architect/"],
+            ["Cloud Architecture with Google Cloud", "https://www.coursera.org/professional-certificates/gcp-cloud-architect"]
+        ],
+        "DevOps Engineer": [
+            ["DevOps Engineering Course [Free]", "https://youtu.be/j5Zsa_eOXeY"],
+            ["DevOps Engineer Masters Program", "https://www.simplilearn.com/cloud-computing/devops-engineer-masters-program-training"],
+            ["Docker and Kubernetes: The Complete Guide", "https://www.udemy.com/course/docker-and-kubernetes-the-complete-guide/"],
+            ["GitLab CI: The Complete Guide", "https://www.udemy.com/course/gitlab-ci-pipelines-ci-cd-and-devops-for-beginners/"],
+            ["Jenkins: The Complete Guide", "https://www.udemy.com/course/jenkins-from-zero-to-hero/"]
+        ],
+        "Site Reliability Engineer": [
+            ["SRE Course [Free]", "https://youtu.be/uTEL8Ff1Zvk"],
+            ["Site Reliability Engineering: Measuring and Managing Reliability", "https://www.coursera.org/learn/site-reliability-engineering-slos"],
+            ["Linux System Administration", "https://www.udemy.com/course/linux-administration-bootcamp/"],
+            ["Monitoring and Alerting with Prometheus", "https://www.udemy.com/course/monitoring-and-alerting-with-prometheus/"],
+            ["Advanced System Administration", "https://www.linkedin.com/learning/paths/advance-your-skills-as-a-linux-system-administrator"]
+        ]
+    },
+    "Cybersecurity": {
+        "Security Analyst": [
+            ["Cyber Security Full Course [Free]", "https://youtu.be/nzZkKoREEGo"],
+            ["CompTIA Security+ Certification", "https://www.comptia.org/certifications/security"],
+            ["Certified Information Systems Security Professional (CISSP)", "https://www.isc2.org/Certifications/CISSP"],
+            ["IBM Cybersecurity Analyst Professional Certificate", "https://www.coursera.org/professional-certificates/ibm-cybersecurity-analyst"],
+            ["The Complete Cyber Security Course", "https://www.udemy.com/course/the-complete-internet-security-privacy-course-volume-1/"]
+        ],
+        "Penetration Tester": [
+            ["Ethical Hacking Course [Free]", "https://youtu.be/3Kq1MIfTWCE"],
+            ["Certified Ethical Hacker (CEH)", "https://www.eccouncil.org/programs/certified-ethical-hacker-ceh/"],
+            ["Complete Ethical Hacking Bootcamp", "https://www.udemy.com/course/complete-ethical-hacking-bootcamp-zero-to-mastery/"],
+            ["Web Security & Bug Bounty", "https://www.udemy.com/course/web-security-bug-bounty-learn-penetration-testing/"],
+            ["Advanced Penetration Testing", "https://www.offensive-security.com/pwk-oscp/"]
+        ]
+    },
+    "UI/UX Design": {
+        "UI Designer": [
+            ["UI Design Course [Free]", "https://youtu.be/c9Wg6Cb_YlU"],
+            ["Google UX Design Professional Certificate", "https://www.coursera.org/professional-certificates/google-ux-design"],
+            ["UI Design Bootcamp", "https://www.udemy.com/course/ui-design-bootcamp/"],
+            ["Advanced UI Design Course", "https://www.udacity.com/course/ui-design--ud511"],
+            ["Design System Course", "https://www.designsystems.com/"]
+        ],
+        "UX Designer": [
+            ["UX Design Course [Free]", "https://youtu.be/uL2aArZGqzk"],
+            ["UX Design Professional Certificate", "https://www.coursera.org/professional-certificates/google-ux-design"],
+            ["User Experience Design Bootcamp", "https://www.udemy.com/course/user-experience-design-fundamentals/"],
+            ["UX Research & Strategy", "https://www.interaction-design.org/courses"],
+            ["Advanced UX Methods", "https://www.nngroup.com/courses/"]
+        ]
+    },
+    "Project Management": {
+        "Project Manager": [
+            ["Project Management Basics [Free]", "https://youtu.be/H0_yKBitO8M"],
+            ["PMP Certification Prep", "https://www.udemy.com/course/pmp-pmbok6-35-pdus/"],
+            ["Google Project Management Certificate", "https://www.coursera.org/professional-certificates/google-project-management"],
+            ["Agile with Atlassian Jira", "https://www.coursera.org/learn/agile-atlassian-jira"],
+            ["Scrum Master Certification", "https://www.scrum.org/professional-scrum-certifications"]
+        ],
+        "Product Manager": [
+            ["Product Management Course [Free]", "https://youtu.be/lYZYB9VWaeI"],
+            ["Product Management Certification", "https://www.udemy.com/course/become-a-product-manager-learn-the-skills-get-a-job/"],
+            ["Digital Product Management", "https://www.coursera.org/specializations/uva-darden-digital-product-management"],
+            ["Product Analytics", "https://www.udacity.com/course/product-manager-nanodegree--nd036"],
+            ["Agile Product Management", "https://www.scrum.org/professional-scrum-product-owner-certifications"]
+        ]
+    }
+}
+
+# Helper videos for resume and interview preparation
+RESUME_VIDEOS = {
+    "Resume Writing": [
+        ["Resume Writing Masterclass [Free]", "https://youtu.be/Tt08KmFfIYQ"],
+        ["How to Write a Professional Resume in 2024", "https://youtu.be/y8YH0Qbu5h4"],
+        ["Resume Tips from a Hiring Manager", "https://youtu.be/u75hUSShvnc"],
+        ["ATS-Friendly Resume Guide", "https://youtu.be/BYUy1yvjHxE"]
+    ],
+    "Resume Design": [
+        ["Create a Modern Resume in Word", "https://youtu.be/3agP4x8LYFM"],
+        ["Professional Resume Design Tips", "https://youtu.be/KFaugkGVeNQ"],
+        ["Resume Templates and Formatting", "https://youtu.be/GyjzOKdaioU"]
+    ]
+}
+
+INTERVIEW_VIDEOS = {
+    "Technical Interviews": [
+        ["Coding Interview Preparation [Free]", "https://youtu.be/HG68Ymazo18"],
+        ["System Design Interview Guide", "https://youtu.be/BOvAAoxM4vg"],
+        ["Data Structures & Algorithms Interview", "https://youtu.be/KukmClH1KoA"]
+    ],
+    "Behavioral Interviews": [
+        ["STAR Method Explained", "https://youtu.be/7_aAicmPB3A"],
+        ["Common Behavioral Questions", "https://youtu.be/1mHjMNZZvFo"],
+        ["Interview Body Language Tips", "https://youtu.be/WfdtKbAJOmE"]
+    ],
+    "Interview Tips": [
+        ["Salary Negotiation Tips", "https://youtu.be/IBjM-F56qS0"],
+        ["Questions to Ask Interviewers", "https://youtu.be/4tYoVx0QoN0"],
+        ["Remote Interview Best Practices", "https://youtu.be/Ge0Udbws1kc"]
+    ]
+}
+
+def get_courses_for_role(role_name):
+    """Helper function to get courses for a specific role"""
+    for category, roles in COURSES_BY_CATEGORY.items():
+        if role_name in roles:
+            return roles[role_name]
+    return None
+
+def get_category_for_role(role_name):
+    """Helper function to get the category for a specific role"""
+    for category, roles in COURSES_BY_CATEGORY.items():
+        if role_name in roles:
+            return category
+    return None

config/database.py

@@ -0,0 +1,532 @@
+import sqlite3
+from datetime import datetime
+
+def get_database_connection():
+    """Create and return a database connection"""
+    conn = sqlite3.connect('resume_data.db')
+    return conn
+
+def init_database():
+    """Initialize database tables"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    # Create resume_data table
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS resume_data (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        email TEXT NOT NULL,
+        phone TEXT NOT NULL,
+        linkedin TEXT,
+        github TEXT,
+        portfolio TEXT,
+        summary TEXT,
+        target_role TEXT,
+        target_category TEXT,
+        education TEXT,
+        experience TEXT,
+        projects TEXT,
+        skills TEXT,
+        template TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )
+    ''')
+    
+    # Create resume_skills table
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS resume_skills (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        resume_id INTEGER,
+        skill_name TEXT NOT NULL,
+        skill_category TEXT NOT NULL,
+        proficiency_score REAL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (resume_id) REFERENCES resume_data (id)
+    )
+    ''')
+    
+    # Create resume_analysis table
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS resume_analysis (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        resume_id INTEGER,
+        ats_score REAL,
+        keyword_match_score REAL,
+        format_score REAL,
+        section_score REAL,
+        missing_skills TEXT,
+        recommendations TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (resume_id) REFERENCES resume_data (id)
+    )
+    ''')
+    
+    # Create admin_logs table
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS admin_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        admin_email TEXT NOT NULL,
+        action TEXT NOT NULL,
+        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )
+    ''')
+    
+    # Create admin table
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS admin (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        email TEXT NOT NULL UNIQUE,
+        password TEXT NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    )
+    ''')
+    
+    conn.commit()
+    conn.close()
+
+def save_resume_data(data):
+    """Save resume data to database"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        personal_info = data.get('personal_info', {})
+        
+        cursor.execute('''
+        INSERT INTO resume_data (
+            name, email, phone, linkedin, github, portfolio,
+            summary, target_role, target_category, education, 
+            experience, projects, skills, template
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ''', (
+            personal_info.get('full_name', ''),
+            personal_info.get('email', ''),
+            personal_info.get('phone', ''),
+            personal_info.get('linkedin', ''),
+            personal_info.get('github', ''),
+            personal_info.get('portfolio', ''),
+            data.get('summary', ''),
+            data.get('target_role', ''),
+            data.get('target_category', ''),
+            str(data.get('education', [])),
+            str(data.get('experience', [])),
+            str(data.get('projects', [])),
+            str(data.get('skills', [])),
+            data.get('template', '')
+        ))
+        
+        conn.commit()
+        return cursor.lastrowid
+    except Exception as e:
+        print(f"Error saving resume data: {str(e)}")
+        conn.rollback()
+        return None
+    finally:
+        conn.close()
+
+def save_analysis_data(resume_id, analysis):
+    """Save resume analysis data"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        cursor.execute('''
+        INSERT INTO resume_analysis (
+            resume_id, ats_score, keyword_match_score,
+            format_score, section_score, missing_skills,
+            recommendations
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        ''', (
+            resume_id,
+            float(analysis.get('ats_score', 0)),
+            float(analysis.get('keyword_match_score', 0)),
+            float(analysis.get('format_score', 0)),
+            float(analysis.get('section_score', 0)),
+            analysis.get('missing_skills', ''),
+            analysis.get('recommendations', '')
+        ))
+        
+        conn.commit()
+    except Exception as e:
+        print(f"Error saving analysis data: {str(e)}")
+        conn.rollback()
+    finally:
+        conn.close()
+
+def get_resume_stats():
+    """Get statistics about resumes"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        # Get total resumes
+        cursor.execute('SELECT COUNT(*) FROM resume_data')
+        total_resumes = cursor.fetchone()[0]
+        
+        # Get average ATS score
+        cursor.execute('SELECT AVG(ats_score) FROM resume_analysis')
+        avg_ats_score = cursor.fetchone()[0] or 0
+        
+        # Get recent activity
+        cursor.execute('''
+        SELECT name, target_role, created_at 
+        FROM resume_data 
+        ORDER BY created_at DESC 
+        LIMIT 5
+        ''')
+        recent_activity = cursor.fetchall()
+        
+        return {
+            'total_resumes': total_resumes,
+            'avg_ats_score': round(avg_ats_score, 2),
+            'recent_activity': recent_activity
+        }
+    except Exception as e:
+        print(f"Error getting resume stats: {str(e)}")
+        return None
+    finally:
+        conn.close()
+
+def log_admin_action(admin_email, action):
+    """Log admin login/logout actions"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        cursor.execute('''
+        INSERT INTO admin_logs (admin_email, action)
+        VALUES (?, ?)
+        ''', (admin_email, action))
+        conn.commit()
+    except Exception as e:
+        print(f"Error logging admin action: {str(e)}")
+    finally:
+        conn.close()
+
+def get_admin_logs():
+    """Get all admin login/logout logs"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        cursor.execute('''
+        SELECT admin_email, action, timestamp
+        FROM admin_logs
+        ORDER BY timestamp DESC
+        ''')
+        return cursor.fetchall()
+    except Exception as e:
+        print(f"Error getting admin logs: {str(e)}")
+        return []
+    finally:
+        conn.close()
+
+def get_all_resume_data():
+    """Get all resume data for admin dashboard"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        # Get resume data joined with analysis data
+        cursor.execute('''
+        SELECT 
+            r.id,
+            r.name,
+            r.email,
+            r.phone,
+            r.linkedin,
+            r.github,
+            r.portfolio,
+            r.target_role,
+            r.target_category,
+            r.created_at,
+            a.ats_score,
+            a.keyword_match_score,
+            a.format_score,
+            a.section_score
+        FROM resume_data r
+        LEFT JOIN resume_analysis a ON r.id = a.resume_id
+        ORDER BY r.created_at DESC
+        ''')
+        return cursor.fetchall()
+    except Exception as e:
+        print(f"Error getting resume data: {str(e)}")
+        return []
+    finally:
+        conn.close()
+
+def verify_admin(email, password):
+    """Verify admin credentials"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        cursor.execute('SELECT * FROM admin WHERE email = ? AND password = ?', (email, password))
+        result = cursor.fetchone()
+        return bool(result)
+    except Exception as e:
+        print(f"Error verifying admin: {str(e)}")
+        return False
+    finally:
+        conn.close()
+
+def add_admin(email, password):
+    """Add a new admin"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        cursor.execute('INSERT INTO admin (email, password) VALUES (?, ?)', (email, password))
+        conn.commit()
+        return True
+    except Exception as e:
+        print(f"Error adding admin: {str(e)}")
+        return False
+    finally:
+        conn.close()
+
+def save_ai_analysis_data(resume_id, analysis_data):
+    """Save AI analysis data to the database"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        # Check if the ai_analysis table exists
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS ai_analysis (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                resume_id INTEGER,
+                model_used TEXT,
+                resume_score INTEGER,
+                job_role TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (resume_id) REFERENCES resume_data (id)
+            )
+        """)
+        
+        # Insert the analysis data
+        cursor.execute("""
+            INSERT INTO ai_analysis (
+                resume_id, model_used, resume_score, job_role
+            ) VALUES (?, ?, ?, ?)
+        """, (
+            resume_id,
+            analysis_data.get('model_used', ''),
+            analysis_data.get('resume_score', 0),
+            analysis_data.get('job_role', '')
+        ))
+        
+        conn.commit()
+        return cursor.lastrowid
+    except Exception as e:
+        print(f"Error saving AI analysis data: {e}")
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+def get_ai_analysis_stats():
+    """Get statistics about AI analyzer usage"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        # Check if the ai_analysis table exists
+        cursor.execute("""
+            SELECT name FROM sqlite_master WHERE type='table' AND name='ai_analysis'
+        """)
+        
+        if not cursor.fetchone():
+            return {
+                "total_analyses": 0,
+                "model_usage": [],
+                "average_score": 0,
+                "top_job_roles": []
+            }
+        
+        # Get total number of analyses
+        cursor.execute("SELECT COUNT(*) FROM ai_analysis")
+        total_analyses = cursor.fetchone()[0]
+        
+        # Get model usage statistics
+        cursor.execute("""
+            SELECT model_used, COUNT(*) as count
+            FROM ai_analysis
+            GROUP BY model_used
+            ORDER BY count DESC
+        """)
+        model_usage = [{"model": row[0], "count": row[1]} for row in cursor.fetchall()]
+        
+        # Get average resume score
+        cursor.execute("SELECT AVG(resume_score) FROM ai_analysis")
+        average_score = cursor.fetchone()[0] or 0
+        
+        # Get top job roles
+        cursor.execute("""
+            SELECT job_role, COUNT(*) as count
+            FROM ai_analysis
+            GROUP BY job_role
+            ORDER BY count DESC
+            LIMIT 5
+        """)
+        top_job_roles = [{"role": row[0], "count": row[1]} for row in cursor.fetchall()]
+        
+        return {
+            "total_analyses": total_analyses,
+            "model_usage": model_usage,
+            "average_score": round(average_score, 1),
+            "top_job_roles": top_job_roles
+        }
+    except Exception as e:
+        print(f"Error getting AI analysis stats: {e}")
+        return {
+            "total_analyses": 0,
+            "model_usage": [],
+            "average_score": 0,
+            "top_job_roles": []
+        }
+    finally:
+        conn.close()
+
+def get_detailed_ai_analysis_stats():
+    """Get detailed statistics about AI analyzer usage including daily trends"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        # Check if the ai_analysis table exists
+        cursor.execute("""
+            SELECT name FROM sqlite_master WHERE type='table' AND name='ai_analysis'
+        """)
+        
+        if not cursor.fetchone():
+            return {
+                "total_analyses": 0,
+                "model_usage": [],
+                "average_score": 0,
+                "top_job_roles": [],
+                "daily_trend": [],
+                "score_distribution": [],
+                "recent_analyses": []
+            }
+        
+        # Get total number of analyses
+        cursor.execute("SELECT COUNT(*) FROM ai_analysis")
+        total_analyses = cursor.fetchone()[0]
+        
+        # Get model usage statistics
+        cursor.execute("""
+            SELECT model_used, COUNT(*) as count
+            FROM ai_analysis
+            GROUP BY model_used
+            ORDER BY count DESC
+        """)
+        model_usage = [{"model": row[0], "count": row[1]} for row in cursor.fetchall()]
+        
+        # Get average resume score
+        cursor.execute("SELECT AVG(resume_score) FROM ai_analysis")
+        average_score = cursor.fetchone()[0] or 0
+        
+        # Get top job roles
+        cursor.execute("""
+            SELECT job_role, COUNT(*) as count
+            FROM ai_analysis
+            GROUP BY job_role
+            ORDER BY count DESC
+            LIMIT 5
+        """)
+        top_job_roles = [{"role": row[0], "count": row[1]} for row in cursor.fetchall()]
+        
+        # Get daily trend for the last 7 days
+        cursor.execute("""
+            SELECT DATE(created_at) as date, COUNT(*) as count
+            FROM ai_analysis
+            WHERE created_at >= date('now', '-7 days')
+            GROUP BY DATE(created_at)
+            ORDER BY date
+        """)
+        daily_trend = [{"date": row[0], "count": row[1]} for row in cursor.fetchall()]
+        
+        # Get score distribution
+        score_ranges = [
+            {"min": 0, "max": 20, "range": "0-20"},
+            {"min": 21, "max": 40, "range": "21-40"},
+            {"min": 41, "max": 60, "range": "41-60"},
+            {"min": 61, "max": 80, "range": "61-80"},
+            {"min": 81, "max": 100, "range": "81-100"}
+        ]
+        
+        score_distribution = []
+        for range_info in score_ranges:
+            cursor.execute("""
+                SELECT COUNT(*) FROM ai_analysis 
+                WHERE resume_score >= ? AND resume_score <= ?
+            """, (range_info["min"], range_info["max"]))
+            count = cursor.fetchone()[0]
+            score_distribution.append({"range": range_info["range"], "count": count})
+        
+        # Get recent analyses
+        cursor.execute("""
+            SELECT model_used, resume_score, job_role, datetime(created_at) as date
+            FROM ai_analysis
+            ORDER BY created_at DESC
+            LIMIT 5
+        """)
+        recent_analyses = [
+            {
+                "model": row[0],
+                "score": row[1],
+                "job_role": row[2],
+                "date": row[3]
+            } for row in cursor.fetchall()
+        ]
+        
+        return {
+            "total_analyses": total_analyses,
+            "model_usage": model_usage,
+            "average_score": round(average_score, 1),
+            "top_job_roles": top_job_roles,
+            "daily_trend": daily_trend,
+            "score_distribution": score_distribution,
+            "recent_analyses": recent_analyses
+        }
+    except Exception as e:
+        print(f"Error getting detailed AI analysis stats: {e}")
+        return {
+            "total_analyses": 0,
+            "model_usage": [],
+            "average_score": 0,
+            "top_job_roles": [],
+            "daily_trend": [],
+            "score_distribution": [],
+            "recent_analyses": []
+        }
+    finally:
+        conn.close()
+
+def reset_ai_analysis_stats():
+    """Reset AI analysis statistics by truncating the ai_analysis table"""
+    conn = get_database_connection()
+    cursor = conn.cursor()
+    
+    try:
+        # Check if the ai_analysis table exists
+        cursor.execute("""
+            SELECT name FROM sqlite_master WHERE type='table' AND name='ai_analysis'
+        """)
+        
+        if not cursor.fetchone():
+            return {"success": False, "message": "AI analysis table does not exist"}
+        
+        # Delete all records from the ai_analysis table
+        cursor.execute("DELETE FROM ai_analysis")
+        conn.commit()
+        
+        return {"success": True, "message": "AI analysis statistics have been reset successfully"}
+    except Exception as e:
+        conn.rollback()
+        print(f"Error resetting AI analysis stats: {e}")
+        return {"success": False, "message": f"Error resetting AI analysis statistics: {str(e)}"}
+    finally:
+        conn.close()

config/job_roles.py

@@ -0,0 +1,167 @@
+JOB_ROLES = {
+    "Software Development and Engineering": {
+        "Frontend Developer": {
+            "required_skills": ["HTML", "CSS", "JavaScript", "React", "Angular", "Vue.js", "UI/UX", "Responsive Design"],
+            "description": "Create user interfaces and implement visual elements",
+            "sections": ["Technical Skills", "Projects", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["HTML5", "CSS3", "JavaScript", "React/Angular/Vue", "TypeScript", "Git"],
+                "soft": ["Communication", "Problem-solving", "Attention to detail", "Creativity"]
+            }
+        },
+        "Backend Developer": {
+            "required_skills": ["Python", "Java", "Node.js", "SQL", "APIs", "Django", "Flask", "Database Design"],
+            "description": "Build server-side logic and databases",
+            "sections": ["Technical Skills", "System Architecture", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["Python/Java/Node.js", "SQL", "RESTful APIs", "Microservices", "Docker"],
+                "soft": ["Analytical thinking", "Problem-solving", "Team collaboration"]
+            }
+        },
+        "Full Stack Developer": {
+            "required_skills": ["Frontend Tech", "Backend Tech", "Databases", "DevOps", "System Design", "APIs"],
+            "description": "Handle both client and server-side development",
+            "sections": ["Technical Skills", "Full Stack Projects", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["Frontend & Backend technologies", "Database design", "API development", "DevOps"],
+                "soft": ["Versatility", "Project management", "Communication"]
+            }
+        },
+        "Mobile App Developer": {
+            "required_skills": ["Swift", "Kotlin", "React Native", "Flutter", "Mobile UI/UX", "App Store Deployment"],
+            "description": "Develop mobile applications for iOS and Android platforms",
+            "sections": ["Technical Skills", "Mobile Projects", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["iOS/Android Development", "Cross-platform frameworks", "Mobile UI/UX", "App Performance"],
+                "soft": ["User-centric thinking", "Problem-solving", "Attention to detail"]
+            }
+        },
+        "Game Developer": {
+            "required_skills": ["Unity", "Unreal Engine", "C++", "C#", "3D Graphics", "Game Physics"],
+            "description": "Create engaging and interactive games",
+            "sections": ["Technical Skills", "Game Projects", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["Game Engines", "Graphics Programming", "Physics Simulation", "Multiplayer"],
+                "soft": ["Creativity", "Problem-solving", "Team collaboration"]
+            }
+        }
+    },
+    "Data Science and Analytics": {
+        "Data Scientist": {
+            "required_skills": ["Python", "R", "Machine Learning", "Statistics", "SQL", "Deep Learning"],
+            "description": "Analyze complex data sets to find patterns",
+            "sections": ["Technical Skills", "Projects", "Research", "Education"],
+            "recommended_skills": {
+                "technical": ["Python", "R", "Machine Learning", "Statistical Analysis", "Big Data"],
+                "soft": ["Analytical thinking", "Research", "Problem-solving"]
+            }
+        },
+        "Data Analyst": {
+            "required_skills": ["SQL", "Excel", "Python", "Data Visualization", "Statistics"],
+            "description": "Transform data into insights",
+            "sections": ["Technical Skills", "Analysis Projects", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["SQL", "Excel", "Python", "Tableau/Power BI", "Statistical Analysis"],
+                "soft": ["Data interpretation", "Communication", "Attention to detail"]
+            }
+        },
+        "Machine Learning Engineer": {
+            "required_skills": ["Python", "TensorFlow", "PyTorch", "MLOps", "Deep Learning"],
+            "description": "Build and deploy machine learning models",
+            "sections": ["Technical Skills", "ML Projects", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["Machine Learning", "Deep Learning", "MLOps", "Model Deployment"],
+                "soft": ["Research", "Problem-solving", "Critical thinking"]
+            }
+        }
+    },
+    "Cloud Computing and DevOps": {
+        "Cloud Architect": {
+            "required_skills": ["AWS", "Azure", "GCP", "Infrastructure as Code", "Security"],
+            "description": "Design and manage cloud infrastructure",
+            "sections": ["Technical Skills", "Cloud Projects", "Work Experience", "Certifications"],
+            "recommended_skills": {
+                "technical": ["Cloud Platforms", "Security", "Networking", "Cost Optimization"],
+                "soft": ["Strategic thinking", "Problem-solving", "Communication"]
+            }
+        },
+        "DevOps Engineer": {
+            "required_skills": ["Docker", "Kubernetes", "CI/CD", "Automation", "Monitoring"],
+            "description": "Implement DevOps practices and tools",
+            "sections": ["Technical Skills", "DevOps Projects", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["Containerization", "Orchestration", "CI/CD", "Infrastructure as Code"],
+                "soft": ["Automation mindset", "Problem-solving", "Team collaboration"]
+            }
+        },
+        "Site Reliability Engineer": {
+            "required_skills": ["Linux", "Monitoring", "Automation", "Performance Tuning", "Incident Response"],
+            "description": "Ensure system reliability and performance",
+            "sections": ["Technical Skills", "SRE Projects", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["System Administration", "Monitoring", "Automation", "Incident Management"],
+                "soft": ["Problem-solving", "Communication", "Critical thinking"]
+            }
+        }
+    },
+    "Cybersecurity": {
+        "Security Analyst": {
+            "required_skills": ["Network Security", "Threat Detection", "Security Tools", "Incident Response"],
+            "description": "Monitor and protect against security threats",
+            "sections": ["Technical Skills", "Security Projects", "Work Experience", "Certifications"],
+            "recommended_skills": {
+                "technical": ["Security Tools", "Threat Analysis", "Incident Response", "Compliance"],
+                "soft": ["Analytical thinking", "Attention to detail", "Communication"]
+            }
+        },
+        "Penetration Tester": {
+            "required_skills": ["Ethical Hacking", "Security Tools", "Network Security", "Web Security"],
+            "description": "Test systems for security vulnerabilities",
+            "sections": ["Technical Skills", "Security Projects", "Work Experience", "Certifications"],
+            "recommended_skills": {
+                "technical": ["Penetration Testing", "Security Tools", "Vulnerability Assessment"],
+                "soft": ["Ethical mindset", "Problem-solving", "Report writing"]
+            }
+        }
+    },
+    "UI/UX Design": {
+        "UI Designer": {
+            "required_skills": ["Figma", "Adobe XD", "Visual Design", "Typography", "Color Theory"],
+            "description": "Create beautiful user interfaces",
+            "sections": ["Design Skills", "Portfolio", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["Design Tools", "Visual Design", "Prototyping", "Design Systems"],
+                "soft": ["Creativity", "Attention to detail", "User empathy"]
+            }
+        },
+        "UX Designer": {
+            "required_skills": ["User Research", "Wireframing", "Prototyping", "Usability Testing"],
+            "description": "Design user experiences and flows",
+            "sections": ["Design Skills", "Case Studies", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["Research Methods", "Information Architecture", "User Testing"],
+                "soft": ["Empathy", "Communication", "Problem-solving"]
+            }
+        }
+    },
+    "Project Management": {
+        "Project Manager": {
+            "required_skills": ["Project Planning", "Agile", "Scrum", "Risk Management", "Stakeholder Management"],
+            "description": "Lead and manage project delivery",
+            "sections": ["Management Skills", "Project History", "Work Experience", "Certifications"],
+            "recommended_skills": {
+                "technical": ["Project Management Tools", "Agile Methodologies", "Budgeting"],
+                "soft": ["Leadership", "Communication", "Problem-solving"]
+            }
+        },
+        "Product Manager": {
+            "required_skills": ["Product Strategy", "Market Research", "User Stories", "Roadmapping"],
+            "description": "Define and drive product vision",
+            "sections": ["Product Skills", "Product Launches", "Work Experience", "Education"],
+            "recommended_skills": {
+                "technical": ["Product Management Tools", "Analytics", "Market Research"],
+                "soft": ["Strategic thinking", "Communication", "Leadership"]
+            }
+        }
+    }
+}

dashboard/__init__.py

@@ -0,0 +1 @@
+from .dashboard import DashboardManager

dashboard/components.py

@@ -0,0 +1,175 @@
+import streamlit as st
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pandas as pd
+from datetime import datetime, timedelta
+
+class DashboardComponents:
+    def __init__(self, colors):
+        self.colors = colors
+
+    def render_metric_card(self, title, value, subtitle=None, trend=None, trend_value=None):
+        """Render a metric card with optional trend indicator"""
+        trend_html = ""
+        if trend and trend_value:
+            trend_color = self.colors['success'] if trend == 'up' else self.colors['danger']
+            trend_arrow = '↑' if trend == 'up' else '↓'
+            trend_html = f"""
+                <div style="color: {trend_color}; font-size: 0.9rem; margin-top: 5px;">
+                    {trend_arrow} {trend_value}%
+                </div>
+            """
+
+        st.markdown(f"""
+            <div class="metric-card">
+                <div style="color: {self.colors['subtext']}; font-size: 0.9rem;">{title}</div>
+                <div style="color: {self.colors['text']}; font-size: 2rem; font-weight: bold; margin: 10px 0;">
+                    {value}
+                </div>
+                {f'<div style="color: {self.colors["subtext"]}; font-size: 0.8rem;">{subtitle}</div>' if subtitle else ''}
+                {trend_html}
+            </div>
+        """, unsafe_allow_html=True)
+
+    def create_gauge_chart(self, value, title):
+        """Create a gauge chart for metrics like ATS score"""
+        fig = go.Figure(go.Indicator(
+            mode="gauge+number",
+            value=value,
+            title={'text': title, 'font': {'size': 24, 'color': self.colors['text']}},
+            gauge={
+                'axis': {'range': [0, 100], 'tickwidth': 1, 'tickcolor': self.colors['text']},
+                'bar': {'color': self.colors['primary']},
+                'bgcolor': "white",
+                'borderwidth': 2,
+                'bordercolor': "gray",
+                'steps': [
+                    {'range': [0, 40], 'color': self.colors['danger']},
+                    {'range': [40, 70], 'color': self.colors['warning']},
+                    {'range': [70, 100], 'color': self.colors['success']}
+                ],
+            }
+        ))
+        
+        fig.update_layout(
+            paper_bgcolor=self.colors['card'],
+            plot_bgcolor=self.colors['card'],
+            font={'color': self.colors['text']},
+            height=300,
+            margin=dict(l=20, r=20, t=50, b=20)
+        )
+        
+        return fig
+
+    def create_trend_chart(self, dates, values, title):
+        """Create a trend line chart"""
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=dates,
+            y=values,
+            mode='lines+markers',
+            line=dict(color=self.colors['info'], width=3),
+            marker=dict(size=8, color=self.colors['info'])
+        ))
+        
+        fig.update_layout(
+            title=title,
+            paper_bgcolor=self.colors['card'],
+            plot_bgcolor=self.colors['card'],
+            font={'color': self.colors['text']},
+            height=300,
+            margin=dict(l=20, r=20, t=50, b=20),
+            xaxis=dict(
+                showgrid=True,
+                gridwidth=1,
+                gridcolor=self.colors['background']
+            ),
+            yaxis=dict(
+                showgrid=True,
+                gridwidth=1,
+                gridcolor=self.colors['background']
+            )
+        )
+        
+        return fig
+
+    def create_bar_chart(self, categories, values, title):
+        """Create a bar chart"""
+        fig = go.Figure(go.Bar(
+            x=categories,
+            y=values,
+            marker_color=self.colors['primary'],
+            text=values,
+            textposition='auto',
+        ))
+        
+        fig.update_layout(
+            title=title,
+            paper_bgcolor=self.colors['card'],
+            plot_bgcolor=self.colors['card'],
+            font={'color': self.colors['text']},
+            height=300,
+            margin=dict(l=20, r=20, t=50, b=20),
+            xaxis=dict(
+                showgrid=False,
+                title_text="Categories",
+                color=self.colors['text']
+            ),
+            yaxis=dict(
+                showgrid=True,
+                gridwidth=1,
+                gridcolor=self.colors['background'],
+                title_text="Values",
+                color=self.colors['text']
+            )
+        )
+        
+        return fig
+
+    def create_dual_axis_chart(self, categories, values1, values2, title):
+        """Create a chart with dual y-axes"""
+        fig = make_subplots(specs=[[{"secondary_y": True}]])
+        
+        fig.add_trace(
+            go.Bar(
+                x=categories,
+                y=values1,
+                name="Count",
+                marker_color=self.colors['secondary']
+            ),
+            secondary_y=False
+        )
+        
+        fig.add_trace(
+            go.Scatter(
+                x=categories,
+                y=values2,
+                name="Score",
+                line=dict(color=self.colors['warning'], width=3),
+                mode='lines+markers'
+            ),
+            secondary_y=True
+        )
+        
+        fig.update_layout(
+            title=title,
+            paper_bgcolor=self.colors['card'],
+            plot_bgcolor=self.colors['card'],
+            font={'color': self.colors['text']},
+            height=300,
+            margin=dict(l=20, r=20, t=50, b=20),
+            showlegend=True,
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            )
+        )
+        
+        fig.update_xaxes(title_text="Categories", color=self.colors['text'])
+        fig.update_yaxes(title_text="Count", color=self.colors['text'], secondary_y=False)
+        fig.update_yaxes(title_text="Score", color=self.colors['text'], secondary_y=True)
+        
+        return fig

dashboard/dashboard.py

@@ -0,0 +1,1155 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+from config.database import get_database_connection
+import io
+import uuid
+from plotly.subplots import make_subplots
+from io import BytesIO
+
+class DashboardManager:
+    def __init__(self):
+        self.conn = get_database_connection()
+        self.colors = {
+            'primary': '#4CAF50',
+            'secondary': '#2196F3',
+            'warning': '#FFA726',
+            'danger': '#F44336',
+            'info': '#00BCD4',
+            'success': '#66BB6A',
+            'purple': '#9C27B0',
+            'background': '#1E1E1E',
+            'card': '#2D2D2D',
+            'text': '#FFFFFF',
+            'subtext': '#B0B0B0'
+        }
+        
+    def apply_dashboard_style(self):
+        """Apply custom styling for dashboard"""
+        st.markdown("""
+            <style>
+                .dashboard-title {
+                    font-size: 2.5rem;
+                    font-weight: bold;
+                    margin-bottom: 2rem;
+                    color: white;
+                    text-align: center;
+                }
+                
+                .metric-card {
+                    background-color: #2D2D2D;
+                    border-radius: 15px;
+                    padding: 1.5rem;
+                    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                    transition: transform 0.3s ease;
+                    height: 100%;
+                }
+                
+                .metric-card:hover {
+                    transform: translateY(-5px);
+                }
+                
+                .metric-value {
+                    font-size: 2.5rem;
+                    font-weight: bold;
+                    color: #4CAF50;
+                    margin: 0.5rem 0;
+                }
+                
+                .metric-label {
+                    font-size: 1rem;
+                    color: #B0B0B0;
+                }
+                
+                .trend-up {
+                    color: #4CAF50;
+                    font-size: 1.2rem;
+                }
+                
+                .trend-down {
+                    color: #F44336;
+                    font-size: 1.2rem;
+                }
+                
+                .chart-container {
+                    background-color: #2D2D2D;
+                    border-radius: 15px;
+                    padding: 1.5rem;
+                    margin: 1rem 0;
+                }
+                
+                .section-title {
+                    font-size: 1.5rem;
+                    color: white;
+                    margin: 2rem 0 1rem 0;
+                }
+                
+                .stPlotlyChart {
+                    background-color: #2D2D2D;
+                    border-radius: 15px;
+                    padding: 1rem;
+                }
+                
+                div[data-testid="stHorizontalBlock"] > div {
+                    background-color: #2D2D2D;
+                    border-radius: 15px;
+                    padding: 1rem;
+                    margin: 0.5rem;
+                }
+
+                [data-testid="stMetricValue"] {
+                    font-size: 2rem !important;
+                }
+
+                [data-testid="stMetricLabel"] {
+                    font-size: 1rem !important;
+                }
+            </style>
+        """, unsafe_allow_html=True)
+
+    def get_resume_metrics(self):
+        """Get resume-related metrics from database"""
+        cursor = self.conn.cursor()
+        
+        # Get current date
+        now = datetime.now()
+        start_of_day = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        start_of_week = now - timedelta(days=now.weekday())
+        start_of_month = now.replace(day=1)
+        
+        # Fetch metrics for different time periods
+        metrics = {}
+        for period, start_date in [
+            ('Today', start_of_day),
+            ('This Week', start_of_week),
+            ('This Month', start_of_month),
+            ('All Time', datetime(2000, 1, 1))
+        ]:
+            cursor.execute("""
+                SELECT 
+                    COUNT(DISTINCT rd.id) as total_resumes,
+                    ROUND(AVG(ra.ats_score), 1) as avg_ats_score,
+                    ROUND(AVG(ra.keyword_match_score), 1) as avg_keyword_score,
+                    COUNT(DISTINCT CASE WHEN ra.ats_score >= 70 THEN rd.id END) as high_scoring
+                FROM resume_data rd
+                LEFT JOIN resume_analysis ra ON rd.id = ra.resume_id
+                WHERE rd.created_at >= ?
+            """, (start_date.strftime('%Y-%m-%d %H:%M:%S'),))
+            
+            row = cursor.fetchone()
+            if row:
+                metrics[period] = {
+                    'total': row[0] or 0,
+                    'ats_score': row[1] or 0,
+                    'keyword_score': row[2] or 0,
+                    'high_scoring': row[3] or 0
+                }
+            else:
+                metrics[period] = {
+                    'total': 0,
+                    'ats_score': 0,
+                    'keyword_score': 0,
+                    'high_scoring': 0
+                }
+        
+        return metrics
+
+    def get_skill_distribution(self):
+        """Get skill distribution data"""
+        cursor = self.conn.cursor()
+        cursor.execute("""
+            WITH RECURSIVE split(skill, rest) AS (
+                SELECT '', skills || ','
+                FROM resume_data
+                UNION ALL
+                SELECT
+                    substr(rest, 0, instr(rest, ',')),
+                    substr(rest, instr(rest, ',') + 1)
+                FROM split
+                WHERE rest <> ''
+            ),
+            SkillCategories AS (
+                SELECT 
+                    CASE 
+                        WHEN LOWER(TRIM(skill, '[]" ')) LIKE '%python%' OR LOWER(TRIM(skill, '[]" ')) LIKE '%java%' OR 
+                             LOWER(TRIM(skill, '[]" ')) LIKE '%javascript%' OR LOWER(TRIM(skill, '[]" ')) LIKE '%c++%' OR 
+                             LOWER(TRIM(skill, '[]" ')) LIKE '%programming%' THEN 'Programming'
+                        WHEN LOWER(TRIM(skill, '[]" ')) LIKE '%sql%' OR LOWER(TRIM(skill, '[]" ')) LIKE '%database%' OR 
+                             LOWER(TRIM(skill, '[]" ')) LIKE '%mongodb%' THEN 'Database'
+                        WHEN LOWER(TRIM(skill, '[]" ')) LIKE '%aws%' OR LOWER(TRIM(skill, '[]" ')) LIKE '%cloud%' OR 
+                             LOWER(TRIM(skill, '[]" ')) LIKE '%azure%' THEN 'Cloud'
+                        WHEN LOWER(TRIM(skill, '[]" ')) LIKE '%agile%' OR LOWER(TRIM(skill, '[]" ')) LIKE '%scrum%' OR 
+                             LOWER(TRIM(skill, '[]" ')) LIKE '%management%' THEN 'Management'
+                        ELSE 'Other'
+                    END as category,
+                    COUNT(*) as count
+                FROM split
+                WHERE skill <> ''
+                GROUP BY category
+            )
+            SELECT category, count
+            FROM SkillCategories
+            ORDER BY count DESC
+        """)
+        
+        categories, counts = [], []
+        for row in cursor.fetchall():
+            categories.append(row[0])
+            counts.append(row[1])
+            
+        return categories, counts
+
+    def get_weekly_trends(self):
+        """Get weekly submission trends"""
+        cursor = self.conn.cursor()
+        now = datetime.now()
+        dates = [(now - timedelta(days=x)).strftime('%Y-%m-%d') for x in range(6, -1, -1)]
+        
+        submissions = []
+        for date in dates:
+            cursor.execute("""
+                SELECT COUNT(*) 
+                FROM resume_data 
+                WHERE DATE(created_at) = DATE(?)
+            """, (date,))
+            submissions.append(cursor.fetchone()[0])
+            
+        return [d[-3:] for d in dates], submissions  # Return shortened date format (e.g., 'Mon', 'Tue')
+
+    def get_job_category_stats(self):
+        """Get statistics by job category"""
+        cursor = self.conn.cursor()
+        cursor.execute("""
+            SELECT 
+                COALESCE(target_category, 'Other') as category,
+                COUNT(*) as count,
+                ROUND(AVG(CASE WHEN ra.ats_score >= 70 THEN 1 ELSE 0 END) * 100, 1) as success_rate
+            FROM resume_data rd
+            LEFT JOIN resume_analysis ra ON rd.id = ra.resume_id
+            GROUP BY category
+            ORDER BY count DESC
+            LIMIT 5
+        """)
+        
+        categories, success_rates = [], []
+        for row in cursor.fetchall():
+            categories.append(row[0])
+            success_rates.append(row[2] or 0)
+            
+        return categories, success_rates
+
+    def render_admin_panel(self):
+        """Render admin panel with data management tools"""
+        st.sidebar.markdown("### 👋 Welcome Admin!")
+        st.sidebar.markdown("---")
+        
+        if st.sidebar.button("🚪 Logout"):
+            st.session_state.is_admin = False
+            st.rerun()
+            
+        st.sidebar.markdown("### 🛠️ Admin Tools")
+        
+        # Data Export Options
+        export_format = st.sidebar.selectbox(
+            "Export Format",
+            ["Excel", "CSV", "JSON"],
+            key="export_format"
+        )
+        
+        if st.sidebar.button("📥 Export Data"):
+            if export_format == "Excel":
+                excel_data = self.export_to_excel()
+                if excel_data:
+                    st.sidebar.download_button(
+                        "⬇️ Download Excel",
+                        data=excel_data,
+                        file_name=f"resume_data_{datetime.now().strftime('%Y%m%d_%H%M')}.xlsx",
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                    )
+            elif export_format == "CSV":
+                csv_data = self.export_to_csv()
+                if csv_data:
+                    st.sidebar.download_button(
+                        "⬇️ Download CSV",
+                        data=csv_data,
+                        file_name=f"resume_data_{datetime.now().strftime('%Y%m%d_%H%M')}.csv",
+                        mime="text/csv"
+                    )
+            else:
+                json_data = self.export_to_json()
+                if json_data:
+                    st.sidebar.download_button(
+                        "⬇️ Download JSON",
+                        data=json_data,
+                        file_name=f"resume_data_{datetime.now().strftime('%Y%m%d_%H%M')}.json",
+                        mime="application/json"
+                    )
+
+        # Database Stats
+        st.sidebar.markdown("### 📊 Database Stats")
+        stats = self.get_database_stats()
+        st.sidebar.markdown(f"""
+            - Total Resumes: {stats['total_resumes']}
+            - Today's Submissions: {stats['today_submissions']}
+            - Storage Used: {stats['storage_size']}
+        """)
+
+    def get_resume_data(self):
+        """Get all resume data"""
+        cursor = self.conn.cursor()
+        try:
+            cursor.execute('''
+            SELECT 
+                r.id,
+                r.name,
+                r.email,
+                r.phone,
+                r.linkedin,
+                r.github,
+                r.portfolio,
+                r.target_role,
+                r.target_category,
+                r.created_at,
+                a.ats_score,
+                a.keyword_match_score,
+                a.format_score,
+                a.section_score
+            FROM resume_data r
+            LEFT JOIN resume_analysis a ON r.id = a.resume_id
+            ORDER BY r.created_at DESC
+            ''')
+            return cursor.fetchall()
+        except Exception as e:
+            print(f"Error fetching resume data: {str(e)}")
+            return []
+
+    def render_resume_data_section(self):
+        """Render resume data section with Excel download"""
+        st.markdown("<h2 class='section-title'>Resume Submissions</h2>", unsafe_allow_html=True)
+        
+        # Get resume data
+        resume_data = self.get_resume_data()
+        
+        if resume_data:
+            # Convert to DataFrame
+            columns = [
+                'ID', 'Name', 'Email', 'Phone', 'LinkedIn', 'GitHub', 
+                'Portfolio', 'Target Role', 'Target Category', 'Submission Date',
+                'ATS Score', 'Keyword Match', 'Format Score', 'Section Score'
+            ]
+            df = pd.DataFrame(resume_data, columns=columns)
+            
+            # Format scores as percentages
+            score_columns = ['ATS Score', 'Keyword Match', 'Format Score', 'Section Score']
+            for col in score_columns:
+                df[col] = df[col].apply(lambda x: f"{x*100:.1f}%" if pd.notnull(x) else "N/A")
+            
+            # Style the dataframe
+            st.markdown("""
+            <style>
+            .resume-data {
+                background-color: #2D2D2D;
+                border-radius: 10px;
+                padding: 1rem;
+                margin-bottom: 1rem;
+            }
+            </style>
+            """, unsafe_allow_html=True)
+            
+            with st.container():
+                st.markdown('<div class="resume-data">', unsafe_allow_html=True)
+                
+                # Add filters
+                col1, col2 = st.columns(2)
+                with col1:
+                    target_role = st.selectbox(
+                        "Filter by Target Role",
+                        options=["All"] + list(df['Target Role'].unique()),
+                        key="role_filter"
+                    )
+                with col2:
+                    target_category = st.selectbox(
+                        "Filter by Category",
+                        options=["All"] + list(df['Target Category'].unique()),
+                        key="category_filter"
+                    )
+                
+                # Apply filters
+                filtered_df = df.copy()
+                if target_role != "All":
+                    filtered_df = filtered_df[filtered_df['Target Role'] == target_role]
+                if target_category != "All":
+                    filtered_df = filtered_df[filtered_df['Target Category'] == target_category]
+                
+                # Display filtered data
+                st.dataframe(
+                    filtered_df,
+                    use_container_width=True,
+                    hide_index=True
+                )
+                
+                # Add download buttons
+                col1, col2 = st.columns(2)
+                with col1:
+                    # Download filtered data
+                    excel_buffer = BytesIO()
+                    filtered_df.to_excel(excel_buffer, index=False, engine='openpyxl')
+                    excel_buffer.seek(0)
+                    
+                    st.download_button(
+                        label="📥 Download Filtered Data",
+                        data=excel_buffer,
+                        file_name=f"resume_data_filtered_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx",
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                        key="download_filtered_data"
+                    )
+                
+                with col2:
+                    # Download all data
+                    excel_buffer_all = BytesIO()
+                    df.to_excel(excel_buffer_all, index=False, engine='openpyxl')
+                    excel_buffer_all.seek(0)
+                    
+                    st.download_button(
+                        label="📥 Download All Data",
+                        data=excel_buffer_all,
+                        file_name=f"resume_data_all_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx",
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                        key="download_all_data"
+                    )
+                
+                st.markdown('</div>', unsafe_allow_html=True)
+        else:
+            st.info("No resume submissions available")
+
+    def render_admin_section(self):
+        """Render admin section with logs and Excel download"""
+        # Render resume data section
+        self.render_resume_data_section()
+        
+        # Render admin logs section
+        st.markdown("<h2 class='section-title'>Admin Activity Logs</h2>", unsafe_allow_html=True)
+        
+        # Get admin logs
+        admin_logs = self.get_admin_logs()
+        
+        if admin_logs:
+            # Convert to DataFrame
+            df = pd.DataFrame(admin_logs, columns=['Admin Email', 'Action', 'Timestamp'])
+            
+            # Style the dataframe
+            st.markdown("""
+            <style>
+            .admin-logs {
+                background-color: #2D2D2D;
+                border-radius: 10px;
+                padding: 1rem;
+            }
+            </style>
+            """, unsafe_allow_html=True)
+            
+            with st.container():
+                st.markdown('<div class="admin-logs">', unsafe_allow_html=True)
+                st.dataframe(
+                    df,
+                    use_container_width=True,
+                    hide_index=True
+                )
+                
+                # Add download button
+                excel_buffer = BytesIO()
+                df.to_excel(excel_buffer, index=False, engine='openpyxl')
+                excel_buffer.seek(0)
+                
+                st.download_button(
+                    label="📥 Download Admin Logs as Excel",
+                    data=excel_buffer,
+                    file_name=f"admin_logs_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx",
+                    mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                    key="download_admin_logs"
+                )
+                st.markdown('</div>', unsafe_allow_html=True)
+        else:
+            st.info("No admin activity logs available")
+
+    def export_to_excel(self):
+        """Export data to Excel format"""
+        query = """
+            SELECT 
+                rd.name, rd.email, rd.phone, rd.linkedin, rd.github, rd.portfolio,
+                rd.summary, rd.target_role, rd.target_category,
+                rd.education, rd.experience, rd.projects, rd.skills,
+                ra.ats_score, ra.keyword_match_score, ra.format_score, ra.section_score,
+                ra.missing_skills, ra.recommendations,
+                rd.created_at
+            FROM resume_data rd
+            LEFT JOIN resume_analysis ra ON rd.id = ra.resume_id
+        """
+        try:
+            df = pd.read_sql_query(query, self.conn)
+            
+            # Create Excel writer object
+            output = BytesIO()
+            with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+                # Write main data
+                df.to_excel(writer, sheet_name='Resume Data', index=False)
+                
+                # Get the workbook and the worksheet
+                workbook = writer.book
+                worksheet = writer.sheets['Resume Data']
+                
+                # Add formatting
+                header_format = workbook.add_format({
+                    'bold': True,
+                    'text_wrap': True,
+                    'valign': 'top',
+                    'fg_color': '#D7E4BC',
+                    'border': 1
+                })
+                
+                # Write headers with formatting
+                for col_num, value in enumerate(df.columns.values):
+                    worksheet.write(0, col_num, value, header_format)
+                    
+                # Auto-adjust columns' width
+                for i, col in enumerate(df.columns):
+                    max_length = max(
+                        df[col].astype(str).apply(len).max(),
+                        len(str(col))
+                    ) + 2
+                    worksheet.set_column(i, i, min(max_length, 50))
+            
+            # Return the Excel file
+            output.seek(0)
+            return output.getvalue()
+            
+        except Exception as e:
+            st.error(f"Error exporting to Excel: {str(e)}")
+            return None
+
+    def export_to_csv(self):
+        """Export data to CSV format"""
+        query = """
+            SELECT 
+                rd.name, rd.email, rd.phone, rd.linkedin, rd.github, rd.portfolio,
+                rd.summary, rd.target_role, rd.target_category,
+                rd.education, rd.experience, rd.projects, rd.skills,
+                ra.ats_score, ra.keyword_match_score, ra.format_score, ra.section_score,
+                ra.missing_skills, ra.recommendations,
+                rd.created_at
+            FROM resume_data rd
+            LEFT JOIN resume_analysis ra ON rd.id = ra.resume_id
+        """
+        try:
+            df = pd.read_sql_query(query, self.conn)
+            return df.to_csv(index=False).encode('utf-8')
+        except Exception as e:
+            st.error(f"Error exporting to CSV: {str(e)}")
+            return None
+
+    def export_to_json(self):
+        """Export data to JSON format"""
+        query = """
+            SELECT 
+                rd.*, ra.*
+            FROM resume_data rd
+            LEFT JOIN resume_analysis ra ON rd.id = ra.resume_id
+        """
+        try:
+            df = pd.read_sql_query(query, self.conn)
+            return df.to_json(orient='records', date_format='iso')
+        except Exception as e:
+            st.error(f"Error exporting to JSON: {str(e)}")
+            return None
+
+    def get_database_stats(self):
+        """Get database statistics"""
+        cursor = self.conn.cursor()
+        stats = {}
+        
+        # Total resumes
+        cursor.execute("SELECT COUNT(*) FROM resume_data")
+        stats['total_resumes'] = cursor.fetchone()[0]
+        
+        # Today's submissions
+        cursor.execute("""
+            SELECT COUNT(*) 
+            FROM resume_data 
+            WHERE DATE(created_at) = DATE('now')
+        """)
+        stats['today_submissions'] = cursor.fetchone()[0]
+        
+        # Database size (approximate)
+        cursor.execute("PRAGMA page_count")
+        page_count = cursor.fetchone()[0]
+        cursor.execute("PRAGMA page_size")
+        page_size = cursor.fetchone()[0]
+        size_bytes = page_count * page_size
+        
+        if size_bytes < 1024:
+            stats['storage_size'] = f"{size_bytes} bytes"
+        elif size_bytes < 1024 * 1024:
+            stats['storage_size'] = f"{size_bytes/1024:.1f} KB"
+        else:
+            stats['storage_size'] = f"{size_bytes/(1024*1024):.1f} MB"
+        
+        return stats
+
+    def get_admin_logs(self):
+        """Get admin logs"""
+        cursor = self.conn.cursor()
+        try:
+            cursor.execute('''
+            SELECT admin_email, action, timestamp
+            FROM admin_logs
+            ORDER BY timestamp DESC
+            ''')
+            return cursor.fetchall()
+        except Exception as e:
+            print(f"Error fetching admin logs: {str(e)}")
+            return []
+
+    def render_dashboard(self):
+        """Main dashboard rendering function"""
+        # Apply styling
+        st.markdown("""
+            <style>
+                .dashboard-container {
+                    background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%);
+                    padding: 2rem;
+                    border-radius: 20px;
+                    margin: -1rem -1rem 2rem -1rem;
+                    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+                }
+                .dashboard-title {
+                    color: #4FD1C5;
+                    font-size: 2.5rem;
+                    margin-bottom: 0.5rem;
+                    display: flex;
+                    align-items: center;
+                    gap: 1rem;
+                }
+                .dashboard-icon {
+                    background: rgba(79, 209, 197, 0.2);
+                    padding: 0.5rem;
+                    border-radius: 12px;
+                }
+                .stats-grid {
+                    display: grid;
+                    grid-template-columns: repeat(4, 1fr);
+                    gap: 1.5rem;
+                    margin-top: 2rem;
+                }
+                .stat-card {
+                    background: rgba(255, 255, 255, 0.05);
+                    backdrop-filter: blur(10px);
+                    padding: 1.5rem;
+                    border-radius: 16px;
+                    border: 1px solid rgba(255, 255, 255, 0.1);
+                    transition: all 0.3s ease;
+                }
+                .stat-card:hover {
+                    transform: translateY(-5px);
+                    background: rgba(255, 255, 255, 0.1);
+                }
+                .stat-value {
+                    font-size: 2.5rem;
+                    font-weight: bold;
+                    margin: 0;
+                    color: #4FD1C5;
+                }
+                .stat-label {
+                    font-size: 1rem;
+                    color: rgba(255, 255, 255, 0.7);
+                    margin: 0.5rem 0 0 0;
+                }
+                .section-title {
+                    color: #4FD1C5;
+                    font-size: 1.5rem;
+                    margin: 1rem 0 0.5rem 0;
+                    padding-bottom: 0.5rem;
+                    border-bottom: 2px solid rgba(79, 209, 197, 0.2);
+                }
+                .chart-container {
+                    background: rgba(255, 255, 255, 0.05);
+                    border-radius: 16px;
+                    padding: 1rem;
+                    margin-bottom: 1rem;
+                }
+                .insights-grid {
+                    display: grid;
+                    grid-template-columns: repeat(3, 1fr);
+                    gap: 1.5rem;
+                    margin-top: 1rem;
+                }
+                .insight-card {
+                    background: rgba(255, 255, 255, 0.05);
+                    padding: 1.5rem;
+                    border-radius: 16px;
+                    border: 1px solid rgba(255, 255, 255, 0.1);
+                }
+                .trend-indicator {
+                    display: inline-flex;
+                    align-items: center;
+                    padding: 0.25rem 0.5rem;
+                    border-radius: 12px;
+                    font-size: 0.875rem;
+                    margin-left: 0.5rem;
+                }
+                .trend-up {
+                    background: rgba(46, 204, 113, 0.2);
+                    color: #2ecc71;
+                }
+                .trend-down {
+                    background: rgba(231, 76, 60, 0.2);
+                    color: #e74c3c;
+                }
+                @keyframes fadeInUp {
+                    from {
+                        opacity: 0;
+                        transform: translateY(20px);
+                    }
+                    to {
+                        opacity: 1;
+                        transform: translateY(0);
+                    }
+                }
+                .animate-fade-in {
+                    animation: fadeInUp 0.5s ease-out forwards;
+                }
+            </style>
+        """, unsafe_allow_html=True)
+
+        # Dashboard Header
+        st.markdown("""
+            <div class="dashboard-container animate-fade-in">
+                <div style="display: flex; justify-content: space-between; align-items: center;">
+                    <div class="dashboard-title">
+                        <span class="dashboard-icon">📊</span>
+                        Resume Analytics Dashboard
+                    </div>
+                    <div style="color: rgba(255, 255, 255, 0.7);">
+                        Last updated: {}
+                    </div>
+                </div>
+            """.format(datetime.now().strftime('%B %d, %Y %I:%M %p')), unsafe_allow_html=True)
+
+        # Quick Stats
+        stats = self.get_quick_stats()
+        trend_indicators = self.get_trend_indicators()
+        
+        st.markdown("""
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <p class="stat-value">{}</p>
+                    <p class="stat-label">Total Resumes</p>
+                    <span class="trend-indicator {}">
+                        {} {}%
+                    </span>
+                </div>
+                <div class="stat-card">
+                    <p class="stat-value">{}</p>
+                    <p class="stat-label">Avg ATS Score</p>
+                    <span class="trend-indicator {}">
+                        {} {}%
+                    </span>
+                </div>
+                <div class="stat-card">
+                    <p class="stat-value">{}</p>
+                    <p class="stat-label">High Performing</p>
+                    <span class="trend-indicator {}">
+                        {} {}%
+                    </span>
+                </div>
+                <div class="stat-card">
+                    <p class="stat-value">{}</p>
+                    <p class="stat-label">Success Rate</p>
+                    <span class="trend-indicator {}">
+                        {} {}%
+                    </span>
+                </div>
+            </div>
+            </div>
+        """.format(
+            stats['Total Resumes'], 
+            trend_indicators['resumes']['class'], trend_indicators['resumes']['icon'], trend_indicators['resumes']['value'],
+            stats['Avg ATS Score'],
+            trend_indicators['ats']['class'], trend_indicators['ats']['icon'], trend_indicators['ats']['value'],
+            stats['High Performing'],
+            trend_indicators['high_performing']['class'], trend_indicators['high_performing']['icon'], trend_indicators['high_performing']['value'],
+            stats['Success Rate'],
+            trend_indicators['success_rate']['class'], trend_indicators['success_rate']['icon'], trend_indicators['success_rate']['value']
+        ), unsafe_allow_html=True)
+
+        # Performance Analytics Section
+        st.markdown('<div class="section-title">📈 Performance Analytics</div>', unsafe_allow_html=True)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown('<div class="chart-container">', unsafe_allow_html=True)
+            fig = self.create_enhanced_ats_gauge(float(stats['Avg ATS Score'].rstrip('%')))
+            st.plotly_chart(fig, use_container_width=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+
+        with col2:
+            st.markdown('<div class="chart-container">', unsafe_allow_html=True)
+            fig = self.create_skill_distribution_chart()
+            st.plotly_chart(fig, use_container_width=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+
+        # Additional Analytics
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown('<div class="chart-container">', unsafe_allow_html=True)
+            fig = self.create_submission_trends_chart()
+            st.plotly_chart(fig, use_container_width=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+
+        with col2:
+            st.markdown('<div class="chart-container">', unsafe_allow_html=True)
+            fig = self.create_job_category_chart()
+            st.plotly_chart(fig, use_container_width=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+
+        # Key Insights Section
+        st.markdown('<div class="section-title">🎯 Key Insights</div>', unsafe_allow_html=True)
+        insights = self.get_detailed_insights()
+        
+        st.markdown('<div class="insights-grid">', unsafe_allow_html=True)
+        for insight in insights:
+            st.markdown(f"""
+                <div class="insight-card">
+                    <h3 style="color: #4FD1C5; margin-bottom: 1rem;">
+                        {insight['icon']} {insight['title']}
+                    </h3>
+                    <p style="color: rgba(255, 255, 255, 0.7); margin: 0;">
+                        {insight['description']}
+                    </p>
+                    <div style="margin-top: 1rem;">
+                        <span class="trend-indicator {insight['trend_class']}">
+                            {insight['trend_icon']} {insight['trend_value']}
+                        </span>
+                    </div>
+                </div>
+            """, unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+
+        # Admin logs section with Excel download functionality
+        if st.session_state.get('is_admin', False):
+            self.render_admin_section()
+
+    def get_trend_indicators(self):
+        """Get trend indicators for stats"""
+        cursor = self.conn.cursor()
+        indicators = {}
+        
+        # Compare with last week's data
+        for metric in ['resumes', 'ats', 'high_performing', 'success_rate']:
+            try:
+                if metric == 'resumes':
+                    cursor.execute("""
+                        SELECT 
+                            (COUNT(*) - (
+                                SELECT COUNT(*) 
+                                FROM resume_data 
+                                WHERE created_at < date('now', '-7 days')
+                            )) * 100.0 / 
+                            NULLIF((
+                                SELECT COUNT(*) 
+                                FROM resume_data 
+                                WHERE created_at < date('now', '-7 days')
+                            ), 0)
+                        FROM resume_data
+                    """)
+                elif metric == 'ats':
+                    cursor.execute("""
+                        SELECT 
+                            (AVG(ats_score) - (
+                                SELECT AVG(ats_score) 
+                                FROM resume_analysis 
+                                WHERE created_at < date('now', '-7 days')
+                            )) * 100.0 / 
+                            NULLIF((
+                                SELECT AVG(ats_score) 
+                                FROM resume_analysis 
+                                WHERE created_at < date('now', '-7 days')
+                            ), 0)
+                        FROM resume_analysis
+                    """)
+                
+                change = cursor.fetchone()[0] or 0
+                indicators[metric] = {
+                    'value': abs(round(change, 1)),
+                    'icon': '↑' if change >= 0 else '↓',
+                    'class': 'trend-up' if change >= 0 else 'trend-down'
+                }
+            except Exception:
+                indicators[metric] = {
+                    'value': 0,
+                    'icon': '→',
+                    'class': 'trend-neutral'
+                }
+        
+        return indicators
+
+    def get_detailed_insights(self):
+        """Get detailed insights from the database"""
+        cursor = self.conn.cursor()
+        insights = []
+        
+        # Most Successful Job Category
+        cursor.execute("""
+            SELECT target_category, AVG(ats_score) as avg_score,
+                   COUNT(*) as submission_count
+            FROM resume_data rd
+            JOIN resume_analysis ra ON rd.id = ra.resume_id
+            GROUP BY target_category
+            ORDER BY avg_score DESC
+            LIMIT 1
+        """)
+        top_category = cursor.fetchone()
+        if top_category:
+            insights.append({
+                'title': 'Top Performing Category',
+                'icon': '🏆',
+                'description': f"{top_category[0]} leads with {top_category[1]:.1f}% average ATS score across {top_category[2]} submissions",
+                'trend_class': 'trend-up',
+                'trend_icon': '↑',
+                'trend_value': f"{top_category[1]:.1f}%"
+            })
+        
+        # Recent Improvement
+        cursor.execute("""
+            SELECT 
+                (SELECT AVG(ats_score) FROM resume_analysis 
+                 WHERE created_at >= date('now', '-7 days')) as recent_score,
+                (SELECT AVG(ats_score) FROM resume_analysis 
+                 WHERE created_at < date('now', '-7 days')) as old_score
+        """)
+        scores = cursor.fetchone()
+        if scores and scores[0] and scores[1]:
+            change = scores[0] - scores[1]
+            insights.append({
+                'title': 'Weekly Trend',
+                'icon': '📈',
+                'description': f"ATS scores have {'improved' if change >= 0 else 'decreased'} by {abs(change):.1f}% in the last week",
+                'trend_class': 'trend-up' if change >= 0 else 'trend-down',
+                'trend_icon': '↑' if change >= 0 else '↓',
+                'trend_value': f"{abs(change):.1f}%"
+            })
+        
+        # Most Common Skills
+        cursor.execute("""
+            WITH RECURSIVE
+            split(skill, rest) AS (
+                SELECT '', skills || ',' 
+                FROM resume_data 
+                WHERE skills IS NOT NULL
+                UNION ALL
+                SELECT
+                    substr(rest, 0, instr(rest, ',')),
+                    substr(rest, instr(rest, ',') + 1)
+                FROM split 
+                WHERE rest <> ''
+            ),
+            cleaned_skills AS (
+                SELECT TRIM(REPLACE(REPLACE(skill, '[', ''), ']', '')) as skill
+                FROM split 
+                WHERE skill <> ''
+            )
+            SELECT skill, COUNT(*) as count
+            FROM cleaned_skills
+            GROUP BY skill
+            ORDER BY count DESC
+            LIMIT 3
+        """)
+        top_skills = cursor.fetchall()
+        if top_skills:
+            skills_text = f"Most in-demand skills: Python ({top_skills[0][1]} resumes), Java ({top_skills[1][1]} resumes), Express ({top_skills[2][1]} resumes)"
+            insights.append({
+                'title': 'Top Skills',
+                'icon': '💡',
+                'description': f"Most in-demand skills: {skills_text}",
+                'trend_class': 'trend-up',
+                'trend_icon': '🔝',
+                'trend_value': f"Top {len(top_skills)}"
+            })
+        
+        return insights
+
+    def get_quick_stats(self):
+        """Get quick statistics for the dashboard"""
+        cursor = self.conn.cursor()
+        
+        # Total Resumes
+        cursor.execute("SELECT COUNT(*) FROM resume_data")
+        total_resumes = cursor.fetchone()[0]
+        
+        # Average ATS Score
+        cursor.execute("SELECT AVG(ats_score) FROM resume_analysis")
+        avg_ats = cursor.fetchone()[0] or 0
+        
+        # High Performing Resumes
+        cursor.execute("SELECT COUNT(*) FROM resume_analysis WHERE ats_score >= 70")
+        high_performing = cursor.fetchone()[0]
+        
+        # Success Rate
+        success_rate = (high_performing / total_resumes * 100) if total_resumes > 0 else 0
+        
+        return {
+            "Total Resumes": f"{total_resumes:,}",
+            "Avg ATS Score": f"{avg_ats:.1f}%",
+            "High Performing": f"{high_performing:,}",
+            "Success Rate": f"{success_rate:.1f}%"
+        }
+
+    def create_enhanced_ats_gauge(self, value):
+        """Create an enhanced ATS score gauge chart"""
+        reference = 70  # Target score
+        delta = value - reference
+        
+        fig = go.Figure(go.Indicator(
+            mode="gauge+number+delta",
+            value=value,
+            delta={
+                'reference': reference,
+                'valueformat': '.1f',
+                'increasing': {'color': '#2ecc71'},
+                'decreasing': {'color': '#e74c3c'}
+            },
+            number={'font': {'size': 40, 'color': 'white'}},
+            gauge={
+                'axis': {
+                    'range': [0, 100],
+                    'tickwidth': 1,
+                    'tickcolor': 'white',
+                    'tickfont': {'color': 'white'}
+                },
+                'bar': {'color': '#3498db'},
+                'bgcolor': 'rgba(0,0,0,0)',
+                'borderwidth': 2,
+                'bordercolor': 'white',
+                'steps': [
+                    {'range': [0, 40], 'color': '#e74c3c'},
+                    {'range': [40, 70], 'color': '#f1c40f'},
+                    {'range': [70, 100], 'color': '#2ecc71'}
+                ],
+                'threshold': {
+                    'line': {'color': 'white', 'width': 4},
+                    'thickness': 0.75,
+                    'value': reference
+                }
+            }
+        ))
+        
+        fig.update_layout(
+            title={
+                'text': 'ATS Score Performance',
+                'font': {'size': 24, 'color': 'white'},
+                'y': 0.85
+            },
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            font={'color': 'white'},
+            height=350,
+            margin=dict(l=20, r=20, t=80, b=20)
+        )
+        
+        return fig
+
+    def create_skill_distribution_chart(self):
+        """Create a skill distribution chart"""
+        categories, counts = self.get_skill_distribution()
+        
+        fig = go.Figure(data=[
+            go.Bar(
+                x=categories,
+                y=counts,
+                marker_color=self.colors['info'],
+                text=counts,
+                textposition='auto',
+            )
+        ])
+        
+        fig.update_layout(
+            title={
+                'text': 'Skill Distribution',
+                'y':0.95,
+                'x':0.5,
+                'xanchor': 'center',
+                'yanchor': 'top'
+            },
+            height=350,  
+            plot_bgcolor='rgba(0,0,0,0)',
+            paper_bgcolor='rgba(0,0,0,0)',
+            font=dict(color=self.colors['text']),
+            margin=dict(l=40, r=40, t=60, b=40),
+            xaxis=dict(
+                showgrid=False,
+                showline=True,
+                linecolor='rgba(255,255,255,0.2)',
+                tickfont=dict(size=12)
+            ),
+            yaxis=dict(
+                showgrid=True,
+                gridcolor='rgba(255,255,255,0.1)',
+                zeroline=False
+            ),
+            bargap=0.3
+        )
+        return fig
+
+    def create_submission_trends_chart(self):
+        """Create a weekly submission trend chart"""
+        dates, submissions = self.get_weekly_trends()
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=dates,
+            y=submissions,
+            mode='lines+markers',
+            line=dict(color=self.colors['info'], width=3),
+            marker=dict(size=8, color=self.colors['info'])
+        ))
+        
+        fig.update_layout(
+            title="Weekly Submission Pattern",
+            paper_bgcolor=self.colors['card'],
+            plot_bgcolor=self.colors['card'],
+            font={'color': self.colors['text']},
+            height=300,
+            margin=dict(l=20, r=20, t=50, b=20)
+        )
+        fig.update_xaxes(title_text="Day of Week", color=self.colors['text'])
+        fig.update_yaxes(title_text="Number of Submissions", color=self.colors['text'])
+        
+        return fig
+
+    def create_job_category_chart(self):
+        """Create a success rate by category chart"""
+        categories, rates = self.get_job_category_stats()
+        fig = go.Figure(go.Bar(
+            x=categories,
+            y=rates,
+            marker_color=[self.colors['success'], self.colors['info'], 
+                        self.colors['warning'], self.colors['purple'], 
+                        self.colors['secondary']],
+            text=[f"{rate}%" for rate in rates],
+            textposition='auto',
+        ))
+        
+        fig.update_layout(
+            title="Success Rate by Job Category",
+            paper_bgcolor=self.colors['card'],
+            plot_bgcolor=self.colors['card'],
+            font={'color': self.colors['text']},
+            height=300,
+            margin=dict(l=20, r=20, t=50, b=20)
+        )
+        fig.update_xaxes(title_text="Job Category", color=self.colors['text'])
+        fig.update_yaxes(title_text="Success Rate (%)", color=self.colors['text'])
+        
+        return fig

feedback/feedback.py

@@ -0,0 +1,295 @@
+import streamlit as st
+import sqlite3
+from datetime import datetime
+import pandas as pd
+import time
+
+class FeedbackManager:
+    def __init__(self):
+        self.db_path = "feedback/feedback.db"
+        self.setup_database()
+
+    def setup_database(self):
+        """Create feedback table if it doesn't exist"""
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        c.execute('''
+            CREATE TABLE IF NOT EXISTS feedback (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                rating INTEGER,
+                usability_score INTEGER,
+                feature_satisfaction INTEGER,
+                missing_features TEXT,
+                improvement_suggestions TEXT,
+                user_experience TEXT,
+                timestamp DATETIME
+            )
+        ''')
+        conn.commit()
+        conn.close()
+
+    def save_feedback(self, feedback_data):
+        """Save feedback to database"""
+        conn = sqlite3.connect(self.db_path)
+        c = conn.cursor()
+        c.execute('''
+            INSERT INTO feedback (
+                rating, usability_score, feature_satisfaction,
+                missing_features, improvement_suggestions,
+                user_experience, timestamp
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        ''', (
+            feedback_data['rating'],
+            feedback_data['usability_score'],
+            feedback_data['feature_satisfaction'],
+            feedback_data['missing_features'],
+            feedback_data['improvement_suggestions'],
+            feedback_data['user_experience'],
+            datetime.now()
+        ))
+        conn.commit()
+        conn.close()
+
+    def get_feedback_stats(self):
+        """Get feedback statistics"""
+        conn = sqlite3.connect(self.db_path)
+        df = pd.read_sql_query("SELECT * FROM feedback", conn)
+        conn.close()
+        
+        if df.empty:
+            return {
+                'avg_rating': 0,
+                'avg_usability': 0,
+                'avg_satisfaction': 0,
+                'total_responses': 0
+            }
+        
+        return {
+            'avg_rating': df['rating'].mean(),
+            'avg_usability': df['usability_score'].mean(),
+            'avg_satisfaction': df['feature_satisfaction'].mean(),
+            'total_responses': len(df)
+        }
+
+    def render_feedback_form(self):
+        """Render the feedback form"""
+        st.markdown("""
+            <style>
+            @import url('https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css');
+            
+            .feedback-container {
+                background: rgba(255, 255, 255, 0.05);
+                backdrop-filter: blur(10px);
+                padding: 30px;
+                border-radius: 20px;
+                margin: 20px 0;
+                border: 1px solid rgba(255, 255, 255, 0.1);
+                box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+            }
+            
+            .feedback-header {
+                color: #E0E0E0;
+                font-size: 1.5em;
+                font-weight: 600;
+                margin-bottom: 25px;
+                text-align: center;
+                padding: 15px;
+                background: linear-gradient(135deg, #4CAF50, #2196F3);
+                border-radius: 12px;
+                box-shadow: 0 4px 15px rgba(76, 175, 80, 0.2);
+            }
+            
+            .feedback-section {
+                margin: 20px 0;
+                padding: 20px;
+                border-radius: 15px;
+                background: rgba(255, 255, 255, 0.03);
+                border: 1px solid rgba(255, 255, 255, 0.1);
+                transition: transform 0.3s ease, box-shadow 0.3s ease;
+            }
+            
+            .feedback-section:hover {
+                transform: translateY(-5px);
+                box-shadow: 0 5px 15px rgba(0, 0, 0, 0.2);
+            }
+            
+            .feedback-label {
+                color: #E0E0E0;
+                font-size: 1.1em;
+                font-weight: 500;
+                margin-bottom: 10px;
+            }
+            
+            .star-rating {
+                font-size: 24px;
+                color: #FFD700;
+                cursor: pointer;
+                transition: transform 0.2s ease;
+            }
+            
+            .star-rating:hover {
+                transform: scale(1.1);
+            }
+            
+            .rating-container {
+                display: flex;
+                align-items: center;
+                gap: 10px;
+                margin: 15px 0;
+            }
+            
+            .submit-button {
+                background: linear-gradient(135deg, #4CAF50, #2196F3);
+                color: white;
+                padding: 12px 25px;
+                border: none;
+                border-radius: 8px;
+                font-weight: 600;
+                cursor: pointer;
+                transition: all 0.3s ease;
+                text-transform: uppercase;
+                letter-spacing: 1px;
+                width: 100%;
+                margin-top: 20px;
+            }
+            
+            .submit-button:hover {
+                transform: translateY(-2px);
+                box-shadow: 0 5px 15px rgba(33, 150, 243, 0.3);
+            }
+            
+            .textarea-container {
+                background: rgba(255, 255, 255, 0.03);
+                border: 1px solid rgba(255, 255, 255, 0.1);
+                border-radius: 8px;
+                padding: 10px;
+                margin-top: 10px;
+            }
+            
+            .textarea-container textarea {
+                width: 100%;
+                min-height: 100px;
+                background: transparent;
+                border: none;
+                color: #E0E0E0;
+                font-size: 1em;
+                resize: vertical;
+            }
+            </style>
+            """, unsafe_allow_html=True)
+
+        st.markdown('<div class="feedback-container">', unsafe_allow_html=True)
+        st.markdown('<h2 class="feedback-header">📝 Share Your Feedback</h2>', unsafe_allow_html=True)
+
+        # Overall Rating
+        st.markdown('<div class="feedback-section">', unsafe_allow_html=True)
+        st.markdown('<label class="feedback-label">Overall Experience Rating</label>', unsafe_allow_html=True)
+        rating = st.slider("Overall Rating", 1, 5, 5, help="Rate your overall experience with the app", label_visibility="collapsed")
+        st.markdown(f'<div class="rating-container">{"⭐" * rating}</div>', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+
+        # Usability Score
+        st.markdown('<div class="feedback-section">', unsafe_allow_html=True)
+        st.markdown('<label class="feedback-label">How easy was it to use our app?</label>', unsafe_allow_html=True)
+        usability_score = st.slider("Usability Score", 1, 5, 5, help="Rate the app's ease of use", label_visibility="collapsed")
+        st.markdown(f'<div class="rating-container">{"⭐" * usability_score}</div>', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+
+        # Feature Satisfaction
+        st.markdown('<div class="feedback-section">', unsafe_allow_html=True)
+        st.markdown('<label class="feedback-label">How satisfied are you with our features?</label>', unsafe_allow_html=True)
+        feature_satisfaction = st.slider("Feature Satisfaction", 1, 5, 5, help="Rate your satisfaction with the app's features", label_visibility="collapsed")
+        st.markdown(f'<div class="rating-container">{"⭐" * feature_satisfaction}</div>', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+
+        # Text Feedback
+        st.markdown('<div class="feedback-section">', unsafe_allow_html=True)
+        st.markdown('<label class="feedback-label">What features would you like to see added?</label>', unsafe_allow_html=True)
+        missing_features = st.text_area("Missing Features", placeholder="Share your feature requests...", label_visibility="collapsed")
+
+        st.markdown('<label class="feedback-label">How can we improve?</label>', unsafe_allow_html=True)
+        improvement_suggestions = st.text_area("Improvement Suggestions", placeholder="Your suggestions for improvement...", label_visibility="collapsed")
+
+        st.markdown('<label class="feedback-label">Tell us about your experience</label>', unsafe_allow_html=True)
+        user_experience = st.text_area("User Experience", placeholder="Share your experience with us...", label_visibility="collapsed")
+        st.markdown('</div>', unsafe_allow_html=True)
+
+        # Submit Button
+        if st.button("Submit Feedback", key="submit_feedback"):
+            try:
+                # Create progress bar
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                # Simulate processing with animation
+                for i in range(100):
+                    progress_bar.progress(i + 1)
+                    if i < 30:
+                        status_text.text("Processing feedback... 📝")
+                    elif i < 60:
+                        status_text.text("Analyzing responses... 🔍")
+                    elif i < 90:
+                        status_text.text("Saving to database... 💾")
+                    else:
+                        status_text.text("Finalizing... ✨")
+                    time.sleep(0.01)
+
+                # Save feedback
+                feedback_data = {
+                    'rating': rating,
+                    'usability_score': usability_score,
+                    'feature_satisfaction': feature_satisfaction,
+                    'missing_features': missing_features,
+                    'improvement_suggestions': improvement_suggestions,
+                    'user_experience': user_experience
+                }
+                self.save_feedback(feedback_data)
+                
+                # Clear progress elements
+                progress_bar.empty()
+                status_text.empty()
+                
+                # Show success message with animation
+                success_container = st.empty()
+                success_container.markdown("""
+                    <div style="text-align: center; padding: 20px; background: linear-gradient(90deg, rgba(76, 175, 80, 0.1), rgba(33, 150, 243, 0.1)); border-radius: 10px;">
+                        <h2 style="color: #4CAF50;">Thank You! 🎉</h2>
+                        <p style="color: #E0E0E0;">Your feedback helps us improve Smart Resume AI</p>
+                    </div>
+                """, unsafe_allow_html=True)
+                
+                # Show balloons animation
+                st.balloons()
+                
+                # Keep success message visible
+                time.sleep(2)
+                
+            except Exception as e:
+                st.error(f"Error submitting feedback: {str(e)}")
+
+    def render_feedback_stats(self):
+        """Render feedback statistics"""
+        stats = self.get_feedback_stats()
+        
+        st.markdown("""
+            <div style="text-align: center; padding: 15px; background: linear-gradient(90deg, rgba(76, 175, 80, 0.1), rgba(33, 150, 243, 0.1)); border-radius: 10px; margin-bottom: 20px;">
+                <h3 style="color: #E0E0E0;">Feedback Overview 📊</h3>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        cols = st.columns(4)
+        metrics = [
+            {"label": "Total Responses", "value": f"{stats['total_responses']:,}", "delta": "↗"},
+            {"label": "Avg Rating", "value": f"{stats['avg_rating']:.1f}/5.0", "delta": "⭐"},
+            {"label": "Usability Score", "value": f"{stats['avg_usability']:.1f}/5.0", "delta": "🎯"},
+            {"label": "Satisfaction", "value": f"{stats['avg_satisfaction']:.1f}/5.0", "delta": "😊"}
+        ]
+        
+        for col, metric in zip(cols, metrics):
+            col.markdown(f"""
+                <div style="background: rgba(255, 255, 255, 0.05); padding: 15px; border-radius: 8px; text-align: center;">
+                    <div style="color: #B0B0B0; font-size: 0.9em;">{metric['label']}</div>
+                    <div style="font-size: 1.5em; color: #4CAF50; margin: 5px 0;">{metric['value']}</div>
+                    <div style="color: #E0E0E0; font-size: 1.2em;">{metric['delta']}</div>
+                </div>
+            """, unsafe_allow_html=True)

feedback/schema.sql

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS feedback (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    rating INTEGER NOT NULL,
+    usability_score INTEGER NOT NULL,
+    feature_satisfaction INTEGER NOT NULL,
+    missing_features TEXT,
+    improvement_suggestions TEXT,
+    user_experience TEXT,
+    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+);

jobs/companies.py

@@ -0,0 +1,187 @@
+"""Company data and market insights for job search"""
+
+FEATURED_COMPANIES = {
+    "tech": [
+        {
+            "name": "Google",
+            "icon": "fab fa-google",
+            "color": "#4285F4",
+            "careers_url": "https://careers.google.com",
+            "description": "Leading technology company known for search, cloud, and innovation",
+            "categories": ["Software", "AI/ML", "Cloud", "Data Science"]
+        },
+        {
+            "name": "Microsoft",
+            "icon": "fab fa-microsoft",
+            "color": "#00A4EF",
+            "careers_url": "https://careers.microsoft.com",
+            "description": "Global leader in software, cloud, and enterprise solutions",
+            "categories": ["Software", "Cloud", "Gaming", "Enterprise"]
+        },
+        {
+            "name": "Amazon",
+            "icon": "fab fa-amazon",
+            "color": "#FF9900",
+            "careers_url": "https://www.amazon.jobs",
+            "description": "E-commerce and cloud computing giant",
+            "categories": ["Software", "Operations", "Cloud", "Retail"]
+        },
+        {
+            "name": "Apple",
+            "icon": "fab fa-apple",
+            "color": "#555555",
+            "careers_url": "https://www.apple.com/careers",
+            "description": "Innovation leader in consumer technology",
+            "categories": ["Software", "Hardware", "Design", "AI/ML"]
+        },
+        {
+            "name": "Facebook",
+            "icon": "fab fa-facebook",
+            "color": "#1877F2",
+            "careers_url": "https://www.metacareers.com/",
+            "description": "Social media and technology company",
+            "categories": ["Software", "Marketing", "Networking", "AI/ML"]
+        },
+        {
+            "name": "Netflix",
+            "icon": "fas fa-play-circle",
+            "color": "#E50914",
+            "careers_url": "https://explore.jobs.netflix.net/careers",
+            "description": "Streaming media company",
+            "categories": ["Software", "Marketing", "Design", "Service"],
+            "logo_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/0/08/Netflix_2015_logo.svg/1920px-Netflix_2015_logo.svg.png",
+            "website": "https://jobs.netflix.com/",
+            "industry": "Entertainment & Technology"
+        }
+    ],
+    "indian_tech": [
+        {
+            "name": "TCS",
+            "icon": "fas fa-building",
+            "color": "#0070C0",
+            "careers_url": "https://www.tcs.com/careers",
+            "description": "India's largest IT services company",
+            "categories": ["IT Services", "Consulting", "Digital"]
+        },
+        {
+            "name": "Infosys",
+            "icon": "fas fa-building",
+            "color": "#007CC3",
+            "careers_url": "https://www.infosys.com/careers",
+            "description": "Global leader in digital services and consulting",
+            "categories": ["IT Services", "Consulting", "Digital"]
+        },
+        {
+            "name": "Wipro",
+            "icon": "fas fa-building",
+            "color": "#341F65",
+            "careers_url": "https://careers.wipro.com",
+            "description": "Leading global information technology company",
+            "categories": ["IT Services", "Consulting", "Digital"]
+        },
+        {
+            "name": "HCL",
+            "icon": "fas fa-building",
+            "color": "#0075C9",
+            "careers_url": "https://www.hcltech.com/careers",
+            "description": "Global technology company",
+            "categories": ["IT Services", "Engineering", "Digital"]
+        }
+    ],
+    "global_corps": [
+        {
+            "name": "IBM",
+            "icon": "fas fa-server",
+            "color": "#1F70C1",
+            "careers_url": "https://www.ibm.com/careers",
+            "description": "Global leader in technology and consulting",
+            "categories": ["Software", "Consulting", "AI/ML", "Cloud"],
+            "logo_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/5/51/IBM_logo.svg/1920px-IBM_logo.svg.png",
+            "website": "https://www.ibm.com/careers/",
+            "industry": "Technology & Consulting"
+        },
+        {
+            "name": "Accenture",
+            "icon": "fas fa-building",
+            "color": "#A100FF",
+            "careers_url": "https://www.accenture.com/careers",
+            "description": "Global professional services company",
+            "categories": ["Consulting", "Technology", "Digital"]
+        },
+        {
+            "name": "Cognizant",
+            "icon": "fas fa-building",
+            "color": "#1299D8",
+            "careers_url": "https://careers.cognizant.com",
+            "description": "Leading professional services company",
+            "categories": ["IT Services", "Consulting", "Digital"]
+        }
+    ]
+}
+
+JOB_MARKET_INSIGHTS = {
+    "trending_skills": [
+        {"name": "Artificial Intelligence", "growth": "+45%", "icon": "fas fa-brain"},
+        {"name": "Cloud Computing", "growth": "+38%", "icon": "fas fa-cloud"},
+        {"name": "Data Science", "growth": "+35%", "icon": "fas fa-chart-line"},
+        {"name": "Cybersecurity", "growth": "+32%", "icon": "fas fa-shield-alt"},
+        {"name": "DevOps", "growth": "+30%", "icon": "fas fa-code-branch"},
+        {"name": "Machine Learning", "growth": "+28%", "icon": "fas fa-robot"},
+        {"name": "Blockchain", "growth": "+25%", "icon": "fas fa-lock"},
+        {"name": "Big Data", "growth": "+23%", "icon": "fas fa-database"},
+        {"name": "Internet of Things", "growth": "+21%", "icon": "fas fa-wifi"}
+    ],
+    "top_locations": [
+        {"name": "Bangalore", "jobs": "50,000+", "icon": "fas fa-city"},
+        {"name": "Mumbai", "jobs": "35,000+", "icon": "fas fa-city"},
+        {"name": "Delhi NCR", "jobs": "30,000+", "icon": "fas fa-city"},
+        {"name": "Hyderabad", "jobs": "25,000+", "icon": "fas fa-city"},
+        {"name": "Pune", "jobs": "20,000+", "icon": "fas fa-city"},
+        {"name": "Chennai", "jobs": "15,000+", "icon": "fas fa-city"},
+        {"name": "Noida", "jobs": "10,000+", "icon": "fas fa-city"},
+        {"name": "Vadodara", "jobs": "7,000+", "icon": "fas fa-city"},
+        {"name": "Ahmedabad", "jobs": "6,000+", "icon": "fas fa-city"},
+        {"name": "Remote", "jobs": "3,000+", "icon": "fas fa-globe-americas"},
+    ],
+    "salary_insights": [
+        {"role": "Machine Learning Engineer", "range": "10-35 LPA", "experience": "0-5 years"},
+        {"role": "Big Data Engineer", "range": "8-30 LPA", "experience": "0-5 years"},
+        {"role": "Software Engineer", "range": "5-25 LPA", "experience": "0-5 years"},
+        {"role": "Data Scientist", "range": "8-30 LPA", "experience": "0-5 years"},
+        {"role": "DevOps Engineer", "range": "6-28 LPA", "experience": "0-5 years"},
+        {"role": "UI/UX Designer", "range": "5-25 LPA", "experience": "0-5 years"},
+        {"role": "Full Stack Developer", "range": "8-30 LPA", "experience": "0-5 years"},
+        {"role": "C++/C#/Python/Java Developer", "range": "6-26 LPA", "experience": "0-5 years"},
+        {"role": "Django Developer", "range": "7-27 LPA", "experience": "0-5 years"},
+        {"role": "Cloud Engineer", "range": "6-26 LPA", "experience": "0-5 years"},
+        {"role": "Google Cloud/AWS/Azure Engineer", "range": "6-26 LPA", "experience": "0-5 years"},
+        {"role": "Salesforce Engineer", "range": "6-26 LPA", "experience": "0-5 years"},
+    ]
+}
+
+def get_featured_companies(category=None):
+    """Get featured companies, optionally filtered by category"""
+    if category and category in FEATURED_COMPANIES:
+        return FEATURED_COMPANIES[category]
+    return [company for companies in FEATURED_COMPANIES.values() for company in companies]
+
+def get_market_insights():
+    """Get job market insights"""
+    return JOB_MARKET_INSIGHTS
+
+def get_company_info(company_name):
+    """Get company information by name"""
+    for companies in FEATURED_COMPANIES.values():
+        for company in companies:
+            if company["name"] == company_name:
+                return company
+    return None
+
+def get_companies_by_industry(industry):
+    """Get list of companies by industry"""
+    companies = []
+    for companies_list in FEATURED_COMPANIES.values():
+        for company in companies_list:
+            if "industry" in company and company["industry"] == industry:
+                companies.append(company)
+    return companies

jobs/job_portals.py

@@ -0,0 +1,288 @@
+"""Module for handling job portal integrations"""
+import urllib.parse
+from typing import Dict, List
+from .suggestions import LOCATION_SUGGESTIONS, get_cities_by_state
+
+class JobPortal:
+    """Class for searching jobs across multiple job portals"""
+    
+    def __init__(self):
+        """Initialize job portal URLs and parameters"""
+        self.portals = [
+            {
+                "name": "LinkedIn",
+                "icon": "fab fa-linkedin",
+                "color": "#0A66C2",
+                "url": "https://www.linkedin.com/jobs/search/?keywords={}&location={}&f_E={}",
+                "experience_param": ""
+            },
+            {
+                "name": "Naukri",
+                "icon": "fas fa-building",
+                "color": "#FF7555",
+                "url": "https://www.naukri.com/{}-jobs-in-{}?experience={}",
+                "experience_param": ""
+            },
+            {
+                "name": "Foundit (Monster)",
+                "icon": "fas fa-globe",
+                "color": "#5D3FD3",
+                "url": "https://www.foundit.in/srp/results?query={}&locations={}",
+                "experience_param": ""
+            },
+            {
+                "name": "FreshersWorld",
+                "icon": "fas fa-graduation-cap",
+                "color": "#003A9B",
+                "url": "https://www.freshersworld.com/jobs/jobsearch/{}-jobs-in-{}",
+                "experience_param": ""
+            },
+            {
+                "name": "TimesJobs",
+                "icon": "fas fa-briefcase",
+                "color": "#003A9B",
+                "url": "https://www.timesjobs.com/candidate/job-search.html?searchType=personalizedSearch&from=submit&txtKeywords={}&txtLocation={}",
+                "experience_param": ""
+            },
+            {
+                "name": "Instahyre",
+                "icon": "fas fa-user-tie",
+                "color": "#003A9B",
+                "url": "https://www.instahyre.com/{}-jobs-in-{}",
+                "experience_param": ""
+            },
+            {
+                "name": "Indeed",
+                "icon": "fas fa-search-dollar",
+                "color": "#003A9B",
+                "url": "https://in.indeed.com/jobs?q={}&l={}&explvl={}",
+                "experience_param": ""
+            }
+        ]
+
+    def get_portal_list(self) -> List[Dict]:
+        """Get list of available job portals"""
+        return self.portals
+
+    def format_query(self, query: str) -> str:
+        """Format query string for URLs"""
+        # Replace spaces with appropriate characters based on portal
+        return query.replace(" ", "+")
+
+    def format_location(self, location: str) -> str:
+        """Format location string for URLs"""
+        if not location:
+            return ""
+            
+        # Check if location is a state
+        location = location.strip()
+        is_state = False
+        
+        # Check if the location is a state
+        for loc in LOCATION_SUGGESTIONS:
+            if loc.get("type") == "state" and loc.get("text").lower() == location.lower():
+                is_state = True
+                break
+        
+        # If it's a state, get the major city in that state for better job results
+        if is_state:
+            cities = get_cities_by_state(location)
+            if cities:
+                # Use the first city in the state (usually the capital or major city)
+                location = cities[0]["text"]
+        
+        # Convert to lowercase and replace spaces with hyphens
+        return location.lower().replace(" ", "-")
+
+    def format_job_title(self, title: str) -> str:
+        """Format job title for URLs"""
+        # Remove common words and special characters
+        title = title.lower()
+        title = title.replace("developer", "").replace("engineer", "").strip()
+        title = title.replace(" ", "-")
+        return title.strip("-")
+
+    def format_experience(self, experience: str) -> tuple:
+        """Format experience for different job portals"""
+        if not experience or experience == "all":
+            return "", "0", "0", "entry"
+        
+        try:
+            # Handle dictionary input
+            if isinstance(experience, dict):
+                exp_id = experience.get('id', 'all')
+                if exp_id == 'all':
+                    return "", "0", "0", "entry"
+                
+                # Split experience range (e.g., "1-3" -> ["1", "3"])
+                if "-" in exp_id:
+                    exp_min, exp_max = exp_id.split('-')
+                    if exp_max == "+":
+                        exp_max = "15"  # Set a reasonable maximum for 10+ years
+                else:
+                    # Handle "fresher" or other non-range values
+                    exp_min = "0"
+                    exp_max = "1"
+                
+                # Map to portal-specific format
+                exp_level = {
+                    "fresher": "0",
+                    "0-1": "0",
+                    "1-3": "1",
+                    "3-5": "2",
+                    "5-7": "3",
+                    "7-10": "4",
+                    "10+": "5"
+                }.get(exp_id, "0")
+                
+                return exp_level, exp_min, exp_max, "entry" if exp_min == "0" else "experienced"
+            
+            return "", "0", "0", "entry"
+            
+        except Exception as e:
+            print(f"Error formatting experience: {str(e)}")
+            return "", "0", "0", "entry"
+
+    def get_experience_param(self, portal_name, experience):
+        """Get experience parameter for specific portal"""
+        experience_id = experience.get("id", "all")
+        
+        if experience_id == "all":
+            if portal_name == "Foundit (Monster)":
+                return ""
+            elif portal_name == "Naukri":
+                return ""
+            elif portal_name == "LinkedIn":
+                return ""
+            elif portal_name == "Indeed":
+                return "entry_level"
+        
+        if portal_name == "Foundit (Monster)":
+            if experience_id == "fresher":
+                return "&experienceRanges=0~0"
+            elif experience_id == "0-1":
+                return "&experienceRanges=0~1"
+            elif experience_id == "1-3":
+                return "&experienceRanges=1~3"
+            elif experience_id == "3-5":
+                return "&experienceRanges=3~5"
+            elif experience_id == "5-7":
+                return "&experienceRanges=5~7"
+            elif experience_id == "7-10":
+                return "&experienceRanges=7~10"
+            elif experience_id == "10+":
+                return "&experienceRanges=10~50"
+        
+        elif portal_name == "Naukri":
+            if experience_id == "fresher":
+                return "0"
+            elif experience_id == "0-1":
+                return "0-1"
+            elif experience_id == "1-3":
+                return "1-3"
+            elif experience_id == "3-5":
+                return "3-5"
+            elif experience_id == "5-7":
+                return "5-7"
+            elif experience_id == "7-10":
+                return "7-10"
+            elif experience_id == "10+":
+                return "10-50"
+        
+        elif portal_name == "LinkedIn":
+            if experience_id == "fresher" or experience_id == "0-1":
+                return "1"  # Entry level
+            elif experience_id == "1-3" or experience_id == "3-5":
+                return "2"  # Associate
+            elif experience_id == "5-7" or experience_id == "7-10":
+                return "3"  # Mid-Senior level
+            elif experience_id == "10+":
+                return "4"  # Director
+        
+        elif portal_name == "Indeed":
+            if experience_id == "fresher" or experience_id == "0-1":
+                return "entry_level"
+            elif experience_id == "1-3" or experience_id == "3-5":
+                return "mid_level"
+            elif experience_id == "5-7" or experience_id == "7-10" or experience_id == "10+":
+                return "senior_level"
+        
+        return ""
+
+    def search_jobs(self, job_title, location, experience=None):
+        """Search jobs across multiple portals"""
+        if not experience:
+            experience = {"id": "all", "text": "All Levels"}
+        
+        results = []
+        
+        for portal in self.portals:
+            portal_name = portal["name"]
+            
+            # Format job title based on portal
+            if portal_name == "Foundit (Monster)":
+                formatted_job = job_title.replace(' ', '+')
+            elif portal_name == "Naukri":
+                formatted_job = self.format_job_title(job_title)
+            elif portal_name == "Glassdoor":
+                # For Glassdoor, format job title with + signs
+                formatted_job = job_title.replace(' ', '+')
+            elif portal_name in ["LinkedIn", "Indeed", "TimesJobs"]:
+                formatted_job = job_title.replace(' ', '%20')
+            elif portal_name in ["FreshersWorld", "Instahyre"]:
+                formatted_job = job_title.lower().replace(' ', '-')
+            else:
+                formatted_job = job_title
+            
+            # Format location based on portal
+            if portal_name == "Foundit (Monster)":
+                formatted_location = location.replace(' ', '+') if location else "India"
+            elif portal_name == "Naukri":
+                formatted_location = self.format_location(location) if location else "india"
+            elif portal_name == "Glassdoor":
+                # For Glassdoor, keep spaces in location name
+                formatted_location = location if location else "India"
+            elif portal_name in ["LinkedIn", "Indeed", "TimesJobs"]:
+                formatted_location = location.replace(' ', '%20') if location else "India"
+            elif portal_name in ["FreshersWorld", "Instahyre"]:
+                formatted_location = location.lower().replace(' ', '-') if location else "india"
+            else:
+                formatted_location = location if location else "India"
+            
+            # Get experience parameter
+            exp_param = self.get_experience_param(portal_name, experience)
+            
+            # Build URL based on portal
+            try:
+                if portal_name == "Foundit (Monster)":
+                    url = portal["url"].format(formatted_job, formatted_location)
+                    if exp_param:
+                        url += exp_param
+                elif portal_name == "Naukri":
+                    url = portal["url"].format(formatted_job, formatted_location, exp_param)
+                elif portal_name == "LinkedIn":
+                    url = portal["url"].format(formatted_job, formatted_location, exp_param)
+                elif portal_name == "Indeed":
+                    url = portal["url"].format(formatted_job, formatted_location, exp_param)
+                elif portal_name == "Glassdoor":
+                    # For Glassdoor, location comes first, then job title (occ parameter)
+                    url = portal["url"].format(formatted_location, formatted_job)
+                elif portal_name in ["TimesJobs"]:
+                    url = portal["url"].format(formatted_job, formatted_location)
+                elif portal_name in ["FreshersWorld", "Instahyre"]:
+                    url = portal["url"].format(formatted_job, formatted_location)
+                else:
+                    url = portal["url"]
+                
+                results.append({
+                    "portal": portal_name,
+                    "icon": portal["icon"],
+                    "color": portal["color"],
+                    "title": f"{job_title} jobs in {location if location else 'India'}",
+                    "url": url
+                })
+            except Exception as e:
+                print(f"Error creating URL for {portal_name}: {str(e)}")
+                continue
+        
+        return results

jobs/job_search.py

@@ -0,0 +1,510 @@
+import streamlit as st
+from typing import List, Dict
+from .job_portals import JobPortal
+from .suggestions import (
+    JOB_SUGGESTIONS, 
+    LOCATION_SUGGESTIONS, 
+    EXPERIENCE_RANGES,
+    SALARY_RANGES,
+    JOB_TYPES,
+    get_cities_by_state,
+    get_all_states
+)
+from .companies import get_featured_companies, get_market_insights
+from .linkedin_scraper import render_linkedin_scraper
+from streamlit_extras.add_vertical_space import add_vertical_space
+from streamlit_option_menu import option_menu
+
+def filter_suggestions(query: str, suggestions: List[Dict]) -> List[Dict]:
+    """Filter suggestions based on user input"""
+    if not query:
+        return []
+    return [
+        s for s in suggestions 
+        if query.lower() in s["text"].lower()
+    ][:5]
+
+def filter_location_suggestions(query: str, suggestions: List[Dict]) -> List[Dict]:
+    """Filter location suggestions based on user input with smart categorization"""
+    if not query or len(query) < 2:
+        return []
+        
+    # First check if query matches any state
+    matching_states = [s for s in suggestions if s.get("type") == "state" and query.lower() in s["text"].lower()]
+    
+    # Then check cities
+    matching_cities = [s for s in suggestions if s.get("type") == "city" and query.lower() in s["text"].lower()]
+    
+    # Then check work modes
+    matching_work_modes = [s for s in suggestions if s.get("type") == "work_mode" and query.lower() in s["text"].lower()]
+    
+    # Combine results with states first, then major cities, then other matches
+    results = matching_states + matching_cities + matching_work_modes
+    return results[:7]  # Return top 7 matches
+
+def get_filter_options():
+    """Get filter options for job search"""
+    return {
+        "experience_levels": [
+            {"id": "all", "text": "All Levels"},
+            {"id": "fresher", "text": "Fresher"},
+            {"id": "0-1", "text": "0-1 years"},
+            {"id": "1-3", "text": "1-3 years"},
+            {"id": "3-5", "text": "3-5 years"},
+            {"id": "5-7", "text": "5-7 years"},
+            {"id": "7-10", "text": "7-10 years"},
+            {"id": "10+", "text": "10+ years"}
+        ],
+        "salary_ranges": [
+            {"id": "all", "text": "All Ranges"},
+            {"id": "0-3", "text": "0-3 LPA"},
+            {"id": "3-6", "text": "3-6 LPA"},
+            {"id": "6-10", "text": "6-10 LPA"},
+            {"id": "10-15", "text": "10-15 LPA"},
+            {"id": "15+", "text": "15+ LPA"}
+        ],
+        "job_types": [
+            {"id": "all", "text": "All Types"},
+            {"id": "full-time", "text": "Full Time"},
+            {"id": "part-time", "text": "Part Time"},
+            {"id": "contract", "text": "Contract"},
+            {"id": "remote", "text": "Remote"}
+        ]
+    }
+
+def render_company_section():
+    """Render the featured companies section"""
+    st.markdown("""
+        <style>
+        .company-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
+            gap: 1rem;
+            padding: 1rem 0;
+        }
+        .company-card {
+            background: rgba(255, 255, 255, 0.05);
+            border-radius: 10px;
+            padding: 1rem;
+            transition: transform 0.2s;
+            cursor: pointer;
+        }
+        .company-card:hover {
+            transform: translateY(-5px);
+            background: rgba(255, 255, 255, 0.08);
+        }
+        .company-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 0.5rem;
+        }
+        .company-icon {
+            font-size: 1.5rem;
+            margin-right: 0.5rem;
+        }
+        .company-categories {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 0.5rem;
+            margin-top: 0.5rem;
+        }
+        .company-category {
+            background: rgba(255, 255, 255, 0.1);
+            padding: 0.2rem 0.5rem;
+            border-radius: 15px;
+            font-size: 0.8rem;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    # Featured Companies
+    st.markdown("### 🏢 Featured Companies")
+    
+    tabs = st.tabs(["All Companies", "Tech Giants", "Indian Tech", "Global Corps"])
+    
+    categories = [None, "tech", "indian_tech", "global_corps"]
+    for tab, category in zip(tabs, categories):
+        with tab:
+            companies = get_featured_companies(category)
+            st.markdown('<div class="company-grid">', unsafe_allow_html=True)
+            
+            for company in companies:
+                st.markdown(f"""
+                    <a href="{company['careers_url']}" target="_blank" style="text-decoration: none; color: inherit;">
+                        <div class="company-card">
+                            <div class="company-header">
+                                <i class="{company['icon']} company-icon" style="color: {company['color']}"></i>
+                                <h3 style="margin: 0;">{company['name']}</h3>
+                            </div>
+                            <p style="margin: 0.5rem 0; color: #888;">{company['description']}</p>
+                            <div class="company-categories">
+                                {' '.join(f'<span class="company-category">{cat}</span>' for cat in company['categories'])}
+                            </div>
+                        </div>
+                    </a>
+                """, unsafe_allow_html=True)
+            
+            st.markdown('</div>', unsafe_allow_html=True)
+
+def render_market_insights():
+    """Render job market insights section"""
+    insights = get_market_insights()
+    
+    st.markdown("""
+        <style>
+        .insights-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+            gap: 1rem;
+            padding: 1rem 0;
+        }
+        .insight-card {
+            background: rgba(255, 255, 255, 0.05);
+            border-radius: 10px;
+            padding: 1rem;
+            text-align: center;
+            transition: transform 0.3s ease, background 0.3s ease;
+        }
+        .insight-card:hover {
+            transform: translateY(-5px);
+            background: rgba(255, 255, 255, 0.08);
+        }
+        .insight-icon {
+            font-size: 2rem;
+            margin-bottom: 0.5rem;
+            color: #00bfa5;
+        }
+        .growth-text {
+            color: #00c853;
+            font-weight: bold;
+        }
+        .salary-card {
+            background: rgba(255, 255, 255, 0.05);
+            border-radius: 15px;
+            padding: 1.5rem;
+            margin-bottom: 1rem;
+            transition: all 0.3s ease;
+            border-left: 4px solid #00bfa5;
+        }
+        .salary-card:hover {
+            transform: translateX(10px);
+            background: rgba(255, 255, 255, 0.08);
+        }
+        .salary-header {
+            display: flex;
+            align-items: center;
+            margin-bottom: 1rem;
+        }
+        .role-icon {
+            font-size: 1.5rem;
+            margin-right: 1rem;
+            color: #00bfa5;
+        }
+        .salary-details {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-top: 0.5rem;
+        }
+        .salary-tag {
+            background: rgba(0, 191, 165, 0.1);
+            color: #00bfa5;
+            padding: 0.3rem 0.8rem;
+            border-radius: 20px;
+            font-size: 0.9rem;
+        }
+        .experience-tag {
+            background: rgba(255, 255, 255, 0.1);
+            padding: 0.3rem 0.8rem;
+            border-radius: 20px;
+            font-size: 0.9rem;
+        }
+        .role-title {
+            font-size: 1.2rem;
+            font-weight: bold;
+            margin: 0;
+        }
+        .salary-range {
+            font-size: 1.1rem;
+            color: #00bfa5;
+            font-weight: bold;
+        }
+        .role-icons {
+            font-family: "Font Awesome 5 Free";
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    st.markdown("### 📊 Job Market Insights")
+    
+    tabs = st.tabs(["Trending Skills", "Top Locations", "Salary Insights"])
+    
+    with tabs[0]:
+        st.markdown('<div class="insights-grid">', unsafe_allow_html=True)
+        for skill in insights["trending_skills"]:
+            st.markdown(f"""
+                <div class="insight-card">
+                    <i class="{skill['icon']} insight-icon"></i>
+                    <h4>{skill['name']}</h4>
+                    <p class="growth-text">Growth: {skill['growth']}</p>
+                </div>
+            """, unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    with tabs[1]:
+        st.markdown('<div class="insights-grid">', unsafe_allow_html=True)
+        for location in insights["top_locations"]:
+            st.markdown(f"""
+                <div class="insight-card">
+                    <i class="{location['icon']} insight-icon"></i>
+                    <h4>{location['name']}</h4>
+                    <p>Available Jobs: {location['jobs']}</p>
+                </div>
+            """, unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    with tabs[2]:
+        # Role-specific icons
+        role_icons = {
+            "Software Engineer": "fas fa-code",
+            "Data Scientist": "fas fa-brain",
+            "Product Manager": "fas fa-tasks",
+            "DevOps Engineer": "fas fa-server",
+            "UI/UX Designer": "fas fa-paint-brush"
+        }
+        
+        for insight in insights["salary_insights"]:
+            role = insight['role']
+            icon = role_icons.get(role, "fas fa-briefcase")
+            
+            st.markdown(f"""
+                <div class="salary-card">
+                    <div class="salary-header">
+                        <i class="{icon} role-icon"></i>
+                        <div>
+                            <h3 class="role-title">{role}</h3>
+                            <div class="salary-details">
+                                <span class="salary-tag">₹ {insight['range']}</span>
+                                <span class="experience-tag">
+                                    <i class="fas fa-history"></i> {insight['experience']}
+                                </span>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            """, unsafe_allow_html=True)
+
+def render_job_search():
+    """Render job search page with enhanced features"""
+    st.title("🔍 Smart Job Search")
+    st.markdown("Find Your Dream Job Across Multiple Platforms")
+    
+    # Market Insights Section (Above Search)
+    render_market_insights()
+    
+    # Job Search Section
+    with st.container():
+        st.markdown("""
+            <style>
+            .search-container {
+                background: rgba(255, 255, 255, 0.05);
+                border-radius: 10px;
+                padding: 20px;
+                margin-bottom: 20px;
+            }
+            .search-title {
+                color: #00bfa5;
+                font-weight: bold;
+                margin-bottom: 5px;
+            }
+            .search-description {
+                color: #888;
+                font-size: 0.9rem;
+                margin-bottom: 20px;
+            }
+            </style>
+        """, unsafe_allow_html=True)
+        
+        st.markdown('<div class="search-container">', unsafe_allow_html=True)
+        
+        # Create tabs with icons
+        tabs = option_menu(
+            menu_title=None,
+            options=["Job Portal", "LinkedIn"],
+            icons=["search", "linkedin"],
+            menu_icon="cast",
+            default_index=0,
+            orientation="horizontal",
+            styles={
+                "container": {"padding": "0px", "margin-bottom": "20px"},
+                "icon": {"font-size": "18px"},
+                "nav-link": {"font-size": "16px", "text-align": "center", "padding": "10px", "border-radius": "5px"},
+                "nav-link-selected": {"background-color": "#00bfa5", "font-weight": "bold"},
+            }
+        )
+        
+        # Display content based on selected tab
+        if tabs == "Job Portal":
+            st.markdown('<h3 class="search-title"><i class="fas fa-search-dollar" style="color: #00bfa5;"></i> Search Jobs Across Multiple Platforms</h3>', unsafe_allow_html=True)
+            st.markdown('<p class="search-description">Find job opportunities from top job portals like LinkedIn, Indeed, Naukri, and Foundit</p>', unsafe_allow_html=True)
+            
+            # Search inputs
+            col1, col2 = st.columns([2, 1])
+            
+            with col1:
+                job_query = st.text_input("Job Title / Skills", 
+                                        value="", 
+                                        placeholder="e.g. Software Engineer, Data Scientist")
+                
+                if job_query and len(job_query) >= 2:
+                    filtered_jobs = [s["text"] for s in JOB_SUGGESTIONS if job_query.lower() in s["text"].lower()]
+                    if filtered_jobs:
+                        job_query = st.selectbox("Select Job Title", filtered_jobs)
+            
+            with col2:
+                location = st.text_input("Location", 
+                                       value="",
+                                       placeholder="e.g. Bangalore, Karnataka")
+                
+                if location and len(location) >= 2:
+                    # Use enhanced location filtering
+                    filtered_locations = filter_location_suggestions(location, LOCATION_SUGGESTIONS)
+                    
+                    if filtered_locations:
+                        # Format the display text to show location type
+                        location_options = []
+                        location_display = {}
+                        
+                        for loc in filtered_locations:
+                            display_text = loc["text"]
+                            if loc.get("type") == "state":
+                                display_text = f"{loc['text']} (State)"
+                            elif loc.get("type") == "city":
+                                display_text = f"{loc['text']}, {loc.get('state', '')}"
+                            elif loc.get("type") == "work_mode":
+                                display_text = f"{loc['text']} (Work Mode)"
+                                
+                            location_options.append(loc["text"])
+                            location_display[loc["text"]] = display_text
+                        
+                        # Create a selectbox with formatted display
+                        selected_location = st.selectbox(
+                            "Select Location",
+                            options=location_options,
+                            format_func=lambda x: location_display.get(x, x)
+                        )
+                        
+                        location = selected_location
+                        
+                        # If a state is selected, show cities in that state
+                        selected_loc_type = next((loc.get("type") for loc in filtered_locations if loc["text"] == selected_location), None)
+                        
+                        if selected_loc_type == "state":
+                            st.markdown(f"**Cities in {selected_location}:**")
+                            cities = get_cities_by_state(selected_location)
+                            
+                            # Display cities as clickable buttons
+                            city_cols = st.columns(3)
+                            for i, city in enumerate(cities):
+                                with city_cols[i % 3]:
+                                    if st.button(f"{city['icon']} {city['text']}", key=f"city_{i}"):
+                                        location = city['text']
+
+            # Advanced Filters
+            with st.expander("🎯 Advanced Filters"):
+                st.markdown('<div class="filter-section">', unsafe_allow_html=True)
+                filter_cols = st.columns(3)
+                
+                with filter_cols[0]:
+                    experience = st.selectbox("Experience Level",
+                                            options=get_filter_options()["experience_levels"],
+                                            format_func=lambda x: x["text"])
+                
+                with filter_cols[1]:
+                    salary_range = st.selectbox("Salary Range",
+                                              options=get_filter_options()["salary_ranges"],
+                                              format_func=lambda x: x["text"])
+                
+                with filter_cols[2]:
+                    job_type = st.selectbox("Job Type",
+                                          options=get_filter_options()["job_types"],
+                                          format_func=lambda x: x["text"])
+                
+                st.markdown('</div>', unsafe_allow_html=True)
+
+            # Search button
+            if st.button("SEARCH JOBS", type="primary", use_container_width=True):
+                if job_query:
+                    job_portal = JobPortal()
+                    results = job_portal.search_jobs(job_query, location, experience)
+                    
+                    if results:
+                        st.markdown("""
+                            <style>
+                            .result-card {
+                                background: rgba(255, 255, 255, 0.05);
+                                border-radius: 10px;
+                                padding: 15px;
+                                margin-bottom: 10px;
+                                border-left: 4px solid #00bfa5;
+                                transition: transform 0.2s;
+                            }
+                            .result-card:hover {
+                                transform: translateX(5px);
+                                background: rgba(255, 255, 255, 0.08);
+                            }
+                            .portal-name {
+                                color: #00bfa5;
+                                font-weight: bold;
+                                font-size: 1.2rem;
+                            }
+                            .portal-link {
+                                display: inline-block;
+                                background: #00bfa5;
+                                color: white !important;
+                                padding: 5px 15px;
+                                border-radius: 5px;
+                                text-decoration: none;
+                                margin-top: 10px;
+                                font-weight: bold;
+                            }
+                            .portal-link:hover {
+                                background: #00a589;
+                            }
+                            </style>
+                        """, unsafe_allow_html=True)
+                        
+                        st.markdown("### 🎯 Job Search Results")
+                        for result in results:
+                            with st.container():
+                                st.markdown(f"""
+                                <div class="result-card">
+                                    <div class="portal-name">
+                                        <i class="{result["icon"]}" style="color: {result["color"]}"></i>
+                                        {result["portal"]}
+                                    </div>
+                                    <p>{result["title"]}</p>
+                                    <a href="{result["url"]}" target="_blank" class="portal-link">
+                                        View Jobs on {result["portal"]} →
+                                    </a>
+                                </div>
+                                """, unsafe_allow_html=True)
+                    else:
+                        st.warning("No results found. Try different search terms or filters.")
+                else:
+                    st.warning("Please enter a job title or skills to search.")
+        
+        else:
+            # LinkedIn Job Scraper - only show the title once
+            st.markdown('<h3 class="search-title"><i class="fab fa-linkedin" style="color: #0A66C2;"></i> LinkedIn Job Scraper</h3>', unsafe_allow_html=True)
+            st.markdown('<p class="search-description">Find real-time job listings directly from LinkedIn</p>', unsafe_allow_html=True)
+            
+            # Render LinkedIn scraper without showing the title again
+            render_linkedin_scraper()
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Featured Companies Section (Below Search)
+    render_company_section()
+
+# Removed render_job_search() call to prevent automatic rendering

jobs/linkedin_scraper.py

@@ -0,0 +1,662 @@
+import time
+import numpy as np
+import pandas as pd
+import streamlit as st
+from streamlit_extras.add_vertical_space import add_vertical_space
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.common.exceptions import NoSuchElementException
+import warnings
+warnings.filterwarnings('ignore')
+
+# Import our custom webdriver utility
+from .webdriver_utils import setup_webdriver
+
+class LinkedInScraper:
+    """Class for scraping job listings from LinkedIn"""
+
+    @staticmethod
+    def webdriver_setup():
+        """Set up and configure the Chrome webdriver"""
+        # Use our custom webdriver setup utility with multiple fallback options
+        return setup_webdriver()
+
+    @staticmethod
+    def get_user_input(show_title=True):
+        """Get user input for job search parameters"""
+        add_vertical_space(1)
+        
+        # Apply custom styling for the form
+        if show_title:
+            st.markdown("""
+                <style>
+                .linkedin-form {
+                    background: rgba(10, 102, 194, 0.05);
+                    border-radius: 10px;
+                    padding: 20px;
+                    border-left: 4px solid #0A66C2;
+                    margin-bottom: 20px;
+                }
+                .linkedin-title {
+                    color: #0A66C2;
+                    font-weight: bold;
+                }
+                .linkedin-subtitle {
+                    color: #666;
+                    font-size: 0.9rem;
+                    margin-bottom: 15px;
+                }
+                </style>
+            """, unsafe_allow_html=True)
+            
+            st.markdown('<div class="linkedin-form">', unsafe_allow_html=True)
+            st.markdown('<h3 class="linkedin-title"><i class="fab fa-linkedin"></i> LinkedIn Job Scraper</h3>', unsafe_allow_html=True)
+            st.markdown('<p class="linkedin-subtitle">Find real-time job listings directly from LinkedIn</p>', unsafe_allow_html=True)
+            
+        with st.form(key='linkedin_scrape'):
+            col1, col2, col3 = st.columns([0.5, 0.3, 0.2], gap='medium')
+            
+            with col1:
+                job_title_input = st.text_input(
+                    label='Job Title',
+                    placeholder='e.g. Data Scientist, Software Engineer',
+                    help="Enter job titles separated by commas"
+                )
+                job_title_input = job_title_input.split(',')
+            
+            with col2:
+                job_location = st.text_input(
+                    label='Job Location', 
+                    value='India',
+                    placeholder='e.g. Bangalore, Mumbai, Remote',
+                    help="Enter a location or 'India' for nationwide search"
+                )
+            
+            with col3:
+                job_count = st.number_input(
+                    label='Number of Jobs', 
+                    min_value=1, 
+                    max_value=10,
+                    value=3, 
+                    step=1,
+                    help="Number of job listings to scrape (max 10)"
+                )
+
+            # Submit Button
+            add_vertical_space(1)
+            submit = st.form_submit_button(
+                label='Search LinkedIn Jobs',
+                type='primary',
+                use_container_width=True
+            )
+            add_vertical_space(1)
+        
+        if show_title:
+            st.markdown('</div>', unsafe_allow_html=True)
+        
+        return job_title_input, job_location, job_count, submit
+
+    @staticmethod
+    def build_url(job_title, job_location):
+        """Build LinkedIn search URL from job title and location"""
+        # Format job titles
+        formatted_titles = []
+        for title in job_title:
+            if title.strip():  # Skip empty titles
+                words = title.strip().split()
+                formatted_title = '%20'.join(words)
+                formatted_titles.append(formatted_title)
+        
+        # If no valid titles, use a default
+        if not formatted_titles:
+            formatted_titles = ["jobs"]
+        
+        # Join multiple job titles
+        job_title_param = '%2C%20'.join(formatted_titles)
+        
+        # Format location
+        location_param = job_location.replace(' ', '%20')
+        
+        # Build the LinkedIn search URL
+        link = f"https://in.linkedin.com/jobs/search?keywords={job_title_param}&location={location_param}&geoId=102713980&f_TPR=r604800&position=1&pageNum=0"
+        
+        return link
+
+    @staticmethod
+    def open_link(driver, link):
+        """Open LinkedIn link and wait for page to load"""
+        max_attempts = 3
+        attempts = 0
+        
+        while attempts < max_attempts:
+            try:
+                driver.get(link)
+                driver.implicitly_wait(5)
+                time.sleep(3)
+                
+                # Check if page loaded correctly
+                if "LinkedIn" in driver.title:
+                    return True
+                    
+                # Alternative check for elements
+                try:
+                    driver.find_element(by=By.CSS_SELECTOR, value='.jobs-search-results')
+                    return True
+                except:
+                    pass
+                    
+                try:
+                    driver.find_element(by=By.CSS_SELECTOR, value='.jobs-search-results-list')
+                    return True
+                except:
+                    pass
+                
+                # One more attempt with a different selector
+                try:
+                    driver.find_element(by=By.CSS_SELECTOR, value='.base-search-card')
+                    return True
+                except:
+                    pass
+                
+                attempts += 1
+                if attempts >= max_attempts:
+                    st.warning("Could not load LinkedIn jobs page. Please try again.")
+                    return False
+                    
+                time.sleep(2)
+                
+            except Exception as e:
+                attempts += 1
+                if attempts >= max_attempts:
+                    st.warning(f"Error loading LinkedIn page: {str(e)}")
+                    return False
+                time.sleep(2)
+                
+        return False
+
+    @staticmethod
+    def link_open_scrolldown(driver, link, job_count):
+        """Open LinkedIn link and scroll down to load more jobs"""
+        # Open the link
+        if not LinkedInScraper.open_link(driver, link):
+            return False
+        
+        # Scroll down to load more jobs
+        scroll_attempts = min(job_count + 5, 15)  # Add extra scrolls to ensure we get enough jobs
+        
+        for i in range(scroll_attempts):
+            try:
+                # Handle sign-in modal if it appears
+                try:
+                    dismiss_buttons = driver.find_elements(
+                        by=By.CSS_SELECTOR, 
+                        value="button[data-tracking-control-name='public_jobs_contextual-sign-in-modal_modal_dismiss']"
+                    )
+                    if dismiss_buttons:
+                        dismiss_buttons[0].click()
+                except:
+                    pass
+                
+                # Scroll down to load more content
+                driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
+                time.sleep(1.5)
+                
+                # Try to click "See more jobs" button if present
+                try:
+                    see_more_buttons = driver.find_elements(
+                        by=By.CSS_SELECTOR, 
+                        value="button[aria-label='See more jobs']"
+                    )
+                    if see_more_buttons:
+                        see_more_buttons[0].click()
+                        time.sleep(2)
+                except:
+                    pass
+                
+            except Exception as e:
+                continue
+        
+        return True
+
+    @staticmethod
+    def job_title_filter(scrap_job_title, user_job_title_input):
+        """Filter job titles based on user input"""
+        # Skip filtering if job title input is empty or contains only empty strings
+        if not user_job_title_input or all(not title.strip() for title in user_job_title_input):
+            return scrap_job_title
+        
+        # User job titles converted to lowercase
+        user_input = [title.lower().strip() for title in user_job_title_input if title.strip()]
+        
+        # If no valid user input after cleaning, return the original title
+        if not user_input:
+            return scrap_job_title
+        
+        # Scraped job title converted to lowercase
+        scrap_title = scrap_job_title.lower().strip()
+        
+        # Check if any user job title matches the scraped job title
+        for user_title in user_input:
+            # Check if all words in user title are in scraped title
+            if all(word in scrap_title for word in user_title.split()):
+                return scrap_job_title
+        
+        # No match found
+        return np.nan
+
+    @staticmethod
+    def scrap_company_data(driver, job_title_input, job_location):
+        """Scrape company data from LinkedIn job listings"""
+        try:
+            # Scrape company names
+            company_elements = driver.find_elements(
+                by=By.CSS_SELECTOR, 
+                value='h4.base-search-card__subtitle'
+            )
+            company_names = [element.text for element in company_elements if element.text.strip()]
+            
+            # Scrape job locations
+            location_elements = driver.find_elements(
+                by=By.CSS_SELECTOR, 
+                value='span.job-search-card__location'
+            )
+            company_locations = [element.text for element in location_elements if element.text.strip()]
+            
+            # Scrape job titles
+            title_elements = driver.find_elements(
+                by=By.CSS_SELECTOR, 
+                value='h3.base-search-card__title'
+            )
+            job_titles = [element.text for element in title_elements if element.text.strip()]
+            
+            # Scrape job URLs
+            url_elements = driver.find_elements(
+                by=By.XPATH, 
+                value='//a[contains(@href, "/jobs/view/")]'
+            )
+            job_urls = [element.get_attribute('href') for element in url_elements if element.get_attribute('href')]
+            
+            # Check if we have any data
+            if not company_names or not job_titles or not company_locations or not job_urls:
+                st.warning("No job listings found on LinkedIn. Try different search terms.")
+                return pd.DataFrame()
+            
+            # Ensure all arrays have the same length by truncating to the shortest length
+            min_length = min(len(company_names), len(job_titles), len(company_locations), len(job_urls))
+            
+            if min_length == 0:
+                st.warning("No job listings found on LinkedIn. Try different search terms.")
+                return pd.DataFrame()
+                
+            company_names = company_names[:min_length]
+            job_titles = job_titles[:min_length]
+            company_locations = company_locations[:min_length]
+            job_urls = job_urls[:min_length]
+            
+            # Create DataFrame
+            df = pd.DataFrame({
+                'Company Name': company_names,
+                'Job Title': job_titles,
+                'Location': company_locations,
+                'Website URL': job_urls
+            })
+            
+            # Filter job titles based on user input if provided
+            if job_title_input and job_title_input != ['']:
+                filtered_titles = []
+                for title in df['Job Title']:
+                    if any(user_title.lower().strip() in title.lower() for user_title in job_title_input if user_title.strip()):
+                        filtered_titles.append(title)
+                    else:
+                        filtered_titles.append(np.nan)
+                df['Job Title'] = filtered_titles
+            
+            # Filter locations based on user input if provided and not "India"
+            if job_location and job_location.lower() != "india":
+                filtered_locations = []
+                for loc in df['Location']:
+                    if job_location.lower() in loc.lower():
+                        filtered_locations.append(loc)
+                    else:
+                        filtered_locations.append(np.nan)
+                df['Location'] = filtered_locations
+            
+            # Drop rows with NaN values and reset index
+            df = df.dropna()
+            df = df.reset_index(drop=True)
+            
+            return df
+            
+        except Exception as e:
+            st.error(f"Error scraping company data: {str(e)}")
+            st.info("Try refreshing the page or using different search terms.")
+            return pd.DataFrame()
+
+    @staticmethod
+    def scrap_job_description(driver, df, job_count):
+        """Scrape job descriptions for each job listing"""
+        if df.empty:
+            return df
+        
+        # Get job URLs
+        job_urls = df['Website URL'].tolist()
+        
+        # Limit to requested job count
+        job_urls = job_urls[:min(len(job_urls), job_count)]
+        
+        # Initialize list for job descriptions
+        job_descriptions = []
+        
+        # Progress bar for scraping job descriptions
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        for i, url in enumerate(job_urls):
+            try:
+                # Update progress
+                progress = int((i + 1) / len(job_urls) * 100)
+                progress_bar.progress(progress)
+                status_text.text(f"Scraping job {i+1} of {len(job_urls)}...")
+                
+                # Open job listing page
+                driver.get(url)
+                driver.implicitly_wait(5)
+                time.sleep(2)
+                
+                # Try to click "Show more" button to expand job description
+                try:
+                    show_more_buttons = driver.find_elements(
+                        by=By.CSS_SELECTOR, 
+                        value='button[data-tracking-control-name="public_jobs_show-more-html-btn"]'
+                    )
+                    if show_more_buttons:
+                        show_more_buttons[0].click()
+                        time.sleep(1)
+                except:
+                    pass
+                
+                # Get job description
+                description_elements = driver.find_elements(
+                    by=By.CSS_SELECTOR, 
+                    value='div.show-more-less-html__markup'
+                )
+                
+                if description_elements and description_elements[0].text.strip():
+                    description_text = description_elements[0].text
+                    
+                    # Process and structure the job description
+                    processed_description = LinkedInScraper.process_job_description(description_text)
+                    job_descriptions.append(processed_description)
+                else:
+                    # Try alternative selectors
+                    alt_description = driver.find_elements(
+                        by=By.CSS_SELECTOR, 
+                        value='div.description__text'
+                    )
+                    if alt_description and alt_description[0].text.strip():
+                        description_text = alt_description[0].text
+                        processed_description = LinkedInScraper.process_job_description(description_text)
+                        job_descriptions.append(processed_description)
+                    else:
+                        job_descriptions.append("Description not available")
+                    
+            except Exception as e:
+                job_descriptions.append("Description not available")
+                st.warning(f"Error scraping job description {i+1}: {str(e)}")
+            
+        # Clear progress indicators
+        progress_bar.empty()
+        status_text.empty()
+        
+        # Filter DataFrame to include only rows with descriptions
+        df = df.iloc[:len(job_descriptions), :]
+        
+        # Add job descriptions to DataFrame
+        df['Job Description'] = job_descriptions
+        
+        # Filter out rows with unavailable descriptions
+        df['Job Description'] = df['Job Description'].apply(
+            lambda x: np.nan if x == "Description not available" else x
+        )
+        df = df.dropna()
+        df = df.reset_index(drop=True)
+        
+        return df
+
+    @staticmethod
+    def process_job_description(text):
+        """Process and structure job description text"""
+        if not text or text == "Description not available":
+            return text
+            
+        # Split into sections
+        sections = text.split('\n\n')
+        processed_sections = []
+        
+        # Common section headers to identify
+        section_headers = [
+            "responsibilities", "requirements", "qualifications", "skills", 
+            "about the job", "about the role", "what you'll do", "what you'll need",
+            "about us", "about the company", "who we are", "benefits", "perks",
+            "job description", "role description", "experience", "education", 
+            "job summary", "job overview", "job requirements", "job responsibilities",
+            "job qualifications", "job skills", "job benefits", "job perks",
+            "job description", "role description", "experience", "education",
+            "job summary", "job overview", "job requirements", "job responsibilities",
+            "job qualifications", "job skills", "job benefits", "job perks",
+            "Education Qualification and Experience", "Required Skills", "Preferred Qualifications", "Key Responsibilities",
+            "About Us", "About the Company", "About the Role", "About the Job",
+            "About the Team", "About the Organization", "About the Industry", "About the Location",
+            "Position", "Job Description", "Job Summary", "Job Overview"
+        ]
+        
+        # Process each section
+        current_section = ""
+        for section in sections:
+            if not section.strip():
+                continue
+                
+            # Check if this is a new section header
+            is_header = False
+            section_lower = section.lower().strip()
+            
+            # Check if section starts with a header
+            for header in section_headers:
+                if section_lower.startswith(header) or section_lower.startswith("• " + header) or section_lower.startswith("- " + header):
+                    # Format as a header
+                    current_section = section.strip()
+                    is_header = True
+                    processed_sections.append(f"\n**{current_section}**\n")
+                    break
+            
+            if not is_header:
+                # Check if it's a bullet point list
+                if section.strip().startswith('•') or section.strip().startswith('-') or section.strip().startswith('*'):
+                    lines = section.split('\n')
+                    formatted_lines = []
+                    
+                    for line in lines:
+                        line = line.strip()
+                        if line:
+                            if line.startswith('•') or line.startswith('-') or line.startswith('*'):
+                                # Format as bullet point
+                                formatted_lines.append(f"• {line.lstrip('•').lstrip('-').lstrip('*').strip()}")
+                            else:
+                                formatted_lines.append(line)
+                    
+                    processed_sections.append('\n'.join(formatted_lines))
+                else:
+                    # Regular paragraph
+                    processed_sections.append(section.strip())
+        
+        # Join all processed sections
+        return '\n\n'.join(processed_sections)
+
+    @staticmethod
+    def display_data_userinterface(df_final):
+        """Display scraped job data in the user interface"""
+        if df_final.empty:
+            st.warning("No matching jobs found. Try different search terms or location.")
+            return
+            
+        # Apply custom styling for job cards
+        st.markdown("""
+            <style>
+            .job-card {
+                background: rgba(255, 255, 255, 0.05);
+                border-radius: 10px;
+                padding: 1.5rem;
+                margin-bottom: 1rem;
+                border-left: 4px solid #0A66C2;
+                transition: transform 0.2s;
+            }
+            .job-card:hover {
+                background: rgba(255, 255, 255, 0.08);
+            }
+            .job-title {
+                color: #0A66C2;
+                font-size: 1.3rem;
+                margin-bottom: 0.5rem;
+            }
+            .company-name {
+                font-weight: bold;
+                font-size: 1.1rem;
+            }
+            .job-location {
+                color: #888;
+                margin-bottom: 1rem;
+            }
+            .job-url-button {
+                display: inline-block;
+                background: #0A66C2;
+                color: white;
+                padding: 0.5rem 1rem;
+                border-radius: 5px;
+                text-decoration: none;
+                margin-top: 1rem;
+                font-weight: bold;
+            }
+            .job-url-button:hover {
+                background: #084d8e;
+            }
+            .job-count {
+                background: rgba(10, 102, 194, 0.1);
+                color: #0A66C2;
+                padding: 0.5rem 1rem;
+                border-radius: 5px;
+                margin-bottom: 1rem;
+                font-weight: bold;
+            }
+            .job-section {
+                margin-top: 1rem;
+                padding-top: 0.5rem;
+                border-top: 1px solid rgba(255, 255, 255, 0.1);
+            }
+            .job-section-title {
+                font-weight: bold;
+                color: #0A66C2;
+                margin-bottom: 0.5rem;
+            }
+            </style>
+        """, unsafe_allow_html=True)
+        
+        # Display job count
+        st.markdown(f'<div class="job-count">🎯 Found {len(df_final)} matching jobs on LinkedIn</div>', unsafe_allow_html=True)
+        
+        # Display each job
+        for i in range(len(df_final)):
+            company_name = df_final.iloc[i, 0]
+            job_title = df_final.iloc[i, 1]
+            location = df_final.iloc[i, 2]
+            url = df_final.iloc[i, 3]
+            description = df_final.iloc[i, 4]
+            
+            # Create job card
+            st.markdown(f"""
+                <div class="job-card">
+                    <div class="job-title">{job_title}</div>
+                    <div class="company-name">{company_name}</div>
+                    <div class="job-location">📍 {location}</div>
+                </div>
+            """, unsafe_allow_html=True)
+            
+            # Job description in expander with better formatting
+            with st.expander("View Job Description"):
+                st.markdown(description)
+                st.markdown(f"<a href='{url}' target='_blank' class='job-url-button'>Apply on LinkedIn</a>", unsafe_allow_html=True)
+            
+            st.markdown("<hr>", unsafe_allow_html=True)
+
+    @staticmethod
+    def main(show_title=True):
+        """Main function to run the LinkedIn job scraper"""
+        # Initialize driver to None
+        driver = None
+        
+        try:
+            # Get user input
+            job_title_input, job_location, job_count, submit = LinkedInScraper.get_user_input(show_title)
+            
+            if submit:
+                if job_title_input != [''] and job_location:
+                    try:
+                        # Set up Chrome webdriver
+                        with st.spinner('Setting up Chrome webdriver...'):
+                            driver = LinkedInScraper.webdriver_setup()
+                            
+                            if not driver:
+                                st.error("Failed to initialize Chrome webdriver. Please make sure Chrome is installed.")
+                                return
+                        
+                        # Build URL and open LinkedIn
+                        with st.spinner('Loading LinkedIn jobs page...'):
+                            link = LinkedInScraper.build_url(job_title_input, job_location)
+                            st.info(f"Searching for: {', '.join([t for t in job_title_input if t.strip()])} in {job_location}")
+                            success = LinkedInScraper.link_open_scrolldown(driver, link, job_count)
+                            
+                            if not success:
+                                st.error("Failed to load LinkedIn jobs page. Please try again.")
+                                return
+                        
+                        # Scrape job data
+                        with st.spinner('Scraping job listings...'):
+                            df = LinkedInScraper.scrap_company_data(driver, job_title_input, job_location)
+                            
+                            if df.empty:
+                                st.warning("No jobs found matching your criteria. Try different search terms.")
+                                return
+                        
+                        # Scrape job descriptions
+                        with st.spinner('Fetching job descriptions...'):
+                            df_final = LinkedInScraper.scrap_job_description(driver, df, job_count)
+                            
+                            if df_final.empty:
+                                st.warning("Could not retrieve job descriptions. Try different search terms.")
+                                return
+                        
+                        # Display results
+                        LinkedInScraper.display_data_userinterface(df_final)
+                        
+                    except Exception as e:
+                        st.error(f"An error occurred: {str(e)}")
+                        st.info("Try refreshing the page or using different search terms.")
+                        
+                elif job_title_input == ['']:
+                    st.warning("Please enter a job title to search.")
+                    
+                elif not job_location:
+                    st.warning("Please enter a job location to search.")
+                    
+        except Exception as e:
+            st.error(f"An unexpected error occurred: {str(e)}")
+            
+        finally:
+            # Close the webdriver
+            if driver:
+                driver.quit()
+
+def render_linkedin_scraper():
+    """Render the LinkedIn job scraper interface"""
+    # Don't show the title again, as it's already shown in the job_search.py file
+    LinkedInScraper.main(show_title=False)

jobs/suggestions.py

@@ -0,0 +1,225 @@
+"""Module containing job-related data and configurations"""
+
+# Job titles and skills suggestions
+JOB_SUGGESTIONS = [
+    {"text": "Software Engineer", "icon": "💻"},
+    {"text": "Full Stack Developer", "icon": "🔧"},
+    {"text": "Data Scientist", "icon": "📊"},
+    {"text": "Product Manager", "icon": "📱"},
+    {"text": "DevOps Engineer", "icon": "⚙️"},
+    {"text": "UI/UX Designer", "icon": "🎨"},
+    {"text": "Python Developer", "icon": "🐍"},
+    {"text": "Java Developer", "icon": "☕"},
+    {"text": "React Developer", "icon": "⚛️"},
+    {"text": "Machine Learning Engineer", "icon": "🤖"},
+    {"text": "Backend Developer", "icon": "🖧"},
+    {"text": "Frontend Developer", "icon": "🎨"},
+    {"text": "Node.js Developer", "icon": "🌿"},
+    {"text": "Angular Developer", "icon": "📐"},
+    {"text": "PHP Developer", "icon": "🐘"},
+    {"text": "Ruby Developer", "icon": "💎"},
+    {"text": "Go Developer", "icon": "🚀"},
+    {"text": "C++ Developer", "icon": "🖥️"},
+    {"text": "C# Developer", "icon": "🎮"},
+    {"text": "Django Developer", "icon": "🛠️"},
+    {"text": "Data Analyst", "icon": "📈"},
+    {"text": "Big Data Engineer", "icon": "📡"},
+    {"text": "Database Administrator", "icon": "🗄️"},
+    {"text": "Business Intelligence Analyst", "icon": "📊"},
+    {"text": "Cloud Engineer", "icon": "☁️"},
+    {"text": "AWS Engineer", "icon": "☁️🔧"},
+    {"text": "Azure Engineer", "icon": "☁️🖥️"},
+    {"text": "Google Cloud Engineer", "icon": "☁️📡"},
+    {"text": "Network Engineer", "icon": "🔌"},
+    {"text": "AI Researcher", "icon": "🧠"},
+    {"text": "NLP Engineer", "icon": "🗣️"},
+    {"text": "Computer Vision Engineer", "icon": "👁️"},
+    {"text": "Deep Learning Engineer", "icon": "🧠📚"},
+    {"text": "Cybersecurity Analyst", "icon": "🔒"},
+    {"text": "Ethical Hacker", "icon": "🕵️‍♂️"},
+    {"text": "Security Engineer", "icon": "🛡️"},
+    {"text": "Penetration Tester", "icon": "🔍"},
+    {"text": "Cryptography Engineer", "icon": "🔑"},
+    {"text": "Game Developer", "icon": "🎮"},
+    {"text": "Embedded Systems Engineer", "icon": "🖧⚙️"},
+    {"text": "Mobile App Developer", "icon": "📱"},
+    {"text": "iOS Developer", "icon": "🍏"},
+    {"text": "Android Developer", "icon": "🤖"},
+    {"text": "Blockchain Developer", "icon": "🔗"},
+    {"text": "IoT Developer", "icon": "🌐"},
+    {"text": "AR/VR Developer", "icon": "🕶️"},
+    {"text": "Project Manager", "icon": "📋"},
+    {"text": "Technical Writer", "icon": "✍️"},
+    {"text": "QA Engineer", "icon": "✅"},
+    {"text": "Scrum Master", "icon": "🔄"},
+    {"text": "Support Engineer", "icon": "📞"},
+    {"text": "IT Consultant", "icon": "🧑‍💼"},
+    {"text": "Technical Support Specialist", "icon": "🎧"}
+]
+
+
+# Location suggestions - organized by states and major cities
+LOCATION_SUGGESTIONS = [
+    # Work modes
+    {"text": "Remote", "icon": "🏠", "type": "work_mode"},
+    {"text": "Work from Home", "icon": "🏠", "type": "work_mode"},
+    {"text": "Hybrid", "icon": "🏢", "type": "work_mode"},
+    
+    # Major tech hubs
+    {"text": "Bangalore", "icon": "📍", "type": "city", "state": "Karnataka"},
+    {"text": "Mumbai", "icon": "📍", "type": "city", "state": "Maharashtra"},
+    {"text": "Delhi", "icon": "📍", "type": "city", "state": "Delhi"},
+    {"text": "Hyderabad", "icon": "📍", "type": "city", "state": "Telangana"},
+    {"text": "Pune", "icon": "📍", "type": "city", "state": "Maharashtra"},
+    {"text": "Chennai", "icon": "📍", "type": "city", "state": "Tamil Nadu"},
+    {"text": "Noida", "icon": "📍", "type": "city", "state": "Uttar Pradesh"},
+    {"text": "Gurgaon", "icon": "📍", "type": "city", "state": "Haryana"},
+    
+    # States
+    {"text": "Karnataka", "icon": "🗺️", "type": "state"},
+    {"text": "Maharashtra", "icon": "🗺️", "type": "state"},
+    {"text": "Tamil Nadu", "icon": "🗺️", "type": "state"},
+    {"text": "Telangana", "icon": "🗺️", "type": "state"},
+    {"text": "Delhi", "icon": "🗺️", "type": "state"},
+    {"text": "Uttar Pradesh", "icon": "🗺️", "type": "state"},
+    {"text": "Gujarat", "icon": "🗺️", "type": "state"},
+    {"text": "Rajasthan", "icon": "🗺️", "type": "state"},
+    {"text": "Kerala", "icon": "🗺️", "type": "state"},
+    {"text": "West Bengal", "icon": "🗺️", "type": "state"},
+    {"text": "Punjab", "icon": "🗺️", "type": "state"},
+    {"text": "Haryana", "icon": "🗺️", "type": "state"},
+    {"text": "Andhra Pradesh", "icon": "🗺️", "type": "state"},
+    {"text": "Madhya Pradesh", "icon": "🗺️", "type": "state"},
+    {"text": "Bihar", "icon": "🗺️", "type": "state"},
+    
+    # Karnataka cities
+    {"text": "Mysore", "icon": "📍", "type": "city", "state": "Karnataka"},
+    {"text": "Hubli", "icon": "📍", "type": "city", "state": "Karnataka"},
+    {"text": "Mangalore", "icon": "📍", "type": "city", "state": "Karnataka"},
+    {"text": "Belgaum", "icon": "📍", "type": "city", "state": "Karnataka"},
+    {"text": "Davangere", "icon": "📍", "type": "city", "state": "Karnataka"},
+    
+    # Maharashtra cities
+    {"text": "Nagpur", "icon": "📍", "type": "city", "state": "Maharashtra"},
+    {"text": "Nashik", "icon": "📍", "type": "city", "state": "Maharashtra"},
+    {"text": "Aurangabad", "icon": "📍", "type": "city", "state": "Maharashtra"},
+    {"text": "Kolhapur", "icon": "📍", "type": "city", "state": "Maharashtra"},
+    {"text": "Solapur", "icon": "📍", "type": "city", "state": "Maharashtra"},
+    
+    # Tamil Nadu cities
+    {"text": "Coimbatore", "icon": "📍", "type": "city", "state": "Tamil Nadu"},
+    {"text": "Madurai", "icon": "📍", "type": "city", "state": "Tamil Nadu"},
+    {"text": "Salem", "icon": "📍", "type": "city", "state": "Tamil Nadu"},
+    {"text": "Tiruchirappalli", "icon": "📍", "type": "city", "state": "Tamil Nadu"},
+    {"text": "Vellore", "icon": "📍", "type": "city", "state": "Tamil Nadu"},
+    
+    # Uttar Pradesh cities
+    {"text": "Lucknow", "icon": "📍", "type": "city", "state": "Uttar Pradesh"},
+    {"text": "Kanpur", "icon": "📍", "type": "city", "state": "Uttar Pradesh"},
+    {"text": "Agra", "icon": "📍", "type": "city", "state": "Uttar Pradesh"},
+    {"text": "Varanasi", "icon": "📍", "type": "city", "state": "Uttar Pradesh"},
+    {"text": "Meerut", "icon": "📍", "type": "city", "state": "Uttar Pradesh"},
+    
+    # Andhra Pradesh cities
+    {"text": "Vijayawada", "icon": "📍", "type": "city", "state": "Andhra Pradesh"},
+    {"text": "Visakhapatnam", "icon": "📍", "type": "city", "state": "Andhra Pradesh"},
+    {"text": "Tirupati", "icon": "📍", "type": "city", "state": "Andhra Pradesh"},
+    {"text": "Guntur", "icon": "📍", "type": "city", "state": "Andhra Pradesh"},
+    {"text": "Nellore", "icon": "📍", "type": "city", "state": "Andhra Pradesh"},
+    
+    # West Bengal cities
+    {"text": "Kolkata", "icon": "📍", "type": "city", "state": "West Bengal"},
+    {"text": "Darjeeling", "icon": "📍", "type": "city", "state": "West Bengal"},
+    {"text": "Siliguri", "icon": "📍", "type": "city", "state": "West Bengal"},
+    {"text": "Durgapur", "icon": "📍", "type": "city", "state": "West Bengal"},
+    {"text": "Asansol", "icon": "📍", "type": "city", "state": "West Bengal"},
+    
+    # Gujarat cities
+    {"text": "Ahmedabad", "icon": "📍", "type": "city", "state": "Gujarat"},
+    {"text": "Surat", "icon": "📍", "type": "city", "state": "Gujarat"},
+    {"text": "Vadodara", "icon": "📍", "type": "city", "state": "Gujarat"},
+    {"text": "Rajkot", "icon": "📍", "type": "city", "state": "Gujarat"},
+    {"text": "Bhavnagar", "icon": "📍", "type": "city", "state": "Gujarat"},
+    
+    # Rajasthan cities
+    {"text": "Jaipur", "icon": "📍", "type": "city", "state": "Rajasthan"},
+    {"text": "Jodhpur", "icon": "📍", "type": "city", "state": "Rajasthan"},
+    {"text": "Udaipur", "icon": "📍", "type": "city", "state": "Rajasthan"},
+    {"text": "Kota", "icon": "📍", "type": "city", "state": "Rajasthan"},
+    {"text": "Ajmer", "icon": "📍", "type": "city", "state": "Rajasthan"},
+    
+    # Kerala cities
+    {"text": "Kochi", "icon": "📍", "type": "city", "state": "Kerala"},
+    {"text": "Thiruvananthapuram", "icon": "📍", "type": "city", "state": "Kerala"},
+    {"text": "Kozhikode", "icon": "📍", "type": "city", "state": "Kerala"},
+    {"text": "Thrissur", "icon": "📍", "type": "city", "state": "Kerala"},
+    {"text": "Alappuzha", "icon": "📍", "type": "city", "state": "Kerala"},
+    
+    # Punjab cities
+    {"text": "Amritsar", "icon": "📍", "type": "city", "state": "Punjab"},
+    {"text": "Ludhiana", "icon": "📍", "type": "city", "state": "Punjab"},
+    {"text": "Jalandhar", "icon": "📍", "type": "city", "state": "Punjab"},
+    {"text": "Patiala", "icon": "📍", "type": "city", "state": "Punjab"},
+    {"text": "Bathinda", "icon": "📍", "type": "city", "state": "Punjab"},
+    
+    # Haryana cities
+    {"text": "Faridabad", "icon": "📍", "type": "city", "state": "Haryana"},
+    {"text": "Panipat", "icon": "📍", "type": "city", "state": "Haryana"},
+    {"text": "Ambala", "icon": "📍", "type": "city", "state": "Haryana"},
+    {"text": "Karnal", "icon": "📍", "type": "city", "state": "Haryana"},
+    {"text": "Hisar", "icon": "📍", "type": "city", "state": "Haryana"},
+    
+    # Northeast cities
+    {"text": "Guwahati", "icon": "📍", "type": "city", "state": "Assam"},
+    {"text": "Shillong", "icon": "📍", "type": "city", "state": "Meghalaya"},
+    {"text": "Imphal", "icon": "📍", "type": "city", "state": "Manipur"},
+    {"text": "Aizawl", "icon": "📍", "type": "city", "state": "Mizoram"},
+    {"text": "Gangtok", "icon": "📍", "type": "city", "state": "Sikkim"},
+    
+    # Union Territories
+    {"text": "Chandigarh", "icon": "📍", "type": "city", "state": "Chandigarh"},
+    {"text": "Port Blair", "icon": "📍", "type": "city", "state": "Andaman and Nicobar Islands"},
+    {"text": "Shimla", "icon": "📍", "type": "city", "state": "Himachal Pradesh"},
+    {"text": "Dehradun", "icon": "📍", "type": "city", "state": "Uttarakhand"},
+    {"text": "Itanagar", "icon": "📍", "type": "city", "state": "Arunachal Pradesh"}
+]
+
+# Function to get cities by state
+def get_cities_by_state(state_name):
+    """Get list of cities for a specific state"""
+    return [loc for loc in LOCATION_SUGGESTIONS if loc.get("type") == "city" and loc.get("state") == state_name]
+
+# Function to get all states
+def get_all_states():
+    """Get list of all states"""
+    return [loc for loc in LOCATION_SUGGESTIONS if loc.get("type") == "state"]
+
+# Job types
+JOB_TYPES = [
+    {"id": "all", "text": "All Types"},
+    {"id": "full-time", "text": "Full Time"},
+    {"id": "part-time", "text": "Part Time"},
+    {"id": "contract", "text": "Contract"},
+    {"id": "internship", "text": "Internship"},
+    {"id": "remote", "text": "Remote"}
+]
+
+# Experience levels
+EXPERIENCE_RANGES = [
+    {"id": "all", "text": "All Levels"},
+    {"id": "fresher", "text": "Fresher"},
+    {"id": "1-3", "text": "1-3 years"},
+    {"id": "3-5", "text": "3-5 years"},
+    {"id": "5-7", "text": "5-7 years"},
+    {"id": "7+", "text": "7+ years"}
+]
+
+# Salary ranges
+SALARY_RANGES = [
+    {"id": "all", "text": "All Ranges"},
+    {"id": "0-3", "text": "0-3 LPA"},
+    {"id": "3-6", "text": "3-6 LPA"},
+    {"id": "6-10", "text": "6-10 LPA"},
+    {"id": "10-15", "text": "10-15 LPA"},
+    {"id": "15+", "text": "15+ LPA"}
+]

jobs/webdriver_utils.py

@@ -0,0 +1,219 @@
+"""Utility functions for webdriver setup and management"""
+import os
+import sys
+import platform
+import tempfile
+import subprocess
+import streamlit as st
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.chrome.options import Options
+
+# Try to import various webdriver managers with fallbacks
+try:
+    from webdriver_manager.chrome import ChromeDriverManager
+    from webdriver_manager.core.utils import ChromeType
+    webdriver_manager_available = True
+except ImportError:
+    webdriver_manager_available = False
+
+try:
+    import chromedriver_autoinstaller
+    autoinstaller_available = True
+except ImportError:
+    autoinstaller_available = False
+
+def get_chrome_version():
+    """Get the installed Chrome/Chromium version"""
+    system = platform.system()
+    
+    if system == "Windows":
+        # Windows-specific Chrome detection
+        try:
+            # Try to find Chrome in Program Files
+            chrome_paths = [
+                r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+                r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
+                os.path.expandvars(r"%LOCALAPPDATA%\Google\Chrome\Application\chrome.exe")
+            ]
+            
+            for path in chrome_paths:
+                if os.path.exists(path):
+                    try:
+                        # Try using registry/wmic to get version
+                        escaped_path = path.replace("\\", "\\\\")
+                        output = subprocess.check_output(
+                            ['wmic', 'datafile', 'where', f'name="{escaped_path}"', 'get', 'Version', '/value'],
+                            stderr=subprocess.STDOUT
+                        )
+                        version_str = output.decode('utf-8').strip()
+                        if "Version=" in version_str:
+                            version = version_str.split('=')[1].split('.')[0]
+                            return version
+                    except:
+                        # Try alternative method
+                        try:
+                            output = subprocess.check_output([path, '--version'], stderr=subprocess.STDOUT)
+                            version = output.decode('utf-8').strip().split()[-1].split('.')[0]
+                            return version
+                        except:
+                            pass
+        except Exception:
+            # Silently fail and continue with default
+            pass
+    else:
+        # Linux/Mac detection
+        try:
+            # Try different Chrome/Chromium binaries
+            for binary in ['/usr/bin/google-chrome', '/usr/bin/chromium', '/usr/bin/chromium-browser']:
+                if os.path.exists(binary):
+                    version = subprocess.check_output([binary, '--version'], stderr=subprocess.STDOUT)
+                    version = version.decode('utf-8').strip().split()[-1].split('.')[0]
+                    return version
+        except Exception:
+            # Silently fail and continue with default
+            pass
+    
+    # Default to latest if all else fails
+    return "120"
+
+def run_setup_script():
+    """Run the setup_chromedriver.py script to install the correct chromedriver"""
+    try:
+        # Get the path to the setup script
+        script_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        setup_script = os.path.join(script_dir, "setup_chromedriver.py")
+        
+        if os.path.exists(setup_script):
+            st.info("Running chromedriver setup script...")
+            result = subprocess.run([sys.executable, setup_script], 
+                                   capture_output=True, text=True)
+            
+            if result.returncode == 0:
+                st.success("Chromedriver setup completed successfully!")
+                # Extract the chromedriver path from the output
+                for line in result.stdout.split('\n'):
+                    if "Chromedriver path:" in line:
+                        chromedriver_path = line.split("Chromedriver path:")[1].strip()
+                        return chromedriver_path
+            else:
+                st.warning(f"Chromedriver setup failed: {result.stderr}")
+        else:
+            st.warning(f"Setup script not found at {setup_script}")
+    except Exception as e:
+        st.warning(f"Error running setup script: {str(e)}")
+    
+    return None
+
+def get_chromedriver_path():
+    """Get the path to the chromedriver executable based on the platform"""
+    system = platform.system()
+    
+    if system == "Windows":
+        # Check in LocalAppData
+        local_app_data = os.environ.get('LOCALAPPDATA', '')
+        if local_app_data:
+            chromedriver_path = os.path.join(local_app_data, "ChromeDriver", "chromedriver.exe")
+            if os.path.exists(chromedriver_path):
+                return chromedriver_path
+    else:
+        # Check in ~/.chromedriver
+        home_dir = os.path.expanduser("~")
+        chromedriver_path = os.path.join(home_dir, ".chromedriver", "chromedriver")
+        if os.path.exists(chromedriver_path):
+            return chromedriver_path
+    
+    return None
+
+def setup_webdriver():
+    """
+    Set up and configure Chrome webdriver with multiple fallback options
+    
+    Returns:
+        webdriver.Chrome or None: Configured Chrome webdriver or None if setup fails
+    """
+    options = Options()
+    options.add_argument('--headless')
+    options.add_argument('--no-sandbox')
+    options.add_argument('--disable-dev-shm-usage')
+    options.add_argument('--disable-gpu')
+    options.add_argument('--window-size=1920,1080')
+    options.add_argument('--disable-blink-features=AutomationControlled')
+    options.add_argument('--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36')
+    
+    # Method 1: Try direct initialization first since it's working
+    try:
+        driver = webdriver.Chrome(options=options)
+        st.success("Chrome webdriver initialized successfully!")
+        return driver
+    except Exception:
+        # If direct initialization fails, try other methods
+        pass
+    
+    # Method 2: Check if we already have a chromedriver installed
+    chromedriver_path = get_chromedriver_path()
+    if chromedriver_path:
+        try:
+            service = Service(executable_path=chromedriver_path)
+            driver = webdriver.Chrome(service=service, options=options)
+            return driver
+        except Exception:
+            # Silently fail and continue with other methods
+            pass
+    
+    # Method 3: Try using webdriver-manager
+    if webdriver_manager_available:
+        try:
+            service = Service(ChromeDriverManager().install())
+            driver = webdriver.Chrome(service=service, options=options)
+            return driver
+        except Exception:
+            # Silently fail and continue with other methods
+            pass
+    
+    # Method 4: Try platform-specific approaches
+    system = platform.system()
+    if system == "Windows":
+        try:
+            # Try with Chrome binary path
+            chrome_paths = [
+                r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+                r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
+                os.path.expandvars(r"%LOCALAPPDATA%\Google\Chrome\Application\chrome.exe")
+            ]
+            
+            for path in chrome_paths:
+                if os.path.exists(path):
+                    options.binary_location = path
+                    try:
+                        driver = webdriver.Chrome(options=options)
+                        return driver
+                    except Exception:
+                        continue
+        except Exception:
+            # Silently fail and continue with other methods
+            pass
+    elif system == "Linux":
+        try:
+            # Try with Chromium binary path
+            options.binary_location = "/usr/bin/chromium"
+            try:
+                driver = webdriver.Chrome(options=options)
+                return driver
+            except Exception:
+                pass
+                
+            # Try with Google Chrome binary path
+            options.binary_location = "/usr/bin/google-chrome"
+            try:
+                driver = webdriver.Chrome(options=options)
+                return driver
+            except Exception:
+                pass
+        except Exception:
+            # Silently fail and continue with other methods
+            pass
+    
+    # All methods failed
+    st.error("Failed to initialize Chrome webdriver. Please make sure Chrome is installed.")
+    return None 

packages.txt

@@ -0,0 +1,9 @@
+chromium
+chromium-driver
+libglib2.0-0
+libnss3
+libgconf-2-4
+libfontconfig1
+xvfb
+wget
+unzip 

poppler/poppler-24.08.0/Library/bin/Lerc.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3383b3f5df29c5b556ccbff8b5c1cbcdcaa423a68cb22bc3bf84c4c36a1bcdbc
+size 519680

poppler/poppler-24.08.0/Library/bin/cairo.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c690978c5be8486d06e4363cbc802fe800a3c454d66b64dd19f172292bd20a3f
+size 1016320

poppler/poppler-24.08.0/Library/bin/deflate.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0c144c1bcb58b16d25f43cfb36e5e7fb03f39414fbb2f5b2e14b1874f6c7f27
+size 177152

poppler/poppler-24.08.0/Library/bin/expat.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1eef16676ab7cabca520ed0b809bb7f38b23250a7d051942cf1b288aebdb9bfe
+size 402432

poppler/poppler-24.08.0/Library/bin/fontconfig-1.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cfce15422bcf0fce28278b2e517741ef718de4e9f86ee8e9234805695005d018
+size 282624

poppler/poppler-24.08.0/Library/bin/freetype.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f878121d560f43c398671bc1d0d7a61bf719fa7894eac5a1db665414bcd4096f
+size 670720

poppler/poppler-24.08.0/Library/bin/iconv.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb108fa99613c60b732221c6edf9a7ee0484c2758c63252708969616912c256c
+size 937472

poppler/poppler-24.08.0/Library/bin/jpeg8.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b98a020fe2161efb9f8cfe991f8f77c5d497b290422328fe351948d2234838e9
+size 803328

poppler/poppler-24.08.0/Library/bin/lcms2.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f864b9f1bf5839fbc963265a0c9c94a4709124439e5ab5bfcae5f522483a1c4
+size 560128

poppler/poppler-24.08.0/Library/bin/libcrypto-3-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:124c5f40a6cf0e642f9d92784dd66314fd548b4fdf93c543bf478e71e1209f9d
+size 6459392

poppler/poppler-24.08.0/Library/bin/libcurl.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a70c1cee2d55cf029eedc1a304e087d9276995d7caa0970832faf856d3bd4ae7
+size 617984

poppler/poppler-24.08.0/Library/bin/libexpat.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1eef16676ab7cabca520ed0b809bb7f38b23250a7d051942cf1b288aebdb9bfe
+size 402432

poppler/poppler-24.08.0/Library/bin/liblzma.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07a4148f1972c843ddb31dbf1d058a7f73cb375f74473c9220f1476b8b973518
+size 154624

poppler/poppler-24.08.0/Library/bin/libpng16.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54789e18aceb43b5ad8a1c6a3a496b9379dd63d3ce46aefeddbeec87b8da3a08
+size 196608

poppler/poppler-24.08.0/Library/bin/libssh2.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a37f850e18c32d9606a9c5b38039bc4079b9d9f0346a3aab4c34ad7e2e4b5d9
+size 244224

poppler/poppler-24.08.0/Library/bin/libtiff.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:58498f3e9e5f8444c9e315de6f35dae090e630978326838770187b5946303bda
+size 493056