Add application file

.gitignore

@@ -0,0 +1,2 @@
+.env
+/env

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,13 +1,75 @@
----
-title: ResumeAnalyserGroq
-emoji: 🏃
-colorFrom: green
-colorTo: green
-sdk: streamlit
-sdk_version: 1.43.2
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Resume ATS Scoring Application
+
+An advanced NLP-based Resume ATS (Applicant Tracking System) scoring application built with Streamlit. This application helps users evaluate and improve their resumes for specific job roles.
+
+## Features
+
+- **Resume Analysis**: Upload your resume and get an ATS compatibility score
+- **Job Role Matching**: Specify your target job role for tailored analysis
+- **Visualization**: View detailed graphs and charts of your resume's performance
+- **Word Cloud**: Visual representation of key terms in your resume
+- **History Comparison**: Compare previous resume versions to track improvements
+- **Advanced NLP**: Powered by Groq API for sophisticated natural language processing
+
+## Setup
+
+### Prerequisites
+
+- Python 3.8+
+- Groq API key
+
+### Installation
+
+1. Clone this repository
+2. Create and activate the virtual environment:
+   ```
+   python -m venv env
+   source env/bin/activate  # On Windows: env\Scripts\activate
+   ```
+3. Install the required packages:
+   ```
+   pip install -r requirements.txt
+   ```
+4. Create a `.env` file in the project root and add your Groq API key:
+   ```
+   GROQ_API_KEY=your_api_key_here
+   ```
+5. Run the application:
+   ```
+   streamlit run app.py
+   ```
+
+## Project Structure
+
+```
+├── app.py                  # Main Streamlit application
+├── requirements.txt        # Project dependencies
+├── .env                    # Environment variables (not tracked by git)
+├── .gitignore              # Git ignore file
+├── README.md               # Project documentation
+└── src/                    # Source code
+    ├── __init__.py         # Package initialization
+    ├── analyzer.py         # Resume analysis logic
+    ├── groq_client.py      # Groq API integration
+    ├── utils.py            # Utility functions
+    ├── visualization.py    # Data visualization components
+    └── pages/              # Streamlit pages
+        ├── __init__.py     # Package initialization
+        ├── home.py         # Home page
+        ├── analysis.py     # Analysis page
+        ├── visualization.py # Visualization page
+        └── history.py      # History comparison page
+```
+
+## Usage
+
+1. Navigate to the home page
+2. Upload your resume (PDF, DOCX, or TXT format)
+3. Enter your target job role
+4. View your ATS score and detailed analysis
+5. Explore visualizations and recommendations
+6. Save your results for future comparison
+
+## License
+
+Apache-2.0 license

app.py

