added app for analysis

analysis.py

@@ -0,0 +1,24 @@
+def generate_analysis(jd_data,resume_data,pipe):
+    # jd_text = truncate_text(jd_data)  
+         
+    prompt = f"""
+        Analyze the following resume and job description. Provide a detailed analysis of the match, including strengths, weaknesses, and an overall fit score between 0 and 1.
+
+    Resume: {resume_data}
+
+    Job Description: {jd_data}
+
+    Provide your analysis in the following format:
+    Score: [score between 0 and 1 (for resemblance of resume with job description)]
+    Analysis: [Your detailed analysis in point-wise]
+    Weaknesses:[weaknesses of the resume according to Job Description in point-wise]
+    Strengths:[Strengths of the resume according to Job Description in point-wise]
+    Areas of non-Alignment: [Areas of Alignment where the candidate is missing according to job description in point-wise]
+    Areas of Alignment: [Areas of Alignment where the candidate is matching according to job description in point-wise]
+    
+    **PLEASE USE HEADINGS Score,Analysis,Weaknesses,Strengths,Areas of Alignment as it is**
+    """ 
+    response = pipe(prompt,max_new_tokens=5000, do_sample=True, temperature=0.7)
+
+    return response, prompt
+    # return prompt

app.py

@@ -1,166 +1,213 @@
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, BitsAndBytesConfig
-from json_repair import repair_json
-import torch
-from huggingface_hub import login
-import streamlit as st
-import os,json
-from dotenv import load_dotenv
-from functions import get_json
-from resume_prompt import analyze_resume
-from jd_prompt import analyze_jd
-from sq_and_query import generate_screening_question, generate_search_query
-import fitz
-import time
-
-load_dotenv()
-
-
-SECRET_KEY = os.getenv("SECRET_KEY")
-login(SECRET_KEY)
-
-
-model_name =os.getenv("MODEL")
-bnb_config = BitsAndBytesConfig(
-    load_in_4bit=True,  
-    bnb_4bit_compute_dtype=torch.float16,
-    bnb_4bit_use_double_quant=True
-)
-
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForCausalLM.from_pretrained(
-    model_name,
-    quantization_config=bnb_config, 
-    device_map="auto",
-)
-pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
-
-##Resume
-upload_resume = 'uploaded_resumes'
-
-if not os.path.exists(upload_resume):
-    os.mkdir(upload_resume)
-
-st.header("Upload Resume")
-
-uploaded_file = st.file_uploader("Choose a Resume", type=["pdf", "docx"])
-
-if uploaded_file is not None:
-    file_name = uploaded_file.name
-    saved_resume_path = os.path.join(upload_resume, file_name)
-
-    with open(saved_resume_path, "wb") as f:
-        f.write(uploaded_file.getbuffer())
-
-    st.success(f'Resume successfully uploaded to {saved_resume_path}')
-
-    resume_text=""
-    with fitz.open(saved_resume_path) as doc:
-        for page in doc:
-            resume_text += page.get_text()
-    start_time=time.time()
-    resume_result,resume_prompt = analyze_resume(resume_text,pipe)
-    resume_response_text = resume_result[0]["generated_text"]
-    resume_result_resume = resume_response_text.replace(resume_prompt, "", 1)
-
-    resume_json_str = get_json(resume_result_resume)  
-    resume_good_json_string = repair_json(resume_json_str)
-    resume_data=json.loads(resume_good_json_string)
-    st.success(f'time took {time.time()-start_time}')
-    
-    st.subheader("📄 Extracted Resume JSON")
-    st.json(resume_data)
-
-    
-    resume_json_download = json.dumps(resume_data, indent=4)
-    st.download_button(
-        label="Download Resume JSON",
-        data=resume_json_download,
-        file_name="resume_data.json",
-        mime="application/json"
-    )
-
-
-##Job Description
-upload_jd = 'uploaded_job_desc'
-
-if not os.path.exists(upload_resume):
-    os.mkdir(upload_resume)
-
-st.header("Upload Job Description")
-
-uploaded_file = st.file_uploader("Choose a Job Description to Upload", type=["pdf", "docx","txt"])
-
-if uploaded_file is not None:
-    file_name = uploaded_file.name
-    saved_jd_path = os.path.join(upload_resume, file_name)
-
-    with open(saved_jd_path, "wb") as f:
-        f.write(uploaded_file.getbuffer())
-
-    st.success(f'Job Description successfully uploaded to {saved_jd_path}')
-
-    jd_text=""
-    if saved_jd_path.endswith(".pdf") or saved_jd_path.endswith(".docx"):
-        with fitz.open(saved_jd_path) as doc:
-            for page in doc:
-                jd_text += page.get_text()
-    elif saved_jd_path.endswith(".txt"):
-        with open(saved_jd_path, "r", encoding="utf-8") as file:
-            jd_text = file.read()
-    start_time=time.time()
-    jd_result,jd_prompt = analyze_jd(jd_text,pipe)
-
-    jd_response_text = jd_result[0]["generated_text"]
-    jd_result_resume = jd_response_text.replace(jd_prompt, "", 1)
-    jd_json_str =get_json(jd_result_resume)  
-    jd_good_json_string = repair_json(jd_json_str)
-    jd_data=json.loads(jd_good_json_string)
-    st.success(f'time took {time.time()-start_time}')
-    st.subheader("📄 Extracted Job Description JSON")
-    st.json(jd_data)
-    
-    jd_json_download = json.dumps(jd_data, indent=4)
-    st.download_button(
-        label="Download Job Description JSON",
-        data=jd_json_download,
-        file_name="jd_data.json",
-        mime="application/json"
-    )
-
-    st.header("Screening Questions:")
-
-    start_time=time.time()
-    sq_result,sq_prompt =generate_screening_question(jd_data,pipe)
-    sq_response_text = sq_result[0]["generated_text"]
-    sq_result_resume = sq_response_text.replace(sq_prompt, "", 1)
-    sq_json_str =get_json(sq_result_resume)  
-    sq_good_json_string = repair_json(sq_json_str)
-    sq_data=json.loads(sq_good_json_string)
-    st.success(f'time took {time.time()-start_time}')
-    st.subheader("📄 Extracted Screening Question JSON")
-    st.json(sq_data)
-    st.download_button(
-        label="Download Screening Questions JSON",
-        data=json.dumps(sq_data),
-        file_name="screening_questions_data.json",
-        mime="application/json"
-    )
-    
-    st.header("Search Query:")
-    start_time=time.time()
-    search_q_result,search_q_prompt=generate_search_query(jd_text,jd_data['keywords'],pipe)
-    search_q_final_result=search_q_result[0]["generated_text"]
-    serach_q_text = search_q_final_result.replace(search_q_prompt, "", 1)
-    serach_q_json=get_json(serach_q_text)
-    serach_q_data=json.loads(repair_json(serach_q_json))
-    st.success(f'time took {time.time()-start_time}')
-    st.subheader("📄 Extracted Search Query JSON")
-    st.json(serach_q_data)
-    st.download_button(
-        label="Download Search Query JSON",
-        data=json.dumps(serach_q_data),
-        file_name="search_query_data.json",
-        mime="application/json"
-    )
-    
-    
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, BitsAndBytesConfig
+from json_repair import repair_json
+import torch
+from huggingface_hub import login
+import streamlit as st
+import os,json
+from dotenv import load_dotenv
+from functions import get_json
+from resume_prompt import analyze_resume
+from jd_prompt import analyze_jd
+from sq_and_query import generate_screening_question, generate_search_query
+from resume_with_job import generate_resume_with_job
+from analysis import generate_analysis
+from interview_questons import generate_interview_questions
+import fitz
+import time
+
+load_dotenv()
+
+
+SECRET_KEY = os.getenv("SECRET_KEY")
+login(SECRET_KEY)
+
+
+model_name =os.getenv("MODEL")
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,  
+    bnb_4bit_compute_dtype=torch.float16,
+    bnb_4bit_use_double_quant=True
+)
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    quantization_config=bnb_config, 
+    device_map="auto",
+)
+pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
+
+##Resume
+upload_resume = 'uploaded_resumes'
+
+if not os.path.exists(upload_resume):
+    os.mkdir(upload_resume)
+
+st.header("Upload Resume")
+
+uploaded_file_r = st.file_uploader("Choose a Resume", type=["pdf", "docx"])
+
+if uploaded_file_r is not None:
+    file_name = uploaded_file_r.name
+    saved_resume_path = os.path.join(upload_resume, file_name)
+
+    with open(saved_resume_path, "wb") as f:
+        f.write(uploaded_file_r.getbuffer())
+
+    st.success(f'Resume successfully uploaded to {saved_resume_path}')
+
+    resume_text=""
+    with fitz.open(saved_resume_path) as doc:
+        for page in doc:
+            resume_text += page.get_text()
+    start_time=time.time()
+    resume_result,resume_prompt = analyze_resume(resume_text,pipe)
+    resume_response_text = resume_result[0]["generated_text"]
+    resume_result_resume = resume_response_text.replace(resume_prompt, "", 1)
+
+    resume_json_str = get_json(resume_result_resume)  
+    resume_good_json_string = repair_json(resume_json_str)
+    resume_data=json.loads(resume_good_json_string)
+    st.success(f'time took {time.time()-start_time}')
+    
+    st.subheader("📄 Extracted Resume JSON")
+    st.json(resume_data)
+
+    
+    resume_json_download = json.dumps(resume_data, indent=4)
+    st.download_button(
+        label="Download Resume JSON",
+        data=resume_json_download,
+        file_name="resume_data.json",
+        mime="application/json"
+    )
+
+
+##Job Description
+upload_jd = 'uploaded_job_desc'
+
+if not os.path.exists(upload_resume):
+    os.mkdir(upload_resume)
+
+st.header("Upload Job Description")
+
+uploaded_file_jd = st.file_uploader("Choose a Job Description to Upload", type=["pdf", "docx","txt"])
+
+if uploaded_file_jd is not None:
+    file_name = uploaded_file_jd.name
+    saved_jd_path = os.path.join(upload_resume, file_name)
+
+    with open(saved_jd_path, "wb") as f:
+        f.write(uploaded_file_jd.getbuffer())
+
+    st.success(f'Job Description successfully uploaded to {saved_jd_path}')
+
+    jd_text=""
+    if saved_jd_path.endswith(".pdf") or saved_jd_path.endswith(".docx"):
+        with fitz.open(saved_jd_path) as doc:
+            for page in doc:
+                jd_text += page.get_text()
+    elif saved_jd_path.endswith(".txt"):
+        with open(saved_jd_path, "r", encoding="utf-8") as file:
+            jd_text = file.read()
+    start_time=time.time()
+    jd_result,jd_prompt = analyze_jd(jd_text,pipe)
+
+    jd_response_text = jd_result[0]["generated_text"]
+    jd_result_resume = jd_response_text.replace(jd_prompt, "", 1)
+    jd_json_str =get_json(jd_result_resume)  
+    jd_good_json_string = repair_json(jd_json_str)
+    jd_data=json.loads(jd_good_json_string)
+    st.success(f'time took {time.time()-start_time}')
+    st.subheader("📄 Extracted Job Description JSON")
+    st.json(jd_data)
+    
+    jd_json_download = json.dumps(jd_data, indent=4)
+    st.download_button(
+        label="Download Job Description JSON",
+        data=jd_json_download,
+        file_name="jd_data.json",
+        mime="application/json"
+    )
+
+    st.header("Screening Questions:")
+
+    start_time=time.time()
+    sq_result,sq_prompt =generate_screening_question(jd_data,pipe)
+    sq_response_text = sq_result[0]["generated_text"]
+    sq_result_resume = sq_response_text.replace(sq_prompt, "", 1)
+    sq_json_str =get_json(sq_result_resume)  
+    sq_good_json_string = repair_json(sq_json_str)
+    sq_data=json.loads(sq_good_json_string)
+    st.success(f'time took {time.time()-start_time}')
+    st.subheader("📄 Extracted Screening Question JSON")
+    st.json(sq_data)
+    st.download_button(
+        label="Download Screening Questions JSON",
+        data=json.dumps(sq_data),
+        file_name="screening_questions_data.json",
+        mime="application/json"
+    )
+    
+    st.header("Search Query:")
+    start_time=time.time()
+    search_q_result,search_q_prompt=generate_search_query(jd_text,jd_data['keywords'],pipe)
+    search_q_final_result=search_q_result[0]["generated_text"]
+    serach_q_text = search_q_final_result.replace(search_q_prompt, "", 1)
+    serach_q_json=get_json(serach_q_text)
+    serach_q_data=json.loads(repair_json(serach_q_json))
+    st.success(f'time took {time.time()-start_time}')
+    st.subheader("📄 Extracted Search Query JSON")
+    st.json(serach_q_data)
+    st.download_button(
+        label="Download Search Query JSON",
+        data=json.dumps(serach_q_data),
+        file_name="search_query_data.json",
+        mime="application/json"
+    )
+    
+    
+if uploaded_file_r is not None  and uploaded_file_jd is not None:
+    st.header("Resume With Job:")
+    start_time = time.time()
+    rwj_result,rwj_prompt=generate_resume_with_job(jd_data,resume_data,pipe)
+    rwj_final_result=rwj_result[0]["generated_text"]
+    rwj_text = rwj_final_result.replace(rwj_prompt, "", 1)
+    match=json.loads(repair_json(get_json(rwj_text)))
+    st.success(f'time took {time.time()-start_time}')
+    st.subheader("📄 Extracted Resume With Job JSON")
+    st.json(match)
+    st.download_button(
+        label="Download Resume With Job JSON",
+        data=json.dumps(match),
+        file_name="resume_with_job_data.json",
+        mime="application/json"
+    )
+
+
+    st.header("Analysis:")
+    start_time = time.time()
+    analysis_result,analysis_prompt = generate_analysis(jd_data,resume_data,pipe)
+    analysis_final_result=analysis_result[0]["generated_text"]
+    analysis_result_resume = analysis_final_result.replace(analysis_prompt, "", 1)
+    analysis_result_resume = analysis_result_resume.replace("-", "").strip()
+    st.success(f'time took {time.time()-start_time}')
+    st.subheader("📄 Extracted Resume With Job JSON")
+    st.text_area("Analysis Content", analysis_result_resume, height=250)
+
+
+    st.header("Interview Questions:")
+    start_time = time.time()
+    interview_que,interview_que_prompt=generate_interview_questions(jd_data,match,pipe)
+    interview_que_result=interview_que[0]["generated_text"]
+    interview_que_text=interview_que_result.replace(interview_que_prompt, "", 1)
+    interview_questions=json.loads(repair_json(get_json(interview_que_text)))
+    st.success(f'time took {time.time()-start_time}')
+    st.subheader("📄 Extracted Interview Questions JSON")
+    st.json(interview_questions)
+    st.download_button(
+        label="Download Interview Questions JSON",
+        data=json.dumps(interview_questions),
+        file_name="resume_with_job_data.json",
+        mime="application/json"
+    )

