main.py

from flask import Flask, request, render_template, redirect, url_for, session, send_from_directory
from PyPDF2 import PdfReader
from docx import Document
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from sentence_transformers import SentenceTransformer, util
import os
import pickle
import re
import numpy as np
from urllib.parse import unquote

app = Flask(__name__)
app.secret_key = 'thastabdyekd4i29821bjacuhi338yu9bacd98ebhc'
UPLOAD_FOLDER = 'uploads/'
CANDIDATE_STORAGE = 'candidate_details.pkl'
os.makedirs(UPLOAD_FOLDER, exist_ok=True)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

USER_CREDENTIALS = {
    "HR001": "123456",
    "HR002": "123456",
    "HR003": "123456"
}

def save_candidate_details(details):
    with open(CANDIDATE_STORAGE, 'wb') as f:
        pickle.dump(details, f)

def load_candidate_details():
    try:
        with open(CANDIDATE_STORAGE, 'rb') as f:
            return pickle.load(f)
    except (FileNotFoundError, EOFError):
        return {}

def extract_text_from_file(file_path):
    if file_path.endswith('.pdf'):
        return extract_text_from_pdf(file_path)
    elif file_path.endswith('.docx'):
        return extract_text_from_docx(file_path)
    else:
        raise ValueError("Unsupported file format")

def extract_text_from_pdf(pdf_path):
    text = ""
    reader = PdfReader(pdf_path)
    for page in reader.pages:
        extracted = page.extract_text()
        if extracted:
            text += extracted
    return text

def extract_text_from_docx(docx_path):
    doc = Document(docx_path)
    return "\n".join([p.text for p in doc.paragraphs if p.text.strip()])

def is_valid_resume(text):
    if not text or len(text.strip()) < 50:
        return False
    alphanumeric_count = sum(c.isalnum() for c in text)
    total_length = len(text)
    alphanumeric_ratio = alphanumeric_count / total_length if total_length > 0 else 0
    return alphanumeric_ratio > 0.3

model = SentenceTransformer("./fine_tuned_resume_matcher")

def clean_text(text):
    text = re.sub(r'\s+', ' ', text)
    text = re.sub(r'[^\w\s]', '', text)
    return text.lower().strip()

def score_resumes(job_description, resumes_text, industry, experience):
    job_clean = clean_text(job_description)
    resumes_clean = [clean_text(text) for text in resumes_text]
    
    job_embedding = model.encode(job_description, convert_to_tensor=True)
    resume_embeddings = model.encode(resumes_text, convert_to_tensor=True)
    semantic_sim = util.cos_sim(job_embedding, resume_embeddings).flatten().tolist()

    corpus = [job_clean] + resumes_clean
    vectorizer = TfidfVectorizer(ngram_range=(1, 3), stop_words='english')
    tfidf_matrix = vectorizer.fit_transform(corpus)
    tfidf_sim = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:]).flatten().tolist()

    feature_names = vectorizer.get_feature_names_out()
    job_tfidf_scores = tfidf_matrix[0].toarray().flatten()
    indices = job_tfidf_scores.argsort()[::-1]
    key_phrases = [feature_names[i] for i in indices if job_tfidf_scores[i] > 0][:20]

    scores = []
    for idx, resume_clean in enumerate(resumes_clean):
        num_matches = sum(1 for phrase in key_phrases if phrase in resume_clean)
        skill_match_ratio = num_matches / len(key_phrases) if key_phrases else 0

        job_words = set(job_clean.split())
        resume_words = set(resume_clean.split())
        common_words = job_words.intersection(resume_words)
        match_ratio = len(common_words) / len(job_words) if job_words else 0
        regex_boost = match_ratio

        industry_match = 1.0 if industry.lower() in resume_clean else 0.0
        exp_required = int(experience.split("+")[0])
        exp_match = 1.0 if re.search(r'\b\d+\+?\s*years?\b', resume_clean) and \
                    int(re.search(r'\d+', resume_clean).group()) >= exp_required else 0.0
        metadata_score = 0.5 * industry_match + 0.5 * exp_match

        # Store raw components
        raw_components = {
            "semantic": min(0.2, 0.2 * semantic_sim[idx]),
            "tfidf": min(0.1, 0.1 * tfidf_sim[idx]),
            "skill": min(0.1, 0.1 * skill_match_ratio),
            "regex_boost": min(0.4, 0.4 * regex_boost),
            "metadata": min(0.2, 0.2 * metadata_score)
        }
        raw_total = sum(raw_components.values())
        
        # Scaling based on regex_boost (scale up only)
        max_weights = {
            "semantic": 0.2,
            "tfidf": 0.1,
            "skill": 0.1,
            "regex_boost": 0.4,
            "metadata": 0.2
        }
        regex_boost_raw = raw_components["regex_boost"]
        boost_factor = 0.5  # Adjusts max scale-up (e.g., 0.5 means max +50% at 40% regex)
        scaling_factor = 1.0 + (regex_boost_raw / 0.4) * boost_factor
        scaled_total = min(1.0, raw_total * scaling_factor)  # Scale up, cap at 100%
        
        # Adjust components proportionally
        score = {
            "raw_total": raw_total,
            "raw_components": raw_components.copy(),
            "total": scaled_total,
            **raw_components
        }
        if raw_total > 0:
            scale_ratio = scaled_total / raw_total
            for key in max_weights:
                score[key] = min(max_weights[key], raw_components[key] * scale_ratio)
        
        scores.append(score)
    
    return scores

