Upload 11 files

README.md

@@ -1,8 +1,8 @@
 ---
-title: Anushka
+title: ResumeBuilder
 emoji: 🌖
-colorFrom: gray
-colorTo: yellow
+colorFrom: blue
+colorTo: indigo
 sdk: streamlit
 sdk_version: 1.40.0
 app_file: app.py

app.py

@@ -0,0 +1,460 @@
+# -*- coding: utf-8 -*-
+import streamlit as st
+import os
+import pandas as pd
+import matplotlib.pyplot as plt
+from resume_generation_gemini_pro import generate_gemini
+from similarity_score_refined import similarity_main
+from pdf2image import convert_from_path, convert_from_bytes
+from docx import Document
+import subprocess
+import shutil
+import io
+from io import BytesIO
+import tempfile
+from PIL import Image, ImageDraw, ImageFont
+import PyPDF2
+from docx2pdf import convert
+import pdfplumber
+import docx
+import numpy as np
+import pypandoc
+import streamlit.components.v1 as components
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+
+# Create temporary directories
+temp_dir = tempfile.mkdtemp()
+
+# Custom CSS for styling
+st.markdown("""
+    <style>
+        .main {
+            background-color: #f5f5f5;
+            font-family: Arial, sans-serif;
+        }
+        h1, h2 {
+            color: #4B7BE5;
+            text-align: center;
+        }
+        .stContainer {
+            # background-color: #000000;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            # max-width: 100%;
+            height: 30%;
+            width: 45%;
+        }
+        .logo-container {
+            # background-color: black;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            padding: 10px;
+            # max-width: 100%;
+            
+        }
+        .logo-container img {
+            max-width: 60%;
+            height: 40%;
+        }
+        .stButton>button {
+            # background-color: #4B7BE5;
+            # color: white;
+            # font-size: 18px;
+            appearance: none;
+            background-color: transparent;
+            border: 0.125em solid #1A1A1A;
+            border-radius: 0.9375em;
+            box-sizing: border-box;
+            color: #3B3B3B;
+            cursor: pointer;
+            display: inline-block;
+            font-family: Roobert,-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol";
+            font-size: 16px;
+            font-weight: 600;
+            line-height: normal;
+            margin: 0;
+            min-height: 3.75em;
+            min-width: 0;
+            outline: none;
+            padding: 1em 2.3em;
+            text-align: center;
+            text-decoration: none;
+            transition: all 300ms cubic-bezier(.23, 1, 0.32, 1);
+            user-select: none;
+            -webkit-user-select: none;
+            touch-action: manipulation;
+            will-change: transform;
+        }
+        .stButton>button:hover {
+            color: #fff;
+            background-color: #1A1A1A;
+            box-shadow: rgba(0, 0, 0, 0.25) 0 8px 15px;
+            transform: translateY(-2px);
+            border: none !important;            
+            
+        }
+        /* From Uiverse.io by e-coders */ 
+             
+        # .stButton>btn:disabled {
+        #  pointer-events: none;
+        # }
+        
+        .stButton>:active, focus {
+         box-shadow: none;
+         transform: translateY(0);
+         color: #fff;
+         border: none !important;  
+         outline: none;
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+# Add ResumeMagic Logo
+# st.markdown('<div class="logo-container"></div>', unsafe_allow_html=True)
+# st.image("template_image.png", width=80)
+# st.markdown('</div>', unsafe_allow_html=True)
+st.image("template_image.png", use_container_width =True)
+
+# Title and Description
+st.title("Resume Tailoring with Google Generative AI")
+st.markdown("### Upload your resume and job description to check similarity and generate a tailored resume.")
+
+
+# Helper function to save uploaded files temporarily and return their paths
+def save_uploaded_file(content):
+    if hasattr(content, 'name'):  
+        file_path = os.path.join("/tmp", content.name)
+        with open(file_path, "wb") as f:
+            f.write(content.read())
+    else: 
+        file_path = os.path.join("/tmp", "temp_upload")
+        with open(file_path, "w") as f:
+            f.write(str(content))
+    return file_path
+    
+# def save_uploaded_file(uploaded_file):
+#     file_path = os.path.join("/tmp", uploaded_file.name)
+#     with open(file_path, "wb") as f:
+#         f.write(uploaded_file.getbuffer())
+#     return file_path
+
+
+# Two columns for file uploaders
+col1, col2 = st.columns(2)
+with col1:
+    uploaded_resume = st.file_uploader("Upload Current Resume (.docx or .pdf)", type=["docx", "pdf"], key="resume")
+with col2:
+    uploaded_job_description = st.file_uploader("Upload Job Description (.docx or .pdf)", type=["docx", "pdf"], key="job_description")
+
+def get_score(resume_path, job_description_path):
+    similarity_score = similarity_main(resume_path, job_description_path)
+    if isinstance(similarity_score, str) and '%' in similarity_score:
+        similarity_score = float(similarity_score.replace('%', ''))
+        
+        # Display messages based on score range
+        if similarity_score < 50:
+            st.markdown('<p style="color: red; font-weight: bold;">Low chance, skills gap identified!</p>', unsafe_allow_html=True)
+            pie_colors = ['#FF4B4B', '#E5E5E5']  
+        elif 50 <= similarity_score < 70:
+            st.markdown('<p style="color: red; font-weight: bold;">Good chance but you can improve further!</p>', unsafe_allow_html=True)
+            pie_colors = ['#FFC107', '#E5E5E5']  
+        else:
+            st.markdown('<p style="color: green; font-weight: bold;">Excellent! You can submit your CV.</p>', unsafe_allow_html=True)
+            pie_colors = ['#4CAF50', '#E5E5E5']  
+    
+    return similarity_score, pie_colors
+
+def display_score(similarity, colors):
+    # Display Score as a Pie Chart
+    st.markdown(f"### Resume - Job Match: {int(similarity_score)}%")
+    
+    # Pie chart to show similarity
+    fig, ax = plt.subplots()
+    # ax.pie([similarity_score, 100 - similarity_score], labels=['Match', 'Difference'], autopct='%1.1f%%', startangle=140, colors=['#4B7BE5', '#E5E5E5'])
+    ax.pie([similarity_score, 100 - similarity_score], labels=['Match', 'Difference'], autopct='%1.1f%%', startangle=140, colors=pie_colors)
+        
+    ax.axis('equal')  
+    st.pyplot(fig)
+
+    
+def display_docx_content(file):
+    doc = docx.Document(file)
+    full_text = []
+    for para in doc.paragraphs:
+        full_text.append(para.text)
+    return '\n'.join(full_text)
+    
+
+# Function to save a file from BytesIO to a temporary file
+def save_bytes_to_tempfile(bytes_data, suffix):
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+        temp_file.write(bytes_data)
+        return temp_file.name
+        
+def save_bytes_as_pdf(docx_bytes, output_path='output.pdf'):
+    # Create a temporary directory
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        # Write the DOCX bytes to a temporary file
+        temp_file = os.path.join(tmp_dir, 'temp.docx')
+        with open(temp_file, 'wb') as f:
+            f.write(docx_bytes)
+        
+        # Convert the temporary DOCX to PDF
+        pdf_path = os.path.join(tmp_dir, 'output.pdf')
+        convert(temp_file, pdf_path)
+        
+        # Copy the PDF to the desired output location
+        with open(output_path, 'wb') as f:
+            with open(pdf_path, 'rb') as src_f:
+                f.write(src_f.read())
+
+    # Clean up the temporary directory
+    os.remove(output_path)
+
+
+def display_content_with_page_numbers(content, words_per_page=290):
+    # Split content into words
+    words = content.split()
+    total_pages = (len(words) // words_per_page) + (1 if len(words) % words_per_page != 0 else 0)
+
+    # Display content with page numbers
+    for i in range(total_pages):
+        start_index = i * words_per_page
+        end_index = start_index + words_per_page
+        page_content = ' '.join(words[start_index:end_index])
+        
+        # st.markdown(f"#### Page {i + 1}")
+        # st.write(page_content)
+    st.markdown(f"#### Page {total_pages}")
+    
+def save_docx_as_pdf(input_path, output_path='output.pdf'):
+    if input_path.lower().endswith('.docx'):
+        try:
+            # Convert .docx to .pdf using LibreOffice
+            subprocess.run(['libreoffice', '--headless', '--convert-to', 'pdf', input_path, '--outdir', os.path.dirname(output_path)], check=True)
+            if not os.path.exists(output_path):
+                raise FileNotFoundError("Conversion failed; output PDF not found.")
+        except (FileNotFoundError, subprocess.CalledProcessError):
+            st.error("Failed to convert DOCX to PDF. Please check LibreOffice installation.")
+    elif input_path.lower().endswith('.pdf'):
+        shutil.copy(input_path, output_path)
+    else:
+        raise ValueError("Unsupported file format. Please upload a .docx or .pdf file.")
+
+
+def display_pdf_page(pdf_path):
+    try:
+        # Open PDF file
+        with open(pdf_path, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+        
+        # Extract text from the first page
+        page = reader.pages[0]
+        x_object = page.extract_text()
+    
+        # Convert text to image (using PIL)
+        img = Image.new('RGB', (800, 1000))
+        draw = ImageDraw.Draw(img)
+        font = ImageFont.truetype("arial.ttf", 20)
+    
+        # Draw text on the image
+        draw.text((10, 10), x_object[:500], fill=(255, 255, 255), font=font)
+    
+        # Display the image
+        display(img)
+    except Exception as e:
+        st.error(f"Failed to display image: {str(e)}")
+
+# def display_pdf_pages_as_images(pdf_path):
+#     try:
+#         with pdfplumber.open(pdf_path) as pdf:
+#             for i, page in enumerate(pdf.pages):
+#                 st.markdown(f"#### Page {i + 1}")
+#                 # Convert the page to an image
+#                 image = page.to_image()
+#                 # Render the image using Streamlit
+#                 # st.image(image.original, use_column_width=True)
+#                 st.image(image.original, use_container_width=False)
+#     except Exception as e:
+#         st.error(f"Failed to display PDF as image: {str(e)}")
+
+def display_pdf_pages_as_images(pdf_path):
+    try:
+        with pdfplumber.open(pdf_path) as pdf:
+            num_pages = len(pdf.pages)
+            # Create a container with columns for each page
+            columns = st.columns(num_pages)
+
+            for i, page in enumerate(pdf.pages):
+                # Convert the page to an image
+                image = page.to_image()
+                # Display each page image in its respective column
+                with columns[i]:
+                    st.markdown(f"#### Page {i + 1}")
+                    st.image(image.original, use_container_width=True)
+                    
+    except Exception as e:
+        st.error(f"Failed to display PDF as image: {str(e)}")
+
+    
+def display_doc_as_image2(pdf_path):   
+    iframe_code = f"""
+    <iframe src="{pdf_path}" width="100%" height="600px"></iframe>
+    """
+    st.markdown(iframe_code, unsafe_allow_html=True)
+    
+def add_bold_and_normal_text(paragraph, text):
+    """Adds text to the paragraph, handling bold formatting."""
+    while "**" in text:
+        before, bold_part, after = text.partition("**")
+        if before:
+            paragraph.add_run(before)
+        if bold_part == "**":
+            bold_text, _, text = after.partition("**")
+            paragraph.add_run(bold_text).bold = True
+        else:
+            text = after
+    if text:
+        paragraph.add_run(text)
+ 
+# Process if files are uploaded
+if uploaded_resume and uploaded_job_description:
+    # Save files
+    resume_path = save_uploaded_file(uploaded_resume)
+    job_description_path = save_uploaded_file(uploaded_job_description)
+
+    # Similarity Score Section
+    st.markdown("---")
+    # st.subheader("Check Job Match")
+
+    if st.button("Resume-JD Matching"):
+        with st.spinner("Computing Match"):
+            similarity_score, pie_colors = get_score(resume_path, job_description_path)
+            display_score(similarity_score, pie_colors)
+ 
+        #Autoscroll
+        components.html("""
+                <script>
+                    window.onload = function() {
+                        window.scrollTo(0, document.body.scrollHeight);
+                    };
+                </script>
+            """)
+
+    # Generate Tailored Resume Section
+    st.markdown("---")
+    # st.subheader("Tailor Resume")
+    
+    if st.button("Tailor Resume"):
+        with st.spinner("Generating resume..."):
+            generated_resume, new_resume_path = generate_gemini(resume_path, job_description_path)
+            # resume_path = save_uploaded_file(generated_resume)
+            # st.markdown("Generated Tailored Resume:")
+            # st.write(generated_resume)
+
+            #Autoscroll
+            components.html("""
+                <script>
+                    window.onload = function() {
+                        window.scrollTo(0, document.body.scrollHeight);
+                    };
+                </script>
+            """)
+
+            
+            # with st.spinner("Computing Match"):
+            #     similarity_score, pie_colors = get_score(resume_path, job_description_path)
+            #     display_score(similarity_score, pie_colors)
+                
+            if generated_resume is not None:
+                # st.markdown("---")
+                st.title("Uploaded Resume")
+                doc = Document()
+        
+        # Split the text into lines for processing
+                lines = generated_resume.splitlines()
+
+                for line in lines:
+                  if line.startswith("# "):  # Top-level heading (Highest level)
+                    paragraph = doc.add_heading(line[2:].strip(), level=0)  # Level 0 is the highest heading in Word
+                    paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY  
+                  elif line.startswith("## "):  # Main heading (Level 1)
+                    paragraph = doc.add_heading(line[3:].strip(), level=1)
+                    paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+                  elif line.startswith("### "):  # Subheading (Level 2)
+                    paragraph = doc.add_heading(line[4:].strip(), level=2)
+                    paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+                  elif line.startswith("- "):  # Bullet points
+                    paragraph = doc.add_paragraph(style="List Bullet")
+                    add_bold_and_normal_text(paragraph, line[2:].strip())
+                    paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+                  elif line.startswith("* "):  # Sub-bullet points or normal list items
+                    paragraph = doc.add_paragraph(style="List Bullet 2")
+                    add_bold_and_normal_text(paragraph, line[2:].strip())
+                    paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+                  elif line.strip():  # Normal text (ignores blank lines)
+                    paragraph = doc.add_paragraph()
+                    add_bold_and_normal_text(paragraph, line.strip())
+                    paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY  
+                
+                # Save the generated document as a .docx file in memory
+                resume_bytes = BytesIO()
+                doc.save(resume_bytes)
+                resume_bytes.seek(0)
+                
+                # Save the .docx to a temporary file
+                gen_docx_path = save_bytes_to_tempfile(resume_bytes.getvalue(), 'docx')
+        
+                # Convert the generated .docx to a .pdf
+                gen_pdf_path = save_uploaded_file(gen_docx_path)
+                # st.write(display_docx_content(gen_pdf_path))
+
+                
+                # st.markdown("### Uploaded Resume")
+                save_docx_as_pdf(resume_path, '/tmp/uploaded_resume.pdf')
+                display_pdf_pages_as_images(resume_path)
+               
+                st.success(f"Download tailored resume")
+                st.download_button(
+                    label="Generated Resume (Word)",
+                    data=resume_bytes,
+                    file_name="tailored_resume.docx",
+                    mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                )                            
+
+
+                # Display uploaded and generated resumes side-by-side
+                # col1, col2 = st.columns(2)
+                # with col1:
+                #     st.markdown("### Uploaded Resume")
+                #     save_docx_as_pdf(resume_path, '/tmp/uploaded_resume.pdf')
+                #     display_pdf_pages_as_images(resume_path)
+                # with col2:
+                #     st.markdown("### Tailored Resume")
+                #     # display_pdf_pages_as_images(gen_pdf_path)
+                #     display_content_with_page_numbers(generated_resume, 290)
+                #     st.write(generated_resume)
+                #     # display_content_with_page_numbers(generated_resume, 290)
+                    
+                #     st.success(f"Download tailored resume")
+                #     col1, col2 = st.columns(2)
+                #     with col1:
+                #         st.download_button(
+                #             label="Generated Resume (PDF)",
+                #             data=open(gen_pdf_path, 'rb').read(),
+                #             file_name="tailored_resume.pdf",
+                #             mime="application/pdf"
+                #             )
+                #     with col2:
+                #         st.download_button(
+                #             label="Generated Resume (Word)",
+                #             data=resume_bytes,
+                #             file_name="tailored_resume.docx",
+                #             mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                #         )                            
+                
+                
+else:
+    st.warning("Please upload both the resume and job description files.")

apt.txt

@@ -0,0 +1,5 @@
+poppler-utils=0.90.0
+poppler
+unoconv 
+libreoffice
+pandoc

firm-capsule-436804-b5-5f553d9f1043.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "firm-capsule-436804-b5",
+
+  
+  "client_email": "[email protected]",
+
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/genai-328%40firm-capsule-436804-b5.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

requirements.txt

@@ -0,0 +1,19 @@
+streamlit
+PyPDF2
+pdfplumber
+pypandoc
+langchain_community
+langchain_google_genai
+python-docx
+docx2txt
+faiss-gpu
+google-generativeai
+sentence_transformers
+Transformers
+openai==0.28.0
+nltk
+matplotlib
+IPython
+pdf2image 
+docx2pdf
+Pillow

resume_class.py

@@ -0,0 +1,36 @@
+
+
+# Load the RAG model
+rag_model = RagTokenForGeneration.from_pretrained("rag_model")
+
+job_description_text = """
+We are looking for a Senior Data Scientist with 7+ years of experience in machine learning, deep learning, and advanced statistical modeling. The candidate should have a strong background in Python, TensorFlow, and PyTorch. Experience with cloud platforms like AWS or GCP is mandatory. Responsibilities include leading data science teams, designing predictive models, and optimizing business strategies through data insights. A PhD in Computer Science, Statistics, or a related field is highly preferred.
+"""
+
+resume_text = """
+Hardworking construction worker with 2 years of experience in residential building projects. Skilled in operating heavy machinery, reading blueprints, and ensuring site safety. Proficient in the use of tools like drills, saws, and hammers. Strong knowledge of safety regulations and experience collaborating with contractors and architects. Dedicated to delivering quality results and meeting project deadlines.
+"""
+
+query = resume_text + " " + job_description_text + 
+f"Provide a score between 0 and 100% for the resume against the job description and explain your reasoning. Summarize the classification whether the candidate is a perfect fit, a good fit, a potential fit, or no fit"
+
+tokenizer = RagTokenizer.from_pretrained("facebook/rag-sequence-base", trust_remote_code=True)
+
+def test_new_data(query, model, tokenizer):
+    inputs = tokenizer(query, return_tensors="pt", padding=True, truncation=True)
+    with torch.no_grad():
+        outputs = model(
+            input_ids=inputs["input_ids"],
+            attention_mask=inputs["attention_mask"]
+        )
+        logits = outputs.logits
+        preds = torch.argmax(logits, axis=1)
+    return preds.item()
+
+predicted_label = test_new_data(query, model, tokenizer)
+print(f"Predicted Label: {predicted_label}")
+
+response = model.generate(inputs_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"])
+print(f"Jof Fitness: {response}")
+
+

resume_generation_gemini_pro.py

@@ -0,0 +1,235 @@
+# -*- coding: utf-8 -*-
+"""Resume_generation_Gemini_pro.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/16z793IRwVmvKYCaOLGZFDYj-XOj8zEJL
+"""
+
+# from google.colab import drive,userdata
+
+# drive.mount('/content/drive')
+
+# !pip install streamlit -qq
+
+# !pip install PyPDF2 -qq
+
+# !pip install langchain_community -qq
+
+# !pip install langchain_google_genai -qq
+
+# !pip install python-docx -qq
+
+# !pip install docx2txt -qq
+
+# !pip install faiss-gpu -qq
+
+# !pip install google-generativeai -qq
+
+# !pip install --upgrade google-generativeai -qq
+
+import docx2txt
+import PyPDF2
+
+def extract_text(file_path):
+    if file_path.endswith(".docx"):
+        # Extract text from DOCX file
+        return docx2txt.process(file_path)
+
+    elif file_path.endswith(".pdf"):
+        # Extract text from PDF file
+        text = ""
+        with open(file_path, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            for page_num in range(len(reader.pages)):
+                text += reader.pages[page_num].extract_text()
+        return text
+
+    else:
+        raise ValueError("Unsupported file type")
+
+# from google.colab import auth
+# auth.authenticate_user()
+
+import os
+
+GOOGLE_APPLICATION_CREDENTIALS = os.environ["GOOGLE_APPLICATION_CREDENTIALS"]
+private_key_id = os.environ.get('PRIVATE_KEY_ID')
+private_key = os.environ.get('PRIVATE_KEY')
+client_id = os.environ.get('CLIENT_ID')
+
+# !pip install python-docx
+
+import os
+import streamlit as st
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores.faiss import FAISS
+# from google.colab import drive
+from docx import Document
+import google.generativeai as genai
+from datetime import datetime
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+
+api_key_google = os.environ.get('GOOGLE_GEMINI_KEY')
+genai.configure(api_key=api_key_google)
+
+# Mount Google Drive
+# drive.mount('/content/drive')
+
+model = genai.GenerativeModel('gemini-pro')
+
+def save_resume_to_docx(tailored_resume, file_path):
+    doc = Document()
+    doc.add_heading('Tailored Resume', level=1)
+    doc.add_paragraph(tailored_resume)
+    doc.save(file_path)
+
+# Function to read text from a .docx file
+def read_docx(file_path):
+    doc = Document(file_path)
+    return "\n".join([para.text for para in doc.paragraphs])
+
+# def generate_resume_text(resume_text):
+#     prompt = f"""
+# Given the following resume content:
+
+# [Resume Start]
+# {resume_text}
+# [Resume End]
+
+# Format this resume content with appropriate section titles. Only use the information provided and avoid placeholders like "[Your Name]". Ensure it retains the structure and details exactly as shown.
+# """
+#     try:
+#         response = model.generate_content(prompt)
+#         print(response)
+#         # Accessing the generated text content
+#         return response.candidates[0].content.parts[0].text
+#     except Exception as e:
+#         print("Error in generating resume text:", e)
+#         return None
+
+def tailor_resume(resume_text, job_description):
+    # Use the generate_resume_text function to get the formatted resume content
+    # formatted_resume = generate_resume_text(resume_text)
+    # print("formatted resume:",resume_text)
+        prompt = f"""
+Below is the candidate's original  resume content:
+[Resume Start]
+{resume_text}
+[Resume End]
+Using the candidate's resume above and the job description below, create a tailored resume.
+[Job Description Start]
+{job_description}
+[Job Description End]
+
+
+Please generate a resume that:
+1. Uses real data from the candidate's resume, including name, and education.
+2. Avoids placeholders like "[Your Name]" and includes actual details. This is important.
+3. In the experience section, emphasizes professional experiences and skills that are directly relevant to the job description.
+4. Keeps only a maximum of the top three accomplishments/ responsibilities for each job position held so as to make the candidate standout in the new job role
+5. Removes special characters from the section titles.
+6. Only includes publications if the job description is research based.
+7. Summarizes the skills and technical skills section into a brief profile.
+8. Does not include courses, certification, references, skills and a technical skills sections if they are not relevant.
+9. Only includes true information about the candidate.
+10.Provide the text in markdown format that clearly identifies the headings and subheadings.
+"""
+
+
+        try:
+            response = model.generate_content(prompt)
+            print(response.candidates[0].content.parts[0].text)
+            return response.candidates[0].content.parts[0].text
+        except Exception as e:
+            print("Error in tailoring resume:", e)
+            return None
+
+def add_bold_and_normal_text(paragraph, text):
+    """Adds text to the paragraph, handling bold formatting."""
+    while "**" in text:
+        before, bold_part, after = text.partition("**")
+        if before:
+            paragraph.add_run(before)
+        if bold_part == "**":
+            bold_text, _, text = after.partition("**")
+            paragraph.add_run(bold_text).bold = True
+        else:
+            text = after
+    if text:
+        paragraph.add_run(text)
+        
+def convert_resume_to_word(markdown_text,output_file):
+    # Create a new Word document
+    doc = Document()
+
+    # Split the text into lines for processing
+    lines = markdown_text.splitlines()
+
+    for line in lines:
+        if line.startswith("## "):  # Main heading (Level 1)
+            paragraph = doc.add_heading(line[3:].strip(), level=1)
+            paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+        elif line.startswith("### "):  # Subheading (Level 2)
+            paragraph = doc.add_heading(line[4:].strip(), level=2)
+            paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+        elif line.startswith("- "):  # Bullet points
+            paragraph = doc.add_paragraph()
+            add_bold_and_normal_text(paragraph, line[2:].strip())
+            paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+        elif line.startswith("* "):  # Sub-bullet points or normal list items
+            paragraph = doc.add_paragraph(style="List Bullet")
+            add_bold_and_normal_text(paragraph, line[2:].strip())
+            paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+        elif line.strip():  # Normal text (ignores blank lines)
+            paragraph = doc.add_paragraph()
+            add_bold_and_normal_text(paragraph, line.strip())
+            paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
+
+    # Save the Word document
+
+    doc.save(output_file)
+    print(f"Markdown converted and saved as {output_file}")
+
+#Entry function for the model
+def generate_gemini(current_resume,job_description):
+    st.header('Resume Tailoring')
+
+    # Load the resume and job description from Google Drive
+    resume_text = extract_text(current_resume)
+    job_description = extract_text(job_description)
+
+    # Tailor resume based on job description
+    tailored_resume = tailor_resume(resume_text, job_description)
+    output_file = f"Tailored_Resume_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
+    convert_resume_to_word(tailored_resume,output_file)
+
+    st.success(f"Tailored resume saved to {output_file}")
+
+    return tailored_resume, output_file        
+
+
+# Main function for Streamlit app
+# def Gemini_pro_main(current_resume,job_description):
+#     st.header('Resume Tailoring')
+
+#     # Load the resume and job description from Google Drive
+#     resume_text = extract_text(current_resume)
+#     job_description = extract_text(job_description)
+
+#     # Tailor resume based on job description
+#     tailored_resume = tailor_resume(resume_text, job_description)
+#     st.write("**Tailored Resume:**")
+#     st.write(tailored_resume)
+#     print(tailored_resume)
+
+#         # Save the tailored resume to a .docx file
+#     if tailored_resume:
+#         file_path = f"Tailored_Resume_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
+#         save_resume_to_docx(tailored_resume, file_path)
+#         st.success(f"Tailored resume saved to {file_path}")
+
+# if __name__ == '__main__':
+#     main()
+

setup.sh

@@ -0,0 +1 @@
+apt-get update && apt-get install -y poppler-utils

similarity_score_refined.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""Similarity_score_refined (2).ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1c8mlCBnLbduLsI8rUGFEOYDuyBqdz2JJ
+"""
+
+# !pip install sentence_transformers
+# !pip install openai==0.28
+# !pip install docx2txt PyPDF2 transformers
+
+# from google.colab import drive,userdata
+# drive.mount("/content/drive")
+# print("Google Drive mounted.")
+
+import re
+from sklearn.feature_extraction.text import TfidfVectorizer
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+import os
+
+# Ensure you have downloaded stopwords and wordnet
+import nltk
+nltk.download('stopwords')
+nltk.download('wordnet')
+
+def extract_text(file_path):
+    import docx2txt
+    import PyPDF2
+    if file_path.endswith(".docx"):
+        # Extract text from DOCX file
+        return docx2txt.process(file_path)
+
+    elif file_path.endswith(".pdf"):
+        # Extract text from PDF file
+        text = ""
+        with open(file_path, 'rb') as file:
+            reader = PyPDF2.PdfReader(file)
+            for page_num in range(len(reader.pages)):
+                text += reader.pages[page_num].extract_text()
+        return text
+
+    else:
+        raise ValueError("Unsupported file type")
+
+def preprocess(text):
+    # Lowercase the text
+    text = text.lower()
+
+    # Remove special characters and numbers
+    text = re.sub(r'[^a-z\s]', '', text)
+
+    # Tokenize the text by splitting on whitespace
+    words = text.split()
+
+    # Remove stop words
+    stop_words = set(stopwords.words('english'))
+    words = [word for word in words if word not in stop_words]
+
+    # Lemmatize the words (to get root form)
+    lemmatizer = WordNetLemmatizer()
+    words = [lemmatizer.lemmatize(word) for word in words]
+
+    # Join words back into a single string
+    return ' '.join(words)
+
+def calculate_tfidf(doc):
+    vectorizer = TfidfVectorizer()
+    tfidf_matrix = vectorizer.fit_transform([doc])  # Only fit on the individual document
+    feature_names = vectorizer.get_feature_names_out()
+    dense_tfidf_matrix = tfidf_matrix.todense()
+
+    # Extract important terms from the document with a threshold
+    important_terms = [feature_names[i] for i in range(len(feature_names)) if dense_tfidf_matrix[0, i] > 0.2]
+
+    return ' '.join(important_terms)
+
+def call_chatgpt_api(prompt, api_key,model="gpt-3.5-turbo"):
+    import openai
+    openai.api_key = api_key
+    response = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ],
+        max_tokens=500,
+        temperature= 0,
+        top_p=1,
+        frequency_penalty= 0,
+        presence_penalty= 0
+    )
+    return response['choices'][0]['message']['content'].strip()
+
+def calculate_similarity(resume, job_desc, model_name="sentence-transformers/all-MiniLM-L6-v2"):
+    from sentence_transformers import SentenceTransformer, util
+    model = SentenceTransformer(model_name)
+
+    # Convert texts to embeddings
+    embeddings1 = model.encode(resume, convert_to_tensor=True)
+    embeddings2 = model.encode(job_desc, convert_to_tensor=True)
+
+    # Calculate cosine similarity
+    similarity_score = util.pytorch_cos_sim(embeddings1, embeddings2)
+    return similarity_score.item()  # return as a scalar
+
+def similarity_main(resume_path,job_description_path):
+
+    # Extract text from files (replace with actual file paths)
+    Resume_text = extract_text(resume_path)
+    job_des = extract_text(job_description_path)
+    api_key=os.environ.get('OPENAI_KEY')
+
+
+    prompt=f"Extract the skills or competencies section from the resume. Avoid using name of the candidate:\n\n{Resume_text}"
+    resume_skills = call_chatgpt_api(prompt,api_key)
+    experience_prompt = f"Extract the experience of the candidate from the resume. Avoid using name of the candidate:\n\n{Resume_text}"
+    resume_experience = call_chatgpt_api(experience_prompt,api_key)
+
+    # Extract sections from job description (JD)
+    jd_skills_prompt = f"Extract the skills section from the job description:\n\n{job_des}"
+    jd_skills = call_chatgpt_api(jd_skills_prompt,api_key)
+
+    jd_experience_prompt = f"Extract the experience section from the job description:\n\n{job_des}"
+    jd_experience = call_chatgpt_api(jd_experience_prompt,api_key)
+
+    resume_skills_clean = preprocess(resume_skills)
+    jd_skills_clean = preprocess(jd_skills)
+
+    resume_experience_clean = preprocess(resume_experience)
+    jd_experience_clean = preprocess(jd_experience)
+
+    filtered_resume = calculate_tfidf(resume_skills_clean)
+    filtered_jd = calculate_tfidf(jd_skills_clean)
+    similarity_skills=calculate_similarity(filtered_resume,filtered_jd)
+
+    filtered_resume_ex = calculate_tfidf(resume_experience_clean)
+    filtered_jd_ex = calculate_tfidf(jd_experience_clean)
+    similarity_ex=calculate_similarity(filtered_resume_ex,filtered_jd_ex)
+
+    Average_Score=(similarity_skills+similarity_ex)/2
+    percentage= f"{Average_Score * 100:.2f}%"
+    return percentage
+