interview_questons.py

@@ -0,0 +1,76 @@
+def generate_interview_questions(job_data,match_result,pipe):
+    job_title = job_data.get('title', '')
+    primary_function = job_data.get('primary_job_function', '')
+    matching_skills = match_result.get('matching_skills', [])
+    missing_skills = match_result.get('missing_skills', [])
+    prompt = f"""
+        Generate structured interview questions for a {job_title} position, focusing on three main sections:
+
+        1. Missing Skills Assessment:
+        For each missing skill {missing_skills}, create:
+        - An initial question to check if they have worked with the skill
+        - A detailed follow-up question if they indicate experience
+        - Focus on practical experience and specific examples
+
+        2. Experience Validation:
+        Create questions to validate their claimed experience in:
+        {matching_skills}
+        - Focus on specific projects and implementations
+        - Ask about challenges and solutions
+        - Verify depth of expertise
+
+        3. Role-Specific Technical Deep Dive:
+        Create questions focused on {primary_function} that assess:
+        - Problem-solving approach
+        - Best practices understanding
+        - Technical decision-making
+        - Architecture and design thinking
+
+        Return the questions in this exact JSON format:
+        {{
+            "missing_skills_questions": [
+                {{
+                    "skill": "Name of missing skill",
+                    "screening_question": {{
+                        "question": "Have you worked with [skill]?",
+                        "look_for": ["Indicators of experience"],
+                        "red_flags": ["Warning signs"]
+                    }},
+                    "follow_up": {{
+                        "question": "Detailed follow-up question if they have experience",
+                        "purpose": "What to evaluate",
+                        "look_for": ["Expected positive points"],
+                        "red_flags": ["Warning signs"]
+                    }}
+                }}
+            ],
+            "experience_questions": [
+                {{
+                    "skill": "Specific skill or area",
+                    "question": "Detailed question about their experience",
+                    "purpose": "What this evaluates",
+                    "look_for": ["Expected positive points"],
+                    "red_flags": ["Warning signs"]
+                }}
+            ],
+            "technical_questions": [
+                {{
+                    "area": "Technical area being assessed",
+                    "question": "Technical or scenario-based question",
+                    "purpose": "What this evaluates",
+                    "look_for": ["Expected positive points"],
+                    "red_flags": ["Warning signs"]
+                }}
+            ]
+        }}
+
+        Ensure:
+        1. Questions are specific and practical
+        2. No repetition across sections
+        3. Clear evaluation criteria for each question
+        4. Natural flow from basic to complex topics
+        5. Ensure questions are specific to the candidate's profile and the role requirements.
+        """
+    response = pipe(prompt,max_new_tokens=5000, do_sample=True, temperature=0.7)
+    return response, prompt
+    

