Finished the initial concept of the project

app/streamlit_app.py

@@ -0,0 +1,134 @@
+import streamlit as st
+import sys
+import os
+import tempfile
+import uuid
+# Add the src directory to the Python path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'src')))
+from src.resume_analyzer import optimize_resume
+from src.pdf_handler import read_pdf
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+from io import BytesIO
+
+st.set_page_config(page_title="Resume Optimizer", layout="wide")
+
+# Create a directory to store uploaded files
+UPLOAD_DIR = os.path.join(os.path.dirname(__file__), '..', 'data', 'sample_resumes')
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+def create_pdf(text):
+    buffer = BytesIO()
+    c = canvas.Canvas(buffer, pagesize=letter)
+    width, height = letter
+    y = height - 50  # Start near the top of the page
+    for line in text.split('\n'):
+        if y < 50:  # If we're near the bottom of the page
+            c.showPage()  # Start a new page
+            y = height - 50  # Reset y to the top of the new page
+        c.drawString(50, y, line)
+        y -= 15  # Move down for the next line
+    c.save()
+    buffer.seek(0)
+    return buffer
+
+def save_uploaded_file(uploaded_file):
+    """Save the uploaded file and return the file path."""
+    try:
+        file_path = os.path.join(UPLOAD_DIR, uploaded_file.name)
+        with open(file_path, 'wb') as f:
+            f.write(uploaded_file.getvalue())
+        # file_extension = os.path.splitext(uploaded_file.name)[1]
+        # file_name = f"{uuid.uuid4()}{file_extension}"
+        # file_path = os.path.join(UPLOAD_DIR, file_name)
+        # with open(file_path, "wb") as f:
+        #     f.write(uploaded_file.getvalue())
+        return file_path
+    except Exception as e:
+        st.error(f"An error occurred while saving the file: {str(e)}")
+        return None
+
+def main():
+    st.title("Resume Optimizer")
+
+    # File upload and manual entry option
+    upload_option = st.radio("Choose how to input your resume:", ("Upload PDF", "Enter manually"))
+
+    resume_content = None
+    if upload_option == "Upload PDF":
+        resume_file = st.file_uploader("Upload your resume (PDF)", type="pdf")
+        if resume_file is not None:
+            file_path = save_uploaded_file(resume_file)
+            if file_path:
+                resume_content = read_pdf(file_path)
+                if resume_content.startswith("An error occurred"):
+                    st.error(resume_content)
+                    resume_content = None
+                else:
+                    st.success("PDF successfully read!")
+                    st.text_area("Extracted Content", resume_content, height=200)
+                # Clean up: remove the file after reading
+                os.remove(file_path)
+    else:
+        resume_content = st.text_area("Enter your resume text", height=300)
+
+    job_description = st.text_area("Enter the job description")
+
+    # Always display buttons
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        optimize_button = st.button("Optimize Resume")
+    
+    with col2:
+        download_pdf_button = st.button("Download Optimized Resume (PDF)")
+    
+    with col3:
+        download_txt_button = st.button("Download Optimized Resume (TXT)")
+
+    # Initialize session state for storing results
+    if 'analysis_dict' not in st.session_state:
+        st.session_state.analysis_dict = None
+    if 'updated_resume' not in st.session_state:
+        st.session_state.updated_resume = None
+
+    if optimize_button and resume_content and job_description:
+        with st.spinner("Analyzing and optimizing your resume..."):
+            st.session_state.analysis_dict, st.session_state.updated_resume = optimize_resume(resume_content, job_description)
+        
+        if st.session_state.analysis_dict and st.session_state.updated_resume:
+            st.success("Analysis complete!")
+            # Display analysis results
+            for key, value in st.session_state.analysis_dict.items():
+                st.subheader(key.replace('_', ' ').title())
+                if isinstance(value, list):
+                    for item in value:
+                        st.write(f"- {item}")
+                else:
+                    st.write(value)
+            
+            # Display updated resume
+            st.subheader("Updated Resume")
+            st.text_area("", value=st.session_state.updated_resume, height=300)
+        else:
+            st.error("An error occurred during analysis. Please try again.")
+
+    if download_pdf_button and st.session_state.updated_resume:
+        pdf_buffer = create_pdf(st.session_state.updated_resume)
+        st.download_button(
+            label="Download Optimized Resume (PDF)",
+            data=pdf_buffer,
+            file_name="optimized_resume.pdf",
+            mime="application/pdf"
+        )
+
+    if download_txt_button and st.session_state.updated_resume:
+        st.download_button(
+            label="Download Optimized Resume (TXT)",
+            data=st.session_state.updated_resume,
+            file_name="optimized_resume.txt",
+            mime="text/plain"
+        )
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -1,3 +1,5 @@
-anthropic==0.3.0
+anthropic==0.34.2
 pypdf==5.0.0
--e .
+streamlit
+reportlab
+# -e .

sample_pdf_reader.py

