Upload app.py

app.py

@@ -0,0 +1,229 @@
+import streamlit as st
+from tkinter import Tk, filedialog
+from PyQt5.QtWidgets import QApplication, QFileDialog
+import torch
+import torch.nn.functional as F
+from transformers import AutoTokenizer, AutoModel
+import google.generativeai as genai
+import os
+import io
+import base64
+import json
+import pandas as pd
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+
+
+def mean_pooling(model_output, attention_mask):
+    token_embeddings = model_output[0]  # First element of model_output contains all token embeddings
+    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+
+
+genai.configure(api_key="AIzaSyAV72r2GKD7C4p4rKpClXgeQS_e4dpHojM")
+def ats_extractor(file_path):
+    """
+    Extracts structured information from resumes using Gemini Vision Pro.
+    Args:
+        file_path (str): Path to the resume file (PDF).
+    Returns:
+        dict: Parsed resume information in JSON format.
+    """
+
+    # Read the raw bytes of the PDF file
+    with open(file_path, 'rb') as pdf_file:
+        resume_data = pdf_file.read()
+
+    # Prompt for Vision Pro
+    prompt = '''
+    You are an AI bot specializing in resume parsing. Extract the following details:
+    1. Full Name
+    2. Email ID
+    3. GitHub Portfolio
+    4. LinkedIn ID
+    5. Phone Number
+    6. Address
+    7. Education Details
+    8. Employment Details
+    9. Experiece Details
+    10. Technical Skills
+    11. Soft Skills
+    Provide the output in JSON format.
+    '''
+
+    # Prepare document for Vision API
+    pdf_content = {
+        "mime_type": "application/pdf",  # Set mime_type to application/pdf
+        "data": base64.b64encode(resume_data).decode() # Encode resume data to base64
+    }
+
+    # Initialize the model
+    model = genai.GenerativeModel('gemini-1.5-flash')
+
+    # Send the file and prompt to Vision Pro using generate_content
+    response = model.generate_content([pdf_content, prompt])
+
+    # Parse the response (assuming the response structure)
+    parsed_data = response.text #  Get the text from the response object
+
+    return parsed_data
+
+
+# Load model directly
+from transformers import AutoTokenizer, AutoModel
+
+tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+model = AutoModel.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+
+
+st.title('Resume Scoring')
+
+# Set a title for the app
+st.header("Job Description")
+
+# Add a text input box
+user_input = st.text_input("Enter your job description:")
+
+
+if st.button("Submit"):
+    source_sentence = str(user_input)
+    folder_path = 'E:/fyp progress/Resume'
+    resumes = []
+    # Check if the folder exists
+    if os.path.exists(folder_path):
+        print(f"Accessing folder: {folder_path}")
+
+        # Step 3: Loop through files in the folder
+        for file_name in os.listdir(folder_path):
+            file_path = os.path.join(folder_path, file_name)
+
+            # Check if it's a file
+            if os.path.isfile(file_path):
+                resumes.append(file_path)
+                
+    for i in resumes:
+        parsed_data = ats_extractor(i)
+
+        start_index = parsed_data.find('{')
+        end_index = parsed_data.rfind('}') + 1 # Find the last occurrence of } and add 1 to include it
+        json_part = parsed_data[start_index:end_index] # Slice the string to include only the JSON object
+        json_data = json.loads(json_part)
+        #Address
+        location = json_data['Address']
+
+        #Name
+        name = json_data['Full Name']
+
+        #Email
+        email = json_data['Email ID']
+
+        #Skills
+        skills = json_data['Technical Skills'] + json_data['Soft Skills']
+        skills = ', '.join(skills)
+
+
+        #Education
+
+        education = []
+        for i in range(len(json_data['Education Details'])):
+            # Use get with default value to handle None and ensure all items are strings
+            education.append(str(json_data['Education Details'][i].get('Degree', '')))
+            education.append(str(json_data['Education Details'][i].get('University', '')))
+            education.append(str(json_data['Education Details'][i].get('Dates', '')))
+        education = ', '.join(education)
+
+        #Expereince
+        #Expereince
+        data_experience = []
+        # Check if 'Experience Details' key exists, otherwise use 'Experiece Details'
+        experience_key = 'Experience Details' if 'Experience Details' in json_data else 'Experiece Details'  
+        
+        # Corrected key name and added a check for its existence
+        experience = json_data.get(experience_key, []) + json_data['Employment Details'] 
+        for i in range(len(experience)):
+            data_experience.append(str(experience[i].get('title', ''))) # Use get with default value to handle None
+            data_experience.append(str(experience[i].get('description', ''))) # Use get with default value to handle None
+            data_experience.append(str(experience[i].get('years', ''))) # Use get with default value to handle None
+
+        data_experience = ', '.join(data_experience)
+
+
+        experience_rate = [source_sentence] + [str(experience)] # Convert experience to string
+        skill_rate = [source_sentence] + [str(skills)] # Convert skills to string
+        education_rate = [source_sentence] + [str(education)] # Convert education to string
+        loc_rate = [source_sentence] + [str(location)] # Convert location to string
+
+        encoded_exp = tokenizer(experience_rate, padding=True, truncation=True, return_tensors='pt')
+        encoded_skill = tokenizer(skill_rate, padding=True, truncation=True, return_tensors='pt')
+        encoded_edu = tokenizer(education_rate, padding=True, truncation=True, return_tensors='pt')
+        encoded_loc = tokenizer(loc_rate, padding=True, truncation=True, return_tensors='pt')
+
+        # Compute token embeddings
+        with torch.no_grad():
+            exp_output = model(**encoded_exp)
+            skill_output = model(**encoded_skill)
+            edu_output = model(**encoded_edu)
+            loc_output = model(**encoded_loc)
+
+
+        #Perform Pooling
+        exp_embeddings = mean_pooling(exp_output, encoded_exp['attention_mask'])
+        skill_embeddings = mean_pooling(skill_output, encoded_skill['attention_mask'])
+        edu_embeddings = mean_pooling(edu_output, encoded_edu['attention_mask'])
+        loc_embeddings = mean_pooling(loc_output, encoded_loc['attention_mask'])
+
+        # Normalize embeddings
+        exp_embeddings = F.normalize(exp_embeddings, p=2, dim=1)
+        skill_embeddings = F.normalize(skill_embeddings, p=2, dim=1)
+        edu_embeddings = F.normalize(edu_embeddings, p=2, dim=1)
+        loc_embeddings = F.normalize(loc_embeddings, p=2, dim=1)
+
+        source_embedding = exp_embeddings[0]
+
+        comparison_exp = exp_embeddings[1:]
+        comparison_skill = skill_embeddings[1:]
+        comparison_edu = edu_embeddings[1:]
+        comparison_loc = loc_embeddings[1:]
+
+        cosine_similarities_exp = F.cosine_similarity(source_embedding.unsqueeze(0), comparison_exp)
+        cosine_similarities_skill = F.cosine_similarity(source_embedding.unsqueeze(0), comparison_skill)
+        cosine_similarities_edu = F.cosine_similarity(source_embedding.unsqueeze(0), comparison_edu)
+        cosine_similarities_loc = F.cosine_similarity(source_embedding.unsqueeze(0), comparison_loc)
+
+        final_score = 0.1*cosine_similarities_loc + 0.3*cosine_similarities_skill + 0.4*cosine_similarities_edu + 0.2*cosine_similarities_exp
+        if final_score>0.30:
+            st.write(name)
+            st.write(final_score)
+            # Email sender and receiver details
+            sender_email = "interviewerai@aafaaqamir.com"
+            receiver_email = email
+            password = 'Haseeb69@98'  # Replace with your App Password
+            subject = "Interview Selection"
+            body = f"congratulations {name}! You have been selected for the interview"
+
+            # Set up the MIME
+            message = MIMEMultipart()
+            message["From"] = sender_email
+            message["To"] = receiver_email
+            message["Subject"] = subject
+            message.attach(MIMEText(body, "plain"))
+
+            # Connect to the server and send the email
+            try:
+                # Use Hostinger SMTP server and port
+                server = smtplib.SMTP("smtp.hostinger.com", 587)  # Use 465 for SSL
+                server.set_debuglevel(1)  # Enable debug output
+                server.starttls()  # Start TLS encryption (omit for port 465)
+                server.login(sender_email, password)
+                server.sendmail(sender_email, receiver_email, message.as_string())
+                print("Email sent successfully!")
+            except Exception as e:
+                print(f"Error: {e}")
+            finally:
+                if 'server' in locals() and server:
+                    server.quit()
+
+
+