resume_with_job.py

@@ -0,0 +1,104 @@
+def generate_resume_with_job(jd_data,resume_data,pipe):
+    # jd_text = truncate_text(jd_data)  
+         
+    prompt = f"""
+        You are an expert ATS system analyzing the match between a resume and job description.
+        Provide a highly detailed technical analysis focusing on actual relevance, not just keyword matches.
+        Be critical and thorough in analyzing all aspects including experience, education, and job function.
+
+        Resume: {json.dumps(resume_data)}
+        Job Description: {json.dumps(jd_data)}
+
+        Evaluation Instructions:
+        1. Skills Analysis:
+           - Look for exact matches AND related/equivalent skills
+           - Consider depth of experience with each skill
+           - Distinguish between core skills and peripheral knowledge
+           - Weight technical skills based on their importance to the role
+
+        2. Experience Analysis (Most Critical):
+           - Evaluate actual relevance of past roles, not just years
+           - Analyze responsibilities and projects in detail
+           - Consider recency and depth of relevant experience
+           - Look for specific achievements and implementations
+           - Rate experience relevance on specific job requirements
+           - Consider domain/industry relevance
+           - Evaluate leadership and project scope alignment
+
+        3. Education Analysis (Must be detailed):
+           - Evaluate degree level match (Bachelors, Masters, PhD)
+           - Assess field relevance to role requirements
+           - Analyze coursework alignment with technical needs
+           - Evaluate certifications and professional qualifications
+           - Consider continuing education and training
+           - Assess academic achievements and specializations
+           - Compare institution reputation if relevant
+           - Identify any educational gaps or additional needs
+           - Consider impact of education on role performance
+
+        4. Job Function Analysis (Must be detailed):   
+           - Evaluate direct career path alignment with role
+           - Assess progression within the function
+           - Analyze depth of functional expertise
+           - Evaluate industry-specific functional knowledge
+           - Consider team and project management in function
+           - Assess cross-functional experience relevance
+           - Evaluate strategic and leadership capabilities
+           - Identify functional strengths and weaknesses
+           - Consider future growth potential in function
+
+        5. Technical Depth Analysis:
+           - Evaluate complexity of past projects
+           - Assess technical leadership experience
+           - Consider architecture and design experience
+           - Evaluate hands-on implementation experience
+
+        Provide your detailed analysis in this JSON format:
+        {{
+            "match_score": [score between 0 and 1, be strict and realistic],
+            "component_scores": {{
+                "skills": [score with detailed explanation],
+                "experience": [score with detailed relevance analysis],
+                "education": [score with comprehensive education analysis],
+                "job_function": [score with detailed function alignment analysis]
+            }},
+            "analysis": [comprehensive analysis of overall fit],
+            "matching_skills": [list with proficiency details],
+            "missing_skills": [list with impact analysis],
+            "experience_match": {{
+                "score": [score based on actual relevance],
+                "relevant_experience": [years of truly relevant experience],
+                "analysis": [detailed analysis of experience relevance],
+                "role_relevance": [specific analysis of each role's relevance]
+            }},
+            "education_match": {{
+                "score": [score based on requirements match],
+                "degree_match": [analysis of degree level and field relevance],
+                "certifications": [analysis of professional certifications],
+                "gaps": [specific educational gaps],
+                "strengths": [educational strengths],
+                "recommendations": [educational development suggestions]
+            }},
+            "job_function_match": {{
+                "score": [score based on function alignment],
+                "function_relevance": [analysis of functional experience],
+                "progression": [career progression analysis],
+                "expertise_level": [assessment of functional expertise],
+                "gaps": [functional gaps identified],
+                "strengths": [functional strengths],
+                "growth_potential": [potential in the function]
+            }},
+            "strengths": [specific strengths with concrete examples],
+            "weaknesses": [specific gaps with improvement suggestions],
+            "overall_fit": [comprehensive assessment of fit]
+        }}
+
+        BE VERY STRICT in scoring. A score of 1.0 should only be given for perfect matches.
+        Focus on ACTUAL RELEVANCE, not just superficial matches.
+        ENSURE detailed analysis is provided for both education and job function sections.
+        **return only json**
+        """
+    
+    response = pipe(prompt,max_new_tokens=5000, do_sample=True, temperature=0.7)
+    return response, prompt
+    # return prompt