@@ -0,0 +1,73 @@
+import streamlit as st
+import pdfplumber
+import os
+
+# Define the folder path to save uploaded files
+UPLOAD_FOLDER = 'uploads'
+
+def read_pdf(file_path):
+    with pdfplumber.open(file_path) as pdf:
+        text = ''
+        for page in pdf.pages:
+            text += page.extract_text()
+    return text
+
+def main():
+    st.title("PDF Text Extractor")
+    st.markdown("Upload a PDF file to extract its text.")
+
+    # Create upload folder if it doesn't exist
+    if not os.path.exists(UPLOAD_FOLDER):
+        os.makedirs(UPLOAD_FOLDER)
+
+    # Create file uploader
+    uploaded_file = st.file_uploader("Choose a PDF file", type="pdf")
+
+    if uploaded_file:
+        # Save uploaded file to the upload folder
+        file_path = os.path.join(UPLOAD_FOLDER, uploaded_file.name)
+        with open(file_path, 'wb') as f:
+            f.write(uploaded_file.getvalue())
+
+        # Read PDF text
+        text = read_pdf(file_path)
+
+        # Display PDF text
+        st.write("Extracted Text:")
+        st.markdown(text)
+
+        # Optional: Delete the uploaded file after processing
+        # os.remove(file_path)
+
+if __name__ == "__main__":
+    main()
+
+
+# import streamlit as st
+# import pdfplumber
+# import io
+
+# def read_pdf(file_buffer):
+#     with pdfplumber.open(io.BytesIO(file_buffer)) as pdf:
+#         text = ''
+#         for page in pdf.pages:
+#             text += page.extract_text()
+#     return text
+
+# def main():
+#     st.title("PDF Text Extractor")
+#     st.markdown("Upload a PDF file to extract its text.")
+
+#     # Create file uploader
+#     uploaded_file = st.file_uploader("Choose a PDF file", type="pdf")
+
+#     if uploaded_file:
+#         # Read PDF text
+#         text = read_pdf(uploaded_file.getvalue())
+
+#         # Display PDF text
+#         st.write("Extracted Text:")
+#         st.markdown(text)
+
+# if __name__ == "__main__":
+#     main()

src/api_client.py

@@ -0,0 +1,17 @@
+import anthropic
+from config import ANTHROPIC_API_KEY
+
+client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+
+def call_claude_api(prompt):
+    response = client.messages.create(
+        model='claude-3-5-sonnet-20240620',
+        max_tokens=3000,
+        temperature=0,
+        system="You are a resume optimization expert. Optimize the attached resume to achieve an ATS score of 85% or higher for the target job description. Provide a revised resume, predicted ATS score, and suggestions for improvement.",
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+
+    return response.content

src/config.py

@@ -0,0 +1,3 @@
+import os
+
+ANTHROPIC_API_KEY = os.getenv('ANTHROPIC_API_KEY')

src/main.py

@@ -0,0 +1,10 @@
+from resume_analyzer import optimize_resume
+from pdf_handler import read_pdf
+from config import ANTHROPIC_API_KEY
+import pathlib
+from pathlib import Path
+
+# Read resume
+resume_file_path = pathlib.Path(__file__).parent.parent / 'data' / 'sample_resumes' / 'Anirudh_Nuti_DA.pdf'
+
+print(pathlib.Path(__file__).parent.parent / 'data' / 'sample_resumes')

src/pdf_handler.py

@@ -0,0 +1,17 @@
+import os
+import io
+import pdfplumber
+from pypdf import PdfReader
+
+def read_pdf(file_path):
+    with pdfplumber.open(file_path) as pdf:
+        text = ''
+        for page in pdf.pages:
+            text += page.extract_text()
+    return text
+
+    # with pdfplumber.open(io.BytesIO(file_buffer)) as pdf:
+    #     text = ''
+    #     for page in pdf.pages:
+    #         text += page.extract_text()
+    # return text

src/resume_analyzer.py

@@ -0,0 +1,39 @@
+from api_client import call_claude_api
+from text_processing import text_processing
+import json
+
+def optimize_resume(resume_content, job_description):
+    prompt = f"""
+    I'm actively applying for jobs and want to optimize my resume for Applicant Tracking Systems (ATS) to increase my chances of getting interviews. My goal is to achieve an ATS score of 85% or higher. Please help me with the following:
+
+    1. Analyze my current resume and the target job description provided below.
+    2. Identify any areas where keywords, skills, or formatting could be improved to better align with the job requirements and ATS algorithms.
+    3. Revise my resume based on your analysis. Incorporate relevant keywords, highlight key accomplishments with strong action verbs, and ensure the formatting is ATS-friendly.
+    4. Offer additional suggestions for optimizing my resume content or layout, if applicable.
+    5. Provide a predicted ATS score for the job description and the updated resume.
+    6. Identify any projects in the resume that may not be relevant to this specific job application.
+    7. Provide an updated version of the resume. Start the updated resume section with this heading 'Here's an updated version of your resume, optimized for the given job description:'
+
+    Please present your analysis and suggestions in a structured Python dictionary format, similar to the following:
+
+    resume_analysis = {{
+        "ats_score": 0,
+        "keyword_suggestions": [],
+        "formatting_suggestions": [],
+        "content_improvements": [],
+        "irrelevant_projects": []
+    }}
+
+    Current Resume: {resume_content}
+    Job Description: {job_description}
+    """
+
+    response = call_claude_api(prompt)
+    response = response[0].text
+    # print(response)
+
+    # Extract the dictionary and updated resume
+    try:
+        return text_processing(response)
+    except:
+        return None, None

src/text_processing.py

@@ -0,0 +1,22 @@
+import re
+import ast
+
+def text_processing(text):
+    # Regular expressions to extract resume_analysis and the updated resume
+    resume_analysis_pattern = re.compile(r'resume_analysis\s*=\s*({.*?})', re.DOTALL)
+    updated_resume_pattern = re.compile(r"Here's an updated version of your resume, optimized for the given job description:\n\n(.*)", re.DOTALL)
+
+    # print(resume_analysis_pattern)
+
+    # Extract resume_analysis
+    resume_analysis_match = resume_analysis_pattern.search(text)
+    resume_analysis = resume_analysis_match.group(1) if resume_analysis_match else None
+
+    # Extract updated resume
+    updated_resume_match = updated_resume_pattern.search(text)
+    updated_resume = updated_resume_match.group(1) if updated_resume_match else None
+
+    # Convert the resume_analysis string to a Python dictionary
+    resume_analysis = ast.literal_eval(resume_analysis) if resume_analysis else None
+
+    return resume_analysis, updated_resume