Update app.py

app.py

@@ -1,136 +1,153 @@
+import re
 import json
+import os
 import pandas as pd
-import gradio as gr
 import google.generativeai as genai
-import openai
-from PyPDF2 import PdfReader
-
-# Function to extract text from the uploaded PDF resume
-def input_pdf_text(resume_file):
-    with open(resume_file, "rb") as file_stream:
-        reader = PdfReader(file_stream)
+import PyPDF2 as pdf
+from dotenv import load_dotenv
+import io
+
+# Load environment variables from a .env file
+load_dotenv()
+
+# Get API Key from environment variable
+api_key = os.getenv('GOOGLE_API_KEY')
+if not api_key:
+    raise ValueError("API key not found. Please set GOOGLE_API_KEY in your environment variables.")
+
+genai.configure(api_key=api_key)
+
+# Function to get response from the Gemini model
+def get_gemini_response(input_text):
+    model = genai.GenerativeModel('gemini-1.5-flash')
+    response = model.generate_content(input_text)
+    return response.text
+
+# Function to extract text from uploaded PDF
+def input_pdf_text(uploaded_file_path):
+    with open(uploaded_file_path, 'rb') as file:
+        reader = pdf.PdfReader(file)
         text = ""
         for page in reader.pages:
             text += page.extract_text()
     return text
 
-# Function to extract contact details (name, email, and contact number) from the resume text
+# Function to extract name, email, and contact from the resume text
 def extract_contact_info(resume_text):
