Upload app.py

app.py

@@ -0,0 +1,179 @@
+import streamlit as st
+import os
+import re
+from groq import Groq
+import json
+
+# Set up Groq client
+client = Groq(api_key="")
+
+# Define main function
+def main():
+    st.title("AI-powered Resume Scanner")
+
+    # File upload
+    uploaded_file = st.file_uploader("Upload a resume", type=["pdf", "docx"])
+
+    # Job role input
+    job_role = st.text_input("Enter the job role")
+
+    if uploaded_file is not None and job_role:
+        # Process resume and get results
+        resume_text = parse_resume(uploaded_file)
+        if resume_text:
+            #st.write("Extracted Resume Text:")
+            #st.write(resume_text)
+
+            # Get resume analysis from the Groq model
+            name, degree, cgpa, skills, experience_score, ats_score = analyze_resume(resume_text, job_role)
+
+            # Display the results
+            st.write(f"**Candidate Name:** {name}")
+            st.write(f"**Degree:** {degree}")
+            st.write(f"**Latest CGPA/Percentage:** {cgpa}")
+            if skills:
+                st.write("**Skills:**")
+                for skill in skills:
+                    st.write(f"- {skill}")
+            st.write(f"**Experience Score out of 10:** {experience_score}")
+            st.write(f"**ATS Score for {job_role} out of 10:** {ats_score}")
+
+# Function to parse PDF/Word file
+def parse_resume(uploaded_file):
+    # If PDF
+    if uploaded_file.type == "application/pdf":
+        from PyPDF2 import PdfReader
+        reader = PdfReader(uploaded_file)
+        text = ""
+        for page in reader.pages:
+            text += page.extract_text()
+        return text
+    # If Word
+    elif uploaded_file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+        from docx import Document
+        doc = Document(uploaded_file)
+        text = "\n".join([para.text for para in doc.paragraphs])
+        return text
+    else:
+        st.error("Unsupported file type!")
+        return None
+
+# Function to analyze resume using Groq API and LLaMA 3.1
+# Function to analyze resume using Groq API and LLaMA 3.1
+import json
+
+# Function to analyze resume using Groq API and LLaMA 3.1
+def analyze_resume(text, job_role):
+    # Construct prompt for Groq API
+    prompt = (
+        f"Extract the following details from the given resume text: \n"
+        f"1. Candidate's Name \n"
+        f"2. Latest Education CGPA or Percentage \n"
+        f"3. List of Skills \n"
+        f"4. Rate experience (projects, internships) on a scale from 0 to 10 \n"
+        f"5. Provide an ATS score for the job role: {job_role}\n"
+        f"Resume Text: {text}\n"
+        f"Format your response in a JSON object with the following structure: \n"
+        f"{{\n"
+        f'  "name": "Candidate Name",\n'
+        f'  "Degree": "Latest Education qualification or grade:",\n'
+        f'  "cgpa": "Latest Education CGPA or Percentage",\n'
+        f'  "skills": ["List of skills"],\n'
+        f'  "experience_score": "Experience Score (0 to 10)",\n'
+        f'  "ats_score": "ATS Score for the job role"\n'
+        f"}}"
+    )
+
+    # Call Groq API for chat completion
+    chat_completion = client.chat.completions.create(
+        messages=[{"role": "user", "content": prompt}],
+        model="llama3-8b-8192",
+        temperature=0.7,
+        max_tokens=1024,
+        top_p=1,
+        stream=False
+    )
+
+    # Get the raw output from the LLM
+    output = chat_completion.choices[0].message.content
+    # Clean up the output to avoid any parsing issues
+    cleaned_output = re.search(r'{[^}]*}', output).group()
+    # Try parsing the cleaned JSON
+    try:
+        response_data = json.loads(cleaned_output)
+    except json.JSONDecodeError:
+        st.error("Failed to parse response from model.")
+        st.write("Model Output:")
+        st.write(cleaned_output)
+        return None, None, None, None, None
+
+    # Extract information from the parsed JSON
+    name = response_data.get("name", "Name not found")
+    degree = response_data.get("Degree", "Degree not found")
+    cgpa = response_data.get("cgpa", "CGPA/Percentage not found")
+    skills = response_data.get("skills", "Skills not found")
+    experience_score = response_data.get("experience_score", "Experience score not found")
+    ats_score = response_data.get("ats_score", "ATS score not found")
+
+    return name, degree, cgpa, skills, experience_score, ats_score
+
+
+
+# Function to extract the candidate's name
+def extract_name(text):
+    name_pattern = re.compile(r"(Name:?\s*)([A-Z][a-z]+(?:\s[A-Z][a-z]+)*)")
+    match = name_pattern.search(text)
+    if match:
+        return match.group(2)
+    return "Name not found"
+
+# Function to extract CGPA or Percentage
+def extract_cgpa(text):
+    cgpa_pattern = re.compile(r"(\bCGPA\b|\bGPA\b|\bPercentage\b):?\s*(\d+\.?\d*)")
+    match = cgpa_pattern.search(text)
+    if match:
+        return match.group(2)
+    return "CGPA/Percentage not found"
+
+# Function to extract skills
+def extract_skills(text):
+    skills_pattern = re.compile(r"Skills:?\s*(.*?)(?:Experience|Education|$)", re.DOTALL)
+    match = skills_pattern.search(text)
+    if match:
+        skills = match.group(1)
+        return [skill.strip() for skill in skills.split(",")]
+    return "Skills not found"
+
+# Function to extract experience score
+def extract_experience_score(text):
+    experience_pattern = re.compile(r"Experience Score:?\s*(\d{1,2})")
+    match = experience_pattern.search(text)
+    if match:
+        return int(match.group(1))
+    # Heuristic: If no explicit experience score is given, infer it based on keywords
+    experience_keywords = ["internship", "project", "work experience", "employment"]
+    experience_count = sum(text.lower().count(keyword) for keyword in experience_keywords)
+    return min(10, experience_count)  # Cap at 10
+
+# Function to extract ATS score
+def extract_ats_score(text):
+    ats_pattern = re.compile(r"ATS Score:?\s*(\d+\.?\d*)")
+    match = ats_pattern.search(text)
+    if match:
+        return float(match.group(1))
+    # Heuristic to generate a score based on skill-job match
+    return generate_ats_score(text)
+
+# Heuristic function to generate ATS score
+def generate_ats_score(text):
+    # Just a dummy heuristic for now
+    skills = extract_skills(text)
+    if not skills:
+        return 0
+
+    required_skills = ["Python", "Machine Learning", "Data Analysis"]  # Add job role specific required skills
+    match_count = sum(1 for skill in required_skills if skill.lower() in [s.lower() for s in skills])
+    return round((match_count / len(required_skills)) * 10, 2)
+
+if __name__ == "__main__":
+    main()