@@ -0,0 +1,80 @@
+import streamlit as st
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Import page modules
+from src.pages.home import show_home_page
+from src.pages.analysis import show_analysis_page
+from src.pages.visualization import show_visualization_page
+from src.pages.history import show_history_page
+from src.pages.suggestions import show_suggestions_page
+
+# App configuration
+st.set_page_config(
+    page_title="Resume ATS Scorer",
+    page_icon="📝",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        color: #4a86e8;
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    .sub-header {
+        font-size: 1.5rem;
+        color: #666;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# App title
+st.markdown('<h1 class="main-header">Resume ATS Scoring System</h1>', unsafe_allow_html=True)
+st.markdown('<p class="sub-header">Optimize your resume for Applicant Tracking Systems</p>', unsafe_allow_html=True)
+
+# Session state initialization
+if 'resume_data' not in st.session_state:
+    st.session_state.resume_data = None
+if 'job_role' not in st.session_state:
+    st.session_state.job_role = ""
+if 'analysis_results' not in st.session_state:
+    st.session_state.analysis_results = None
+if 'history' not in st.session_state:
+    st.session_state.history = []
+
+# Navigation tabs
+tabs = st.tabs(["Home", "Analysis", "Visualization", "Suggestions", "History"])
+
+# Display the appropriate page based on the selected tab
+with tabs[0]:
+    show_home_page()
+    
+with tabs[1]:
+    show_analysis_page()
+    
+with tabs[2]:
+    show_visualization_page()
+    
+with tabs[3]:
+    show_suggestions_page()
+    
+with tabs[4]:
+    show_history_page()
+
+# Footer
+st.markdown("---")
+st.markdown("""
+<div style="text-align: center; color: #888; padding: 10px;">
+    <p>Resume ATS Scoring System | Powered by Groq API</p>
+</div>
+""", unsafe_allow_html=True)

requirements.txt

@@ -0,0 +1,22 @@
+# Core dependencies
+streamlit==1.22.0
+python-dotenv==1.0.0
+groq==0.18.0
+
+# Document processing
+pypdf2==3.0.1
+python-docx==0.8.11
+
+# Data processing and visualization
+pandas==2.0.1
+numpy==1.24.3
+matplotlib==3.7.1
+seaborn==0.12.2
+wordcloud==1.9.2
+
+# NLP libraries
+spacy==3.6.0
+scikit-learn==1.2.2
+
+# Storage
+pickle-mixin==1.0.2

src/__init__.py

@@ -0,0 +1,2 @@
+# Resume ATS Scoring Application
+# This package contains all the source code for the application

src/analyzer.py

@@ -0,0 +1,173 @@
+import os
+import re
+import spacy
+from sklearn.feature_extraction.text import CountVectorizer
+from src.groq_client import analyze_resume
+
+# Load spaCy model
+try:
+    nlp = spacy.load("en_core_web_sm")
+except OSError:
+    # If model is not installed, provide instructions
+    print("The spaCy model 'en_core_web_sm' is not installed.")
+    print("Please install it using: python3 -m spacy download en_core_web_sm")
+    # Create a simple placeholder model for basic functionality
+    nlp = spacy.blank("en")
+
+def preprocess_text(text):
+    """Preprocess resume text for analysis
+    
+    Args:
+        text (str): Raw text extracted from resume
+        
+    Returns:
+        str: Preprocessed text
+    """
+    # Remove special characters and extra whitespace
+    text = re.sub(r'[^\w\s]', ' ', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    
+    # Convert to lowercase
+    text = text.lower()
+    
+    return text
+
+def extract_keywords(text, job_role):
+    """Extract keywords from resume text
+    
+    Args:
+        text (str): Preprocessed resume text
+        job_role (str): Target job role
+        
+    Returns:
+        list: Extracted keywords
+    """
+    # Process the text with spaCy
+    doc = nlp(text)
+    
+    # Extract nouns, proper nouns, and skill-related words
+    keywords = [token.text for token in doc if token.pos_ in ["NOUN", "PROPN"] and len(token.text) > 2]
+    
+    # Use CountVectorizer to get the most common terms
+    vectorizer = CountVectorizer(max_features=50, stop_words='english', ngram_range=(1, 2))
+    X = vectorizer.fit_transform([text])
+    common_terms = vectorizer.get_feature_names_out()
+    
+    # Combine and remove duplicates
+    all_keywords = list(set(keywords + list(common_terms)))
+    
+    return all_keywords
+
+def analyze_resume_local(resume_text, job_role):
+    """Perform local analysis on resume text before calling the Groq API
+    
+    Args:
+        resume_text (str): Raw text extracted from resume
+        job_role (str): Target job role
+        
+    Returns:
+        dict: Local analysis results
+    """
+    # Preprocess the text
+    processed_text = preprocess_text(resume_text)
+    
+    # Extract keywords
+    keywords = extract_keywords(processed_text, job_role)
+    
+    # Perform basic format analysis
+    format_score = calculate_format_score(resume_text)
+    
+    # Perform basic readability analysis
+    readability_score = calculate_readability_score(resume_text)
+    
+    return {
+        "local_keywords": keywords,
+        "local_format_score": format_score,
+        "local_readability_score": readability_score
+    }
+
+def calculate_format_score(text):
+    """Calculate a basic format score for the resume
+    
+    Args:
+        text (str): Resume text
+        
+    Returns:
+        int: Format score (0-100)
+    """
+    score = 70  # Base score
+    
+    # Check for section headers
+    section_patterns = ["experience", "education", "skills", "projects", "certifications", "summary"]
+    found_sections = 0
+    for pattern in section_patterns:
+        if re.search(r'\b' + pattern + r'\b', text.lower()):
+            found_sections += 1
+    
+    # Adjust score based on sections found
+    section_score = min(found_sections * 5, 20)
+    score += section_score
+    
+    # Check for bullet points
+    bullet_count = text.count('•') + text.count('·') + text.count('-')
+    bullet_score = min(bullet_count, 10)
+    score += bullet_score
+    
+    return min(score, 100)  # Cap at 100
+
+def calculate_readability_score(text):
+    """Calculate a basic readability score for the resume
+    
+    Args:
+        text (str): Resume text
+        
+    Returns:
+        int: Readability score (0-100)
+    """
+    # Base score
+    score = 70
+    
+    # Split into sentences and words
+    sentences = re.split(r'[.!?]+', text)
+    sentences = [s.strip() for s in sentences if s.strip()]
+    
+    # Calculate average sentence length
+    if sentences:
+        words = []
+        for sentence in sentences:
+            words.extend(sentence.split())
+        
+        avg_sentence_length = len(words) / len(sentences)
+        
+        # Penalize very long sentences
+        if avg_sentence_length > 25:
+            score -= 10
+        elif avg_sentence_length < 10:
+            score += 5
+    
+    return min(max(score, 0), 100)  # Keep between 0-100
+
+def get_resume_analysis(resume_text, job_role, job_description=None):
+    """Main function to analyze a resume
+    
+    Args:
+        resume_text (str): Text extracted from resume
+        job_role (str): Target job role
+        job_description (str, optional): Specific job description for enhanced analysis
+        
+    Returns:
+        dict: Complete analysis results
+    """
+    # First perform local analysis
+    local_results = analyze_resume_local(resume_text, job_role)
+    
+    # Then call the Groq API for advanced analysis
+    groq_results = analyze_resume(resume_text, job_role, job_description)
+    
+    # Combine results
+    combined_results = {
+        **groq_results,
+        "local_keywords": local_results["local_keywords"]
+    }
+    
+    return combined_results

src/groq_client.py

@@ -0,0 +1,172 @@
+import os
+import json
+from groq import Groq
+
+# Initialize Groq client
+def get_groq_client():
+    """Initialize and return a Groq client using the API key from environment variables"""
+    api_key = os.getenv("GROQ_API_KEY")
+    if not api_key:
+        raise ValueError("GROQ_API_KEY environment variable not set. Please add it to your .env file.")
+    return Groq(api_key=api_key)
+
+def analyze_resume(resume_text, job_role, job_description=None):
+    """Analyze a resume using the Groq API
+    
+    Args:
+        resume_text (str): The extracted text from the resume
+        job_role (str): The target job role
+        job_description (str, optional): Specific job description for enhanced analysis
+        
+    Returns:
+        dict: Analysis results including scores and recommendations
+    """
+    client = get_groq_client()
+    
+    # Prepare the prompt for the Groq API
+    job_desc_text = ""
+    if job_description:
+        job_desc_text = f"""
+        JOB DESCRIPTION:
+        {job_description}
+        
+        Please analyze the resume specifically against this job description, identifying exact matches and gaps.
+        """
+    
+    prompt = f"""
+    You are an expert ATS (Applicant Tracking System) analyzer and resume consultant with deep knowledge of industry trends. 
+    Please analyze the following resume for the role of {job_role}.
+    
+    RESUME TEXT:
+    {resume_text}
+    {job_desc_text}
+    Provide a comprehensive analysis in the following JSON format:
+    {{
+        "ats_score": <overall score from 0-100>,
+        "keyword_match": <keyword match score from 0-100>,
+        "format_score": <format and structure score from 0-100>,
+        "readability_score": <readability score from 0-100>,
+        "document_structure_score": <score for document organization and flow from 0-100>,
+        "section_headers_score": <score for section header clarity and formatting from 0-100>,
+        "content_organization_score": <score for content layout and organization from 0-100>,
+        "visual_layout_score": <score for visual presentation and spacing from 0-100>,
+        "strengths": [<list of 3-5 strengths>],
+        "improvements": [<list of 3-5 areas for improvement>],
+        "missing_keywords": [<list of important keywords missing from the resume>],
+        "present_keywords": [<list of important keywords present in the resume>],
+        "recommendations": [<list of 3-5 specific recommendations to improve the resume>],
+        "skill_gaps": [<list of specific skills mentioned in the job description but missing from the resume>],
+        "experience_gaps": [<list of experience requirements mentioned in the job description but not evident in the resume>],
+        "resume_enhancement_tips": [<list of 3-5 specific ways to enhance the resume for this exact job>],
+        "format_tips": [<list of specific formatting recommendations>],
+        "industry_trends": [<list of 3-5 current trends in the industry relevant to the role>],
+        "career_recommendations": [<list of 3-5 career development suggestions based on the resume and role>],
+        "recommended_certifications": [<list of relevant certifications that would enhance the candidate's profile>]
+    }}
+    
+    Ensure your analysis is detailed, specific to the {job_role} role, and actionable. Include current industry trends, career development paths, and relevant certifications for the role.
+    """
+    
+    # Call the Groq API
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are an expert ATS analyzer and resume consultant."},
+                {"role": "user", "content": prompt}
+            ],
+            model="llama3-70b-8192",  # Using Llama 3 70B model for high-quality analysis
+            temperature=0.2,  # Low temperature for more consistent results
+            max_tokens=4000,  # Allow for detailed analysis
+            top_p=0.9
+        )
+        
+        # Extract and parse the response
+        response_text = chat_completion.choices[0].message.content
+        
+        # Find the JSON part in the response
+        try:
+            # Try to parse the entire response as JSON first
+            analysis_results = json.loads(response_text)
+        except json.JSONDecodeError:
+            # If that fails, try to extract JSON from the text
+            import re
+            json_match = re.search(r'\{\s*"ats_score".*\}', response_text, re.DOTALL)
+            if json_match:
+                analysis_results = json.loads(json_match.group(0))
+            else:
+                raise ValueError("Could not extract valid JSON from the API response")
+        
+        # Ensure all required fields are present
+        required_fields = [
+            "ats_score", "keyword_match", "format_score", "readability_score",
+            "document_structure_score", "section_headers_score", "content_organization_score", "visual_layout_score",
+            "strengths", "improvements", "missing_keywords", "present_keywords", "recommendations", "format_tips",
+            "industry_trends", "career_recommendations", "recommended_certifications"
+        ]
+        
+        for field in required_fields:
+            if field not in analysis_results:
+                if field in ["missing_keywords", "present_keywords"]:
+                    analysis_results[field] = []
+                elif field in ["strengths", "improvements", "recommendations"]:
+                    analysis_results[field] = ["No specific " + field + " identified."]
+                else:
+                    analysis_results[field] = 70  # Default score
+        
+        return analysis_results
+        
+    except Exception as e:
+        # Handle API errors
+        error_msg = f"Error calling Groq API: {str(e)}"
+        print(error_msg)
+        raise Exception(error_msg)
+
+# Example of how the analysis results should look
+SAMPLE_ANALYSIS = {
+    "ats_score": 78,
+    "keyword_match": 72,
+    "format_score": 85,
+    "readability_score": 80,
+    "document_structure_score": 82,
+    "section_headers_score": 88,
+    "content_organization_score": 85,
+    "visual_layout_score": 80,
+    "strengths": [
+        "Clear section headings that are ATS-friendly",
+        "Good use of action verbs and quantifiable achievements",
+        "Relevant technical skills clearly listed",
+        "Consistent formatting throughout the document"
+    ],
+    "improvements": [
+        "Missing some key industry-specific keywords",
+        "Contact information could be more prominently displayed",
+        "Some bullet points are too lengthy for optimal ATS parsing",
+        "Education section lacks detail about relevant coursework"
+    ],
+    "missing_keywords": [
+        "project management",
+        "agile methodology",
+        "cross-functional",
+        "stakeholder management",
+        "KPI tracking"
+    ],
+    "present_keywords": [
+        "data analysis",
+        "team leadership",
+        "strategic planning",
+        "budget management"
+    ],
+    "recommendations": [
+        "Add more industry-specific keywords relevant to the job description",
+        "Shorten bullet points to 1-2 lines for better readability",
+        "Include a skills section with both technical and soft skills",
+        "Quantify more achievements with specific metrics and results",
+        "Ensure consistent date formatting throughout the resume"
+    ],
+    "format_tips": [
+        "Use consistent font sizes for section headers",
+        "Maintain standard margins throughout the document",
+        "Ensure proper spacing between sections",
+        "Use bullet points consistently for better readability"
+    ]
+}

src/pages/__init__.py

@@ -0,0 +1,2 @@
+# Pages package for the Resume ATS Scoring Application
+# Contains all the page modules for the Streamlit application

src/pages/analysis.py

@@ -0,0 +1,179 @@
+import streamlit as st
+import pandas as pd
+import time
+from datetime import datetime
+import os
+from src.groq_client import analyze_resume
+
+def show_analysis_page():
+    """Display the analysis page with resume scoring and feedback"""
+    st.header("Resume Analysis")
+    
+    # Check if resume data is available
+    if st.session_state.resume_data is None:
+        st.info("Please upload your resume on the Home page first.")
+        return
+    
+    # Check if job role is available
+    if not st.session_state.job_role:
+        st.warning("Please specify your target job role on the Home page.")
+        return
+    
+    # Display resume and job role information
+    st.subheader("Analysis Information")
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown(f"**Resume**: {st.session_state.resume_data['filename']}")
+    with col2:
+        st.markdown(f"**Target Job Role**: {st.session_state.job_role}")
+    
+    # Check if analysis results are already available
+    if st.session_state.analysis_results is None:
+        # Show analysis in progress
+        with st.spinner("Analyzing your resume... This may take a moment."):
+            try:
+                # Call the Groq API to analyze the resume
+                analysis_results = analyze_resume(
+                    resume_text=st.session_state.resume_data["text"],
+                    job_role=st.session_state.job_role,
+                    job_description=st.session_state.get("job_description", None)
+                )
+                
+                # Store the analysis results in session state
+                st.session_state.analysis_results = {
+                    **analysis_results,
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                }
+                
+                # Add to history for comparison
+                st.session_state.history.append({
+                    "filename": st.session_state.resume_data["filename"],
+                    "job_role": st.session_state.job_role,
+                    "timestamp": st.session_state.analysis_results["timestamp"],
+                    "ats_score": st.session_state.analysis_results["ats_score"],
+                    "keyword_match": st.session_state.analysis_results["keyword_match"],
+                    "format_score": st.session_state.analysis_results["format_score"],
+                    "readability_score": st.session_state.analysis_results["readability_score"]
+                })
+                
+                # Success message
+                st.success("Analysis completed successfully!")
+                
+            except Exception as e:
+                st.error(f"Error analyzing resume: {str(e)}")
+                return
+    
+    # Display the analysis results
+    results = st.session_state.analysis_results
+    
+    # Overall ATS Score
+    st.subheader("ATS Compatibility Score")
+    score_col1, score_col2 = st.columns([1, 3])
+    with score_col1:
+        st.markdown(
+            f"<div style='background-color: {'#4CAF50' if results['ats_score'] >= 80 else '#FFC107' if results['ats_score'] >= 60 else '#F44336'}; "
+            f"padding: 20px; border-radius: 10px; text-align: center;'>"
+            f"<h1 style='color: white; margin: 0;'>{results['ats_score']}/100</h1>"
+            f"</div>",
+            unsafe_allow_html=True
+        )
+    with score_col2:
+        st.markdown(f"**Analysis Date**: {results['timestamp']}")
+        st.markdown(f"**Keyword Match**: {results['keyword_match']}/100")
+        st.markdown(f"**Format & Structure**: {results['format_score']}/100")
+        st.markdown(f"**Readability**: {results['readability_score']}/100")
+        
+        # Detailed Format Scores
+        st.markdown("### Detailed Format Scores")
+        format_scores = {
+            "Document Structure": results.get('document_structure_score', 0),
+            "Section Headers": results.get('section_headers_score', 0),
+            "Content Organization": results.get('content_organization_score', 0),
+            "Visual Layout": results.get('visual_layout_score', 0)
+        }
+        
+        for score_name, score in format_scores.items():
+            st.markdown(
+                f"<div style='margin-bottom: 10px;'>"
+                f"<span style='color: #666;'>{score_name}:</span> "
+                f"<span style='color: {'#4CAF50' if score >= 80 else '#FFC107' if score >= 60 else '#F44336'};'>"
+                f"{score}/100</span></div>",
+                unsafe_allow_html=True
+            )
+        
+        # Format Tips
+        if format_tips := results.get('format_tips', []):
+            with st.expander("Format Improvement Tips", expanded=True):
+                for tip in format_tips:
+                    st.markdown(f"- {tip}")
+    
+    # Detailed Analysis
+    st.subheader("Detailed Analysis")
+    with st.expander("Strengths", expanded=True):
+        for strength in results['strengths']:
+            st.markdown(f"- {strength}")
+    
+    with st.expander("Areas for Improvement", expanded=True):
+        for improvement in results['improvements']:
+            st.markdown(f"- {improvement}")
+    
+    # Missing Keywords
+    st.subheader("Missing Keywords")
+    st.markdown("These keywords are commonly found in job descriptions for your target role but are missing from your resume:")
+    missing_keywords = results['missing_keywords']
+    if missing_keywords:
+        # Display as a table
+        keyword_df = pd.DataFrame({
+            "Keyword": missing_keywords,
+            "Importance": ["High" if i < len(missing_keywords)//3 else 
+                         "Medium" if i < 2*len(missing_keywords)//3 else 
+                         "Low" for i in range(len(missing_keywords))]
+        })
+        st.dataframe(keyword_df, use_container_width=True)
+    else:
+        st.info("Great job! Your resume contains all the important keywords for this role.")
+    
+    # Advanced Resume Review (when job description is provided)
+    if st.session_state.get("job_description"):
+        st.subheader("Advanced Resume Review")
+        
+        # Create tabs for different aspects of the advanced review
+        review_tabs = st.tabs(["Skill Gaps", "Experience Gaps", "Enhancement Tips"])
+        
+        # Skill Gaps tab
+        with review_tabs[0]:
+            st.markdown("### Skill Gaps")
+            st.markdown("These are specific skills mentioned in the job description that are missing from your resume:")
+            skill_gaps = results.get('skill_gaps', [])
+            if skill_gaps:
+                for skill in skill_gaps:
+                    st.markdown(f"- {skill}")
+            else:
+                st.success("Great job! Your resume covers all the key skills mentioned in the job description.")
+        
+        # Experience Gaps tab
+        with review_tabs[1]:
+            st.markdown("### Experience Gaps")
+            st.markdown("These are experience requirements from the job description that aren't clearly demonstrated in your resume:")
+            experience_gaps = results.get('experience_gaps', [])
+            if experience_gaps:
+                for exp in experience_gaps:
+                    st.markdown(f"- {exp}")
+            else:
+                st.success("Your experience appears to match the job requirements well!")
+        
+        # Enhancement Tips tab
+        with review_tabs[2]:
+            st.markdown("### Resume Enhancement Tips")
+            st.markdown("Specific ways to enhance your resume for this exact job:")
+            enhancement_tips = results.get('resume_enhancement_tips', [])
+            if enhancement_tips:
+                for tip in enhancement_tips:
+                    st.markdown(f"- {tip}")
+    
+    # Recommendations
+    st.subheader("Recommendations")
+    for recommendation in results['recommendations']:
+        st.markdown(f"- {recommendation}")
+    
+    # Action buttons section removed as requested

src/pages/history.py

@@ -0,0 +1,132 @@
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime
+
+def show_history_page():
+    """Display the history page with previous resume analyses"""
+    st.header("Resume Analysis History")
+    
+    # Check if there's any history data
+    if not st.session_state.history:
+        st.info("You haven't analyzed any resumes yet. Upload and analyze a resume to see your history.")
+        return
+    
+    # Display history data
+    st.subheader("Previous Analyses")
+    
+    # Create a DataFrame from history data
+    history_df = pd.DataFrame(st.session_state.history)
+    
+    # Format the DataFrame for display
+    display_df = history_df[['timestamp', 'filename', 'job_role', 'ats_score', 'keyword_match', 'format_score', 'readability_score']].copy()
+    display_df.columns = ['Timestamp', 'Resume', 'Job Role', 'ATS Score', 'Keyword Match', 'Format Score', 'Readability Score']
+    
+    # Display the history table
+    st.dataframe(display_df, use_container_width=True)
+    
+    # Option to clear history
+    if st.button("Clear History", type="secondary"):
+        st.session_state.history = []
+        st.success("History cleared successfully!")
+        st.experimental_rerun()
+    
+    # Trend analysis (if there are multiple entries)
+    if len(st.session_state.history) > 1:
+        st.subheader("Score Trend Analysis")
+        
+        # Create trend data
+        trend_data = history_df.sort_values('timestamp')
+        
+        # Plot the trend
+        fig, ax = plt.subplots(figsize=(12, 6))
+        
+        # Plot each score type
+        ax.plot(trend_data['timestamp'], trend_data['ats_score'], marker='o', linewidth=2, label='ATS Score')
+        ax.plot(trend_data['timestamp'], trend_data['keyword_match'], marker='s', linewidth=2, label='Keyword Match')
+        ax.plot(trend_data['timestamp'], trend_data['format_score'], marker='^', linewidth=2, label='Format Score')
+        ax.plot(trend_data['timestamp'], trend_data['readability_score'], marker='d', linewidth=2, label='Readability Score')
+        
+        # Customize the plot
+        ax.set_title('Resume Score Trends Over Time')
+        ax.set_ylim(0, 100)
+        ax.set_ylabel('Score')
+        ax.set_xlabel('Analysis Date')
+        ax.grid(True, linestyle='--', alpha=0.7)
+        ax.legend()
+        
+        # Rotate x-axis labels for better readability
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        
+        # Display the plot
+        st.pyplot(fig)
+        
+        # Improvement analysis
+        if len(st.session_state.history) >= 2:
+            st.subheader("Improvement Analysis")
+            
+            # Get the first and last entries
+            first_entry = trend_data.iloc[0]
+            last_entry = trend_data.iloc[-1]
+            
+            # Calculate improvements
+            ats_improvement = last_entry['ats_score'] - first_entry['ats_score']
+            keyword_improvement = last_entry['keyword_match'] - first_entry['keyword_match']
+            format_improvement = last_entry['format_score'] - first_entry['format_score']
+            readability_improvement = last_entry['readability_score'] - first_entry['readability_score']
+            
+            # Display improvements
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric(
+                    "ATS Score Improvement",
+                    f"{last_entry['ats_score']}/100",
+                    delta=f"{ats_improvement:+.1f}"
+                )
+            
+            with col2:
+                st.metric(
+                    "Keyword Match Improvement",
+                    f"{last_entry['keyword_match']}/100",
+                    delta=f"{keyword_improvement:+.1f}"
+                )
+            
+            with col3:
+                st.metric(
+                    "Format Score Improvement",
+                    f"{last_entry['format_score']}/100",
+                    delta=f"{format_improvement:+.1f}"
+                )
+            
+            with col4:
+                st.metric(
+                    "Readability Score Improvement",
+                    f"{last_entry['readability_score']}/100",
+                    delta=f"{readability_improvement:+.1f}"
+                )
+            
+            # Overall assessment
+            if ats_improvement > 0:
+                st.success("Your resume has improved since your first analysis! Keep up the good work.")
+            elif ats_improvement == 0:
+                st.info("Your overall score has remained the same. Check the specific metrics to see where you can improve.")
+            else:
+                st.warning("Your overall score has decreased. This might be because you're targeting a different job role or have made changes that reduced ATS compatibility.")
+    
+    # Tips for improvement
+    st.subheader("Tips for Improving Your Score")
+    st.markdown("""
+    ### How to Improve Your ATS Score
+    
+    1. **Add missing keywords** from your target job descriptions
+    2. **Use standard section headings** that ATS systems can easily recognize
+    3. **Simplify formatting** by removing tables, text boxes, and complex layouts
+    4. **Quantify achievements** with numbers and metrics
+    5. **Use industry-standard terminology** relevant to your target role
+    6. **Tailor your resume** for each specific job application
+    7. **Use a clean, simple design** with standard fonts
+    8. **Save as PDF or DOCX** formats that are ATS-friendly
+    """)

src/pages/home.py

@@ -0,0 +1,155 @@
+import streamlit as st
+import os
+import tempfile
+from PyPDF2 import PdfReader
+import docx
+from datetime import datetime
+
+def extract_text_from_pdf(file):
+    """Extract text from a PDF file"""
+    pdf_reader = PdfReader(file)
+    text = ""
+    for page in pdf_reader.pages:
+        text += page.extract_text() + "\n"
+    return text
+
+def extract_text_from_docx(file):
+    """Extract text from a DOCX file"""
+    doc = docx.Document(file)
+    text = ""
+    for paragraph in doc.paragraphs:
+        text += paragraph.text + "\n"
+    return text
+
+def show_home_page():
+    """Display the home page with resume upload and job role input"""
+    # Initialize session state variables if they don't exist
+    if "job_role" not in st.session_state:
+        st.session_state.job_role = ""
+    if "job_description" not in st.session_state:
+        st.session_state.job_description = ""
+    if "resume_data" not in st.session_state:
+        st.session_state.resume_data = None
+    if "active_tab" not in st.session_state:
+        st.session_state.active_tab = 0
+        
+    st.header("Upload Your Resume")
+    
+    # File uploader for resume
+    uploaded_file = st.file_uploader(
+        "Upload your resume (PDF or DOCX)", 
+        type=["pdf", "docx", "txt"],
+        help="Upload your resume to get an ATS compatibility score"
+    )
+    
+    # Job role input
+    job_role = st.text_input(
+        "Enter your target job role",
+        value=st.session_state.job_role if st.session_state.job_role else "",
+        placeholder="e.g., Data Scientist, Software Engineer, Product Manager",
+        help="Specify the job role you're applying for to get tailored analysis"
+    )
+    
+    # Job description toggle and input
+    job_desc_toggle = st.checkbox(
+        "Add specific job description for enhanced analysis",
+        help="Toggle this to add a specific job description for more accurate ATS analysis"
+    )
+    
+    job_description = ""
+    if job_desc_toggle:
+        job_description = st.text_area(
+            "Paste the job description",
+            value=st.session_state.get("job_description", ""),
+            height=200,
+            placeholder="Paste the full job description here for more precise keyword matching and tailored recommendations...",
+            help="Adding the actual job description significantly improves analysis accuracy"
+        )
+    
+    # Process the uploaded file
+    if uploaded_file is not None:
+        try:
+            # Create a temporary file to store the uploaded file
+            with tempfile.NamedTemporaryFile(delete=False, suffix=f'.{uploaded_file.name.split(".")[-1]}') as tmp_file:
+                tmp_file.write(uploaded_file.getvalue())
+                tmp_file_path = tmp_file.name
+            
+            # Extract text from the file based on its type
+            if uploaded_file.name.endswith('.pdf'):
+                resume_text = extract_text_from_pdf(tmp_file_path)
+            elif uploaded_file.name.endswith('.docx'):
+                resume_text = extract_text_from_docx(tmp_file_path)
+            else:  # Assume it's a text file
+                resume_text = uploaded_file.getvalue().decode("utf-8")
+            
+            # Clean up the temporary file
+            os.unlink(tmp_file_path)
+            
+            # Store the resume data, job role, and job description in session state
+            st.session_state.resume_data = {
+                "filename": uploaded_file.name,
+                "text": resume_text,
+                "upload_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            }
+            st.session_state.job_role = job_role
+            
+            # Store job description if provided
+            if job_desc_toggle and job_description:
+                st.session_state.job_description = job_description
+            elif not job_desc_toggle:
+                # Clear job description if toggle is off
+                st.session_state.job_description = ""
+            
+            # Display success message
+            st.success(f"Resume '{uploaded_file.name}' uploaded successfully!")
+            
+            # Preview the extracted text
+            with st.expander("Preview Extracted Text"):
+                st.text_area("Extracted Text", resume_text, height=300)
+        
+        except Exception as e:
+            st.error(f"Error processing the file: {str(e)}")
+    
+    # Instructions and tips
+    with st.expander("Tips for ATS-Friendly Resumes"):
+        st.markdown("""
+        ### Tips to Make Your Resume ATS-Friendly
+        
+        1. **Use standard section headings** (e.g., Education, Experience, Skills)
+        2. **Include relevant keywords** from the job description
+        3. **Avoid using tables, headers, footers, and text boxes**
+        4. **Use standard fonts** like Arial, Calibri, or Times New Roman
+        5. **Save your resume as a simple PDF or DOCX file**
+        6. **Include your contact information** at the top of the resume
+        7. **Quantify your achievements** with numbers and metrics
+        8. **Proofread carefully** for spelling and grammar errors
+        """)
+    
+    # Action buttons at the bottom of the page
+    if uploaded_file is not None and job_role:
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Save to History", type="primary", use_container_width=True, key="save_history_bottom"):
+                # Create a basic entry with available information
+                if "history" not in st.session_state:
+                    st.session_state.history = []
+                
+                history_entry = {
+                    "filename": st.session_state.resume_data["filename"],
+                    "job_role": st.session_state.job_role,
+                    "timestamp": st.session_state.resume_data["upload_time"],
+                    "ats_score": 0,  # Placeholder until analysis is done
+                    "keyword_match": 0,
+                    "format_score": 0,
+                    "readability_score": 0
+                }
+                
+                st.session_state.history.append(history_entry)
+                st.success("Resume saved to history!")
+        with col2:
+            if st.button("Analyze Resume", type="primary", use_container_width=True, key="analyze_bottom"):
+                if job_role:
+                    st.session_state.active_tab = 1  # Switch to Analysis tab
+                    st.rerun()
+                else:
+                    st.warning("Please enter your target job role before analyzing.")

src/pages/suggestions.py

@@ -0,0 +1,155 @@
+import streamlit as st
+import pandas as pd
+
+def show_suggestions_page():
+    """Display suggestions and recommendations for resume improvement"""
+    st.header("Resume Suggestions & Recommendations")
+    
+    # Check if resume data is available
+    if st.session_state.resume_data is None:
+        st.info("Please upload your resume on the Home page first.")
+        return
+    
+    # Check if analysis results are available
+    if st.session_state.analysis_results is None:
+        st.warning("Please analyze your resume first to get personalized suggestions.")
+        return
+    
+    # Get analysis results
+    results = st.session_state.analysis_results
+    
+    # Resume Overview Section
+    st.subheader("Resume Overview")
+    overview_col1, overview_col2 = st.columns(2)
+    
+    with overview_col1:
+        st.markdown("### Current Resume Status")
+        st.markdown(f"**Overall ATS Score**: {results['ats_score']}/100")
+        st.markdown(f"**Keyword Match Rate**: {results['keyword_match']}/100")
+        st.markdown(f"**Format Score**: {results['format_score']}/100")
+        st.markdown(f"**Readability Score**: {results['readability_score']}/100")
+    
+    with overview_col2:
+        st.markdown("### Target Job Role")
+        st.markdown(f"**Role**: {st.session_state.job_role}")
+        if st.session_state.get('job_description'):
+            st.markdown("✅ Using specific job description for analysis")
+        else:
+            st.markdown("ℹ️ Using general role requirements for analysis")
+    
+    # Detailed Suggestions Tabs
+    suggestion_tabs = st.tabs(["Content Enhancement", "Skills & Keywords", "Format & Structure", "Industry Insights"])
+    
+    # Content Enhancement Tab
+    with suggestion_tabs[0]:
+        st.markdown("### Content Enhancement Suggestions")
+        
+        # Current Strengths
+        st.markdown("#### Current Strengths")
+        for strength in results['strengths']:
+            st.markdown(f"✅ {strength}")
+        
+        # Areas for Improvement
+        st.markdown("#### Areas for Improvement")
+        for improvement in results['improvements']:
+            st.markdown(f"🔄 {improvement}")
+        
+        # Specific Recommendations
+        st.markdown("#### Action Items")
+        for recommendation in results['recommendations']:
+            st.markdown(f"📌 {recommendation}")
+    
+    # Skills & Keywords Tab
+    with suggestion_tabs[1]:
+        st.markdown("### Skills & Keywords Analysis")
+        
+        # Present Keywords
+        st.markdown("#### Present Keywords")
+        present_keywords = results.get('present_keywords', [])
+        if present_keywords:
+            for keyword in present_keywords:
+                st.markdown(f"✅ {keyword}")
+        else:
+            st.info("No keywords were identified in your resume. Consider adding relevant keywords from the job description.")
+        
+        # Missing Keywords with Importance
+        st.markdown("#### Missing Keywords")
+        missing_keywords = results.get('missing_keywords', [])
+        if missing_keywords:
+            keyword_df = pd.DataFrame({
+                "Keyword": missing_keywords,
+                "Importance": ["High" if i < len(missing_keywords)//3 else 
+                             "Medium" if i < 2*len(missing_keywords)//3 else 
+                             "Low" for i in range(len(missing_keywords))]
+            })
+            st.dataframe(keyword_df, use_container_width=True)
+        else:
+            st.success("Great job! Your resume appears to contain all the important keywords for this role.")
+        
+        # Industry-Specific Skills
+        st.markdown("#### Recommended Industry Skills")
+        if 'recommended_skills' in results and results['recommended_skills']:
+            for skill in results['recommended_skills']:
+                st.markdown(f"💡 {skill}")
+        else:
+            st.info("No additional industry-specific skills recommendations available for your target role.")
+    
+    # Format & Structure Tab
+    with suggestion_tabs[2]:
+        st.markdown("### Format & Structure Analysis")
+        
+        # Format Score Breakdown
+        st.markdown("#### Format Score Components")
+        format_components = [
+            "Document Structure",
+            "Section Headers",
+            "Content Organization",
+            "Visual Layout"
+        ]
+        has_scores = False
+        for component in format_components:
+            score = results.get(f"{component.lower().replace(' ', '_')}_score", 0)
+            if score > 0:
+                has_scores = True
+            st.progress(score/100)
+            st.markdown(f"**{component}**: {score}/100")
+        
+        if not has_scores:
+            st.info("Detailed format scoring is not available. Please ensure your resume has been properly analyzed.")
+        
+        # Format Recommendations
+        st.markdown("#### Format Improvement Tips")
+        format_tips = results.get('format_tips', [])
+        if format_tips:
+            for tip in format_tips:
+                st.markdown(f"🔧 {tip}")
+        else:
+            st.info("No specific format improvement tips available. Your resume format may already be well-structured.")
+    
+    # Industry Insights Tab
+    with suggestion_tabs[3]:
+        st.markdown("### Industry Insights & Trends")
+        
+        # Job Market Trends
+        st.markdown("#### Current Job Market Trends")
+        if 'industry_trends' in results and results['industry_trends']:
+            for trend in results['industry_trends']:
+                st.markdown(f"📈 {trend}")
+        else:
+            st.info("Industry trend data is not available at the moment.")
+        
+        # Career Development Suggestions
+        st.markdown("#### Career Development Recommendations")
+        if 'career_recommendations' in results and results['career_recommendations']:
+            for rec in results['career_recommendations']:
+                st.markdown(f"🎯 {rec}")
+        else:
+            st.info("Career development recommendations will be available after analyzing your resume against specific job requirements.")
+        
+        # Certification Recommendations
+        st.markdown("#### Recommended Certifications")
+        if 'recommended_certifications' in results and results['recommended_certifications']:
+            for cert in results['recommended_certifications']:
+                st.markdown(f"🏅 {cert}")
+        else:
+            st.info("No specific certification recommendations available for your target role at this time.")

src/pages/visualization.py

@@ -0,0 +1,241 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from wordcloud import WordCloud
+import re
+
+def show_visualization_page():
+    """Display visualizations of resume analysis results"""
+    st.header("Resume Analysis Visualizations")
+    
+    # Check if analysis results are available
+    if st.session_state.analysis_results is None:
+        st.info("Please analyze your resume on the Analysis page first.")
+        return
+    
+    # Get analysis results
+    results = st.session_state.analysis_results
+    resume_text = st.session_state.resume_data["text"]
+    job_role = st.session_state.job_role
+    
+    # Create tabs for different visualizations
+    viz_tabs = st.tabs(["Score Breakdown", "Word Cloud", "Keyword Analysis", "Comparison"])
+    
+    # Score Breakdown tab
+    with viz_tabs[0]:
+        st.subheader("ATS Score Breakdown")
+        
+        # Create data for the score breakdown chart
+        score_data = pd.DataFrame({
+            'Category': ['Overall ATS Score', 'Keyword Match', 'Format & Structure', 'Readability'],
+            'Score': [
+                results['ats_score'], 
+                results['keyword_match'], 
+                results['format_score'], 
+                results['readability_score']
+            ]
+        })
+        
+        # Create a horizontal bar chart
+        fig, ax = plt.subplots(figsize=(10, 6))
+        bars = ax.barh(
+            score_data['Category'], 
+            score_data['Score'],
+            color=['#4a86e8', '#ff9900', '#6aa84f', '#e06666']
+        )
+        
+        # Add score labels to the bars
+        for bar in bars:
+            width = bar.get_width()
+            ax.text(
+                width + 2, 
+                bar.get_y() + bar.get_height()/2, 
+                f'{width}/100', 
+                va='center'
+            )
+        
+        # Customize the chart
+        ax.set_xlim(0, 105)
+        ax.set_xlabel('Score')
+        ax.set_title('Resume ATS Score Breakdown')
+        ax.grid(axis='x', linestyle='--', alpha=0.7)
+        
+        # Display the chart
+        st.pyplot(fig)
+        
+        # Add explanation
+        st.markdown("""
+        ### Score Explanation
+        
+        - **Overall ATS Score**: Composite score indicating how well your resume would perform in an ATS system
+        - **Keyword Match**: How well your resume matches keywords for the target job role
+        - **Format & Structure**: Assessment of your resume's formatting and structure for ATS compatibility
+        - **Readability**: How easy your resume is to read and understand
+        """)
+    
+    # Word Cloud tab
+    with viz_tabs[1]:
+        st.subheader("Resume Word Cloud")
+        
+        # Process text for word cloud
+        def preprocess_text(text):
+            # Remove special characters and numbers
+            text = re.sub(r'[^\w\s]', '', text)
+            text = re.sub(r'\d+', '', text)
+            # Convert to lowercase
+            text = text.lower()
+            # Remove common stop words (simplified version)
+            stop_words = ['and', 'the', 'to', 'of', 'in', 'a', 'for', 'with', 'on', 'at', 'from', 'by', 'an', 'is', 'was', 'were', 'are', 'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did', 'but', 'or', 'as', 'if', 'while', 'because', 'so', 'than', 'that', 'this', 'these', 'those', 'then', 'not', 'no']
+            words = text.split()
+            filtered_words = [word for word in words if word not in stop_words and len(word) > 2]
+            return ' '.join(filtered_words)
+        
+        processed_text = preprocess_text(resume_text)
+        
+        # Generate word cloud
+        wordcloud = WordCloud(
+            width=800, 
+            height=400, 
+            background_color='white', 
+            colormap='viridis', 
+            max_words=100, 
+            contour_width=1, 
+            contour_color='steelblue'
+        ).generate(processed_text)
+        
+        # Display word cloud
+        fig, ax = plt.subplots(figsize=(12, 8))
+        ax.imshow(wordcloud, interpolation='bilinear')
+        ax.axis('off')
+        st.pyplot(fig)
+        
+        st.markdown("""
+        ### Word Cloud Analysis
+        
+        The word cloud visualizes the most frequently used words in your resume. 
+        Larger words appear more frequently. This can help you identify:
+        
+        - Which terms are most prominent in your resume
+        - Whether your resume emphasizes the right skills and experiences
+        - Potential overused words that could be replaced with more impactful terms
+        """)
+    
+    # Keyword Analysis tab
+    with viz_tabs[2]:
+        st.subheader("Keyword Analysis")
+        
+        # Create data for present and missing keywords
+        present_keywords = results.get('present_keywords', [])
+        missing_keywords = results.get('missing_keywords', [])
+        
+        # Display keyword match percentage
+        st.metric(
+            "Keyword Match Rate", 
+            f"{results['keyword_match']}%",
+            delta=f"{len(present_keywords)} present, {len(missing_keywords)} missing"
+        )
+        
+        # Create columns for present and missing keywords
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("### Present Keywords")
+            if present_keywords:
+                for keyword in present_keywords:
+                    st.markdown(f"✅ {keyword}")
+            else:
+                st.info("No matching keywords found.")
+        
+        with col2:
+            st.markdown("### Missing Keywords")
+            if missing_keywords:
+                for keyword in missing_keywords:
+                    st.markdown(f"❌ {keyword}")
+            else:
+                st.success("Great job! Your resume contains all important keywords.")
+        
+        # Keyword distribution chart
+        if present_keywords or missing_keywords:
+            st.subheader("Keyword Distribution")
+            
+            # Create data for pie chart
+            labels = ['Present', 'Missing']
+            sizes = [len(present_keywords), len(missing_keywords)]
+            colors = ['#4CAF50', '#F44336']
+            
+            # Create pie chart
+            fig, ax = plt.subplots(figsize=(8, 8))
+            ax.pie(
+                sizes, 
+                labels=labels, 
+                colors=colors, 
+                autopct='%1.1f%%',
+                startangle=90,
+                shadow=True,
+                explode=(0.05, 0)
+            )
+            ax.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle
+            
+            # Display the chart
+            st.pyplot(fig)
+    
+    # Comparison tab (if history exists)
+    with viz_tabs[3]:
+        st.subheader("Historical Comparison")
+        
+        if len(st.session_state.history) <= 1:
+            st.info("You need at least two resume analyses to see a comparison. Save your current analysis and upload a different version of your resume to compare.")
+        else:
+            # Create data for the comparison chart
+            history_data = pd.DataFrame(st.session_state.history)
+            
+            # Select which versions to compare
+            selected_versions = st.multiselect(
+                "Select resume versions to compare",
+                options=history_data['timestamp'].tolist(),
+                default=history_data['timestamp'].tolist()[-2:]
+            )
+            
+            if selected_versions:
+                # Filter data based on selection
+                filtered_data = history_data[history_data['timestamp'].isin(selected_versions)]
+                
+                # Create a comparison chart
+                st.subheader("Score Comparison")
+                
+                # Reshape data for grouped bar chart
+                chart_data = pd.melt(
+                    filtered_data,
+                    id_vars=['timestamp', 'filename'],
+                    value_vars=['ats_score', 'keyword_match', 'format_score'],
+                    var_name='Score Type',
+                    value_name='Score'
+                )
+                
+                # Create a grouped bar chart
+                fig, ax = plt.subplots(figsize=(12, 8))
+                sns.barplot(
+                    x='Score Type', 
+                    y='Score', 
+                    hue='timestamp', 
+                    data=chart_data,
+                    palette='viridis'
+                )
+                
+                # Customize the chart
+                ax.set_title('Resume Score Comparison')
+                ax.set_ylim(0, 100)
+                ax.set_xlabel('Score Category')
+                ax.set_ylabel('Score')
+                ax.legend(title='Version')
+                
+                # Display the chart
+                st.pyplot(fig)
+                
+                # Display a table with detailed comparison
+                st.subheader("Detailed Comparison")
+                comparison_table = filtered_data[['timestamp', 'filename', 'job_role', 'ats_score', 'keyword_match', 'format_score']]
+                comparison_table.columns = ['Timestamp', 'Filename', 'Job Role', 'ATS Score', 'Keyword Match', 'Format Score']
+                st.dataframe(comparison_table, use_container_width=True)

src/utils.py

@@ -0,0 +1,96 @@
+import os
+import re
+import pickle
+from datetime import datetime
+import pandas as pd
+
+def save_analysis_to_history(analysis_results, resume_data, job_role):
+    """Save the current analysis results to history
+    
+    Args:
+        analysis_results (dict): The analysis results from the Groq API
+        resume_data (dict): The resume data including filename and text
+        job_role (str): The target job role
+        
+    Returns:
+        dict: The history entry that was created
+    """
+    # Create a history entry
+    history_entry = {
+        "filename": resume_data["filename"],
+        "job_role": job_role,
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "ats_score": analysis_results["ats_score"],
+        "keyword_match": analysis_results["keyword_match"],
+        "format_score": analysis_results["format_score"],
+        "readability_score": analysis_results["readability_score"]
+    }
+    
+    return history_entry
+
+def format_timestamp(timestamp_str):
+    """Format a timestamp string for display
+    
+    Args:
+        timestamp_str (str): Timestamp string in format '%Y-%m-%d %H:%M:%S'
+        
+    Returns:
+        str: Formatted timestamp for display
+    """
+    try:
+        dt = datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S")
+        return dt.strftime("%b %d, %Y at %I:%M %p")
+    except:
+        return timestamp_str
+
+def get_score_color(score):
+    """Get a color based on a score value
+    
+    Args:
+        score (int): Score value (0-100)
+        
+    Returns:
+        str: Hex color code
+    """
+    if score >= 80:
+        return "#4CAF50"  # Green
+    elif score >= 60:
+        return "#FFC107"  # Yellow/Amber
+    else:
+        return "#F44336"  # Red
+
+def clean_text(text):
+    """Clean and normalize text for analysis
+    
+    Args:
+        text (str): Raw text
+        
+    Returns:
+        str: Cleaned text
+    """
+    # Remove extra whitespace
+    text = re.sub(r'\s+', ' ', text).strip()
+    
+    # Remove special characters that might interfere with analysis
+    text = re.sub(r'[^\w\s.,;:!?\-\(\)]', ' ', text)
+    
+    return text
+
+def export_analysis_to_csv(history_data, filename="resume_analysis_history.csv"):
+    """Export analysis history to a CSV file
+    
+    Args:
+        history_data (list): List of history entries
+        filename (str): Output filename
+        
+    Returns:
+        str: Path to the saved file
+    """
+    # Convert to DataFrame
+    df = pd.DataFrame(history_data)
+    
+    # Save to CSV
+    output_path = os.path.join(os.getcwd(), filename)
+    df.to_csv(output_path, index=False)
+    
+    return output_path