-    # Here we simulate the extraction. You can add regex or NLP models for more accurate extraction.
-    name = "Monisha Jegadeesan"
-    email = "Bmonishaj.65@gmail.com"
-    contact = "+91 9035212894"
+    name_match = re.search(r"^(?P<name>[A-Za-z\s]+)$", resume_text, re.MULTILINE)
+    name = name_match.group('name') if name_match else "Not Available"
+    email_match = re.search(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", resume_text)
+    email = email_match.group(0) if email_match else "Not Available"
+    contact_match = re.search(r"\+?\d{1,2}\s?\(?\d{1,4}\)?\s?\d{10}", resume_text)
+    contact = contact_match.group(0) if contact_match else "Not Available"
     return name, email, contact
 
-# Prepare prompt format
+# Function to extract years of experience based on date mentions (for both direct and indirect experience)
+def extract_years_from_text(text, role):
+    # Define regex patterns to match different formats for date ranges or years
+    patterns = [
+        r"from (\d{4}) to (\d{4})",  # Matches: 'from 2019 to 2022'
+        r"for (\d+) years",           # Matches: 'for 3 years'
+        r"since (\d{4})",             # Matches: 'since 2018'
+        r"from (\d{4}) to present"    # Matches: 'from 2019 to present'
+    ]
+    
+    total_years = 0
+    
+    # Process each pattern to extract relevant years
+    for pattern in patterns:
+        matches = re.findall(pattern, text)
+        
+        for match in matches:
+            if len(match) == 2:  # Date range (e.g., "from 2019 to 2022")
+                start_year = int(match[0])
+                end_year = int(match[1])
+                total_years += end_year - start_year
+            elif len(match) == 1:  # Single year or years
+                years = int(match[0])
+                total_years += years
+    
+    # Apply different logic based on role: "Direct" or "Indirect"
+    if role.lower() == "direct":
+        return total_years  # Direct management years
+    else:
+        return total_years  # Indirect management years
+
+# Refined Prompt Template for Gemini API (requesting simple text)
 input_prompt = """
-You are an AI-powered assistant helping in resume screening for job roles.
-Based on the following resume text, compare it with the given job description and provide the following:
-1. JD_Match_Percentage: Percentage of match between JD and Resume.
-2. Missing_Keywords: List of keywords from the JD that are missing in the resume.
-3. Total_Experience_Years: Total years of experience mentioned in the resume.
-4. Direct_Management_Experience: Specific experience where the candidate had direct management responsibility.
-5. Indirect_Management_Experience: Specific experience where the candidate had indirect management responsibility.
-6. Mentoring_Guiding_Experience: Specific mentoring or guiding experience.
-7. Name: Full name of the candidate.
-8. Email: Candidate's email address.
-9. Contact: Candidate's contact number.
-10. Profile_Summary: Summary of the candidate's profile based on the resume text.
-
-Resume Text:
-{text}
-
-Job Description (JD):
-{jd}
+Act as a highly skilled Applicant Tracking System (ATS) with expertise in evaluating resumes for management and team leadership roles. Your task is to assess the resume against the provided job description, focusing on a detailed analysis.
+
+Instructions:
+1. **Direct Management/Team Leadership Experience**: Identify instances where the candidate has formal responsibility for managing a team, such as leading projects or directly managing team members.
+2. **Indirect Management/Team Leadership Experience**: Identify instances where the candidate provides guidance or mentorship, such as mentoring junior engineers or organizing team activities without direct management responsibility.
+3. **Match Percentage**: Calculate the match percentage by identifying and counting keywords and phrases relevant to management and team leadership from the job description. Include years of experience as a factor in the match.
+
+Provide a simple text output with the following information:
+- The candidate’s **Direct Management/Team Leadership Experience** in years.
+- The candidate’s **Indirect Management/Team Leadership Experience** in years.
+
+Input:
+- Resume Text: "{text}"
+- Job Description: "{jd}"
 """
 
-# Function to interact with Gemini API
-def get_gemini_response(prompt):
-    # Replace this with actual interaction with Gemini or OpenAI APIs
-    # Here we simulate a mock response, but you'll need actual API calls
-    response = {
-        "JD_Match_Percentage": 75,
-        "Missing_Keywords": [
-            "Team Lead", "Project Management", "Leadership", "Team Building",
-            "Decision Making", "Problem Solving", "Team Motivation"
-        ],
-        "Total_Experience_Years": 3.5,
-        "Direct_Management_Experience": [],
-        "Indirect_Management_Experience": [
-            "Guiding junior engineers on programming and software design tasks to enable timely delivery of products to customers.",
-            "Mentored sixteen pairs of students on research projects, with supervision through regular team-wise progress meetings."
-        ],
-        "Mentoring_Guiding_Experience": [
-            "Guiding junior engineers on programming and software design tasks to enable timely delivery of products to customers.",
-            "Mentored sixteen pairs of students on research projects, with supervision through regular team-wise progress meetings.",
-            "Guided by Prof. Yulia Tsvetkov", "Guided by Prof. Veni Madhavan"
-        ],
-        "Name": "Monisha Jegadeesan",
-        "Email": "Bmonishaj.65@gmail.com",
-        "Contact": "+91 9035212894",
-        "Profile_Summary": "Monisha Jegadeesan is a Software Engineer with 3.5 years of experience in Google. She has a strong background in Natural Language Processing, Machine Learning, and software development. She has experience guiding junior engineers and mentoring students on research projects. Monisha has a Master's degree in Computer Science and Engineering from the Indian Institute of Technology Madras."
-    }
-    # Simulating response as JSON string
-    return json.dumps(response)
-
-# Main processing function for resume
-def process_resume(job_desc, resume_file):
-    # Read the uploaded resume file
-    resume_text = input_pdf_text(resume_file)
-    
+# Manually specify the file path of the resume and the job description
+uploaded_file_path = input("Enter the file path of the resume PDF: ")
+jd = input("Paste the Job Description: ")
+
+if os.path.exists(uploaded_file_path):
+    # Extract text from the PDF resume
+    resume_text = input_pdf_text(uploaded_file_path)
+
     # Extract contact info (name, email, contact)
     name, email, contact = extract_contact_info(resume_text)
-    
+
+    # Extract years of experience based on date mentions
+    direct_management_years = extract_years_from_text(resume_text, role="direct")
+    indirect_management_years = extract_years_from_text(resume_text, role="indirect")
+
     # Prepare the prompt with resume and job description text
-    prompt = input_prompt.format(text=resume_text, jd=job_desc)
+    prompt = input_prompt.format(text=resume_text, jd=jd)
     
-    # Get the response from Gemini model (or API)
+    # Get the response from Gemini model
     response_text = get_gemini_response(prompt)
+    
+    # Log the raw response for inspection (cleaned up)
+    print("Raw model response (before cleaning):")
+    print(repr(response_text))  # Use repr to show invisible characters
 
-    # Print the response to inspect it
-    print("Model response:", response_text)
+    # Strip any leading/trailing whitespace or unwanted characters from the response
+    response_text_clean = response_text.strip()
 
-    # Strip any unwanted spaces or newline characters
-    response_text = response_text.strip()
+    # Log the cleaned response
+    print("\nCleaned model response (after stripping whitespace):")
+    print(repr(response_text_clean))  # Show cleaned response
 
+    # Now, process the plain text response
     try:
-        # Try parsing the response as JSON
-        response_data = json.loads(response_text)
-    except json.JSONDecodeError:
-        # If JSON decoding fails, print the raw response for debugging
-        print("Error: The model's response is not in JSON format.")
-        print("Raw response:", response_text)
-        return f"Error: The model's response is not in JSON format. Here is the response: {response_text}", None
-
-    # Add extracted contact info to the JSON response
-    response_data['Name'] = name
-    response_data['Email'] = email
-    response_data['Contact'] = contact
-
-    # Process and create DataFrame for CSV
-    df = pd.DataFrame([response_data])
-
-    # Save the results to CSV in memory
-    csv_filename = "ATS_Analysis_Results.csv"
-    df.to_csv(csv_filename, index=False)
-
-    # Return DataFrame and CSV file for download
-    return df.to_dict(orient="records")[0], csv_filename
-
-# Gradio interface setup
-def gradio_interface(job_desc, resume_file):
-    result, csv_file = process_resume(job_desc, resume_file)
-    return result, gr.File.update(value=csv_file, visible=True)
-
-# Define Gradio interface
-resume_file_input = gr.File(label="Upload Resume (PDF)", type="file")
-job_desc_input = gr.Textbox(label="Enter Job Description", placeholder="Paste job description here")
-
-# Gradio interface layout
-with gr.Blocks() as demo:
-    job_desc_input
-    resume_file_input
-    gr.Button("Process Resume").click(gradio_interface, inputs=[job_desc_input, resume_file_input], outputs=["json", "file"])
-
-# Launch the Gradio interface
-demo.launch()
+        # Create a DataFrame with the extracted data
+        data = {
+            'Name': [name],
+            'Email': [email],
+            'Contact': [contact],
+            'Direct_Management_Experience_Years': [direct_management_years],
+            'Indirect_Management_Experience_Years': [indirect_management_years],
+            'Model_Response': [response_text_clean]
+        }
+
+        df = pd.DataFrame(data)
+
+        # Display the DataFrame as a table
+        print("\nAnalysis Results Table:")
+        print(df)
+
+        # Save the DataFrame to a CSV file
+        csv_filename = "ATS_Analysis_Results.csv"
+        df.to_csv(csv_filename, index=False)
+        
+        print(f"Results saved to {csv_filename}")
+        
+    except Exception as e:
+        print(f"\nAn error occurred while processing the response: {str(e)}")
+else:
+    print("The file path provided does not exist. Please check the path and try again.")