@app.route('/', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        if username in USER_CREDENTIALS and USER_CREDENTIALS[username] == password:
            session['user'] = username
            return redirect(url_for('home'))
        else:
            return render_template('login.html', error="Invalid username or password")
    return render_template('login.html')

@app.route('/candidate/<path:candidate_id>')
def candidate_detail(candidate_id):
    if 'user' not in session:
        return redirect(url_for('login'))
    decoded_filename = unquote(candidate_id)
    candidate_details = load_candidate_details()
    candidate = candidate_details.get(decoded_filename)
    if not candidate:
        return f"Candidate '{decoded_filename}' not found", 404
    return render_template('candidate_detail.html', candidate=candidate)

@app.route('/home', methods=['GET', 'POST'])
def home():
    if 'user' not in session:
        return redirect(url_for('login'))

    if request.method == 'POST':
        selected_industry = request.form.get("industry_type")
        selected_experience = request.form.get("experience")
        selected_gender = request.form.get("gender")
        job_description = request.form.get("job_description")
        uploaded_files = request.files.getlist("resumes")

        resumes_text = []
        valid_files = []
        skipped_files = []
        candidate_details = {}
        results = []

        for file in uploaded_files:
            if not file.filename:
                continue
            file_path = os.path.join(app.config['UPLOAD_FOLDER'], file.filename)
            file.save(file_path)
            text = extract_text_from_file(file_path)
            if is_valid_resume(text):
                resumes_text.append(text)
                valid_files.append(file)
            else:
                skipped_files.append(file.filename)
                os.remove(file_path)

        if not valid_files:
            return render_template('index.html', error="No valid resumes uploaded. Please upload readable PDF or DOCX files.")

        scores = score_resumes(job_description, resumes_text, selected_industry, selected_experience)

        for idx, (resume, score) in enumerate(zip(valid_files, scores)):
            filename = resume.filename
            candidate_details[filename] = {
                "filename": filename,
                "score_breakdown": score,
                "resume_text": resumes_text[idx],
                "explanation": generate_explanation(score)
            }
            results.append((resume, score["total"]))

        results = sorted(results, key=lambda x: x[1], reverse=True)

        histogram_data = [0, 0, 0, 0]
        for _, score in results:
            if score < 0.5:
                histogram_data[0] += 1
            elif score < 0.7:
                histogram_data[1] += 1
            elif score < 0.85:
                histogram_data[2] += 1
            else:
                histogram_data[3] += 1

        top_candidate = results[0][0].filename
        top_breakdown = candidate_details[top_candidate]['score_breakdown']

        radar_keys = ["semantic", "tfidf", "skill", "regex_boost", "metadata"]
        average_breakdown = {}
        for key in radar_keys:
            values = [candidate_details[resume.filename]['score_breakdown'].get(key, 0.0) for resume, _ in results]
            average_breakdown[key] = sum(values) / len(values) if values else 0.0

        save_candidate_details(candidate_details)

        return render_template(
            'results.html',
            results=results,
            industry_type=selected_industry,
            experience=selected_experience,
            gender=selected_gender,
            histogram_data=histogram_data,
            top_breakdown=top_breakdown,
            average_breakdown=average_breakdown,
            candidate_details=candidate_details,
            skipped_files=skipped_files
        )

    return render_template('index.html')

def generate_explanation(breakdown):
    explanations = []
    raw_semantic = breakdown.get('raw_components', {}).get('semantic', 0.0)
    raw_tfidf = breakdown.get('raw_components', {}).get('tfidf', 0.0)
    raw_skill = breakdown.get('raw_components', {}).get('skill', 0.0)
    raw_regex_boost = breakdown.get('raw_components', {}).get('regex_boost', 0.0)
    raw_metadata = breakdown.get('raw_components', {}).get('metadata', 0.0)
    raw_total = breakdown.get('raw_total', 0.0)
    
    semantic = breakdown.get('semantic', 0.0)
    tfidf = breakdown.get('tfidf', 0.0)
    skill = breakdown.get('skill', 0.0)
    regex_boost = breakdown.get('regex_boost', 0.0)
    metadata = breakdown.get('metadata', 0.0)
    total = breakdown.get('total', 0.0)

    max_weights = {
        "semantic": 0.2,
        "tfidf": 0.1,
        "skill": 0.1,
        "regex_boost": 0.4,
        "metadata": 0.2
    }

    explanations.append("Component Scores (Raw -> Scaled):")
    explanations.append(f"Semantic Similarity: Max (20%) Raw: {raw_semantic * 100:.2f}% -> Scaled: {semantic * 100:.2f}%")
    explanations.append(f"Keyword Match: Max (10%) Raw: {raw_tfidf * 100:.2f}% -> Scaled: {tfidf * 100:.2f}%")
    explanations.append(f"Skill Match: Max (10%) Raw: {raw_skill * 100:.2f}% -> Scaled: {skill * 100:.2f}%")
    explanations.append(f"Regex Boost: Max (40%) Raw: {raw_regex_boost * 100:.2f}% -> Scaled: {regex_boost * 100:.2f}%")
    explanations.append(f"Metadata Match: Max (20%) Raw: {raw_metadata * 100:.2f}% -> Scaled: {metadata * 100:.2f}%")
    explanations.append(f"Total Score: Raw: {raw_total * 100:.2f}% -> Scaled: {total * 100:.2f}%")
    explanations.append("Note: Total score is scaled up based on Regex Boost (40% max), adding up to 50% boost at 40% regex match.")

    if total > 0.85:
        explanations.append("Excellent match")
    elif total > 0.7:
        explanations.append("Good match")
    elif total > 0.5:
        explanations.append("Moderate match")
    else:
        explanations.append("Weak match")

    return "\n".join(explanations)

@app.route('/logout')
def logout():
    session.pop('user', None)
    if os.path.exists(CANDIDATE_STORAGE):
        os.remove(CANDIDATE_STORAGE)
    return redirect(url_for('login'))

@app.route('/download/<filename>')
def download(filename):
    if 'user' not in session:
        return redirect(url_for('login'))
    return send_from_directory(app.config['UPLOAD_FOLDER'], filename, as_attachment=True)

if __name__ == "__main__":
    # Run Flask with SSL for encrypted data in transit
    app.run(debug=True, ssl_context=('cert.pem', 'key.pem'), host='0.0.0.0